Merge pull request #6 from writingdeveloper/feat/git-insights-and-scan

Unpushed signal + nested-repo scan + open-in-editor (DECK-13/12/10)

Author: writingdeveloper

scripts/demo-fixture.mjs

@@ -39,7 +39,7 @@ const user = (text) => JSON.stringify({ type: 'user', message: { content: text }
 // stale days chosen for a balanced traffic-light spread (fresh<1, neutral<3, warn<7, else neglected).
 // usageDaysAgo clustered in the last week for a clean Usage chart (decoupled from deck staleness).
 const PROJECTS = [
-  { name: 'acme-dashboard', branch: 'main', stale: 0, dirty: 3,
+  { name: 'acme-dashboard', branch: 'main', stale: 0, dirty: 3, ahead: 2,
     commit: 'feat(ui): dark mode toggle + theme persistence',
     sessions: [{ first: 'scaffold the settings page', cue: 'add a dark mode toggle to the settings page', model: 'claude-opus-4-8', usageDaysAgo: [0, 1] }] },
   { name: 'payments-api', branch: 'feat/refunds', stale: 0, dirty: 1,
@@ -76,6 +76,17 @@ for (const p of PROJECTS) {
   git(repo, ['add', '-A'], d);
   git(repo, ['commit', '-m', p.commit], d);
   if (p.branch !== 'main') git(repo, ['checkout', '-b', p.branch], d);
+  // simulate unpushed commits: set an upstream ref at the current HEAD, then commit ahead of it
+  if (p.ahead) {
+    git(repo, ['remote', 'add', 'origin', 'https://example.invalid/repo.git'], d); // sets remote.origin.fetch refspec
+    git(repo, ['update-ref', `refs/remotes/origin/${p.branch}`, 'HEAD'], d);
+    git(repo, ['branch', `--set-upstream-to=origin/${p.branch}`, p.branch], d);
+    for (let i = 0; i < p.ahead; i++) {
+      writeFileSync(join(repo, `local_${i}.js`), `// local work ${i}\n`);
+      git(repo, ['add', '-A'], d);
+      git(repo, ['commit', '-m', `feat: local work ${i}`], d);
+    }
+  }
   // leave N uncommitted changes
   for (let i = 0; i < p.dirty; i++) writeFileSync(join(repo, `wip_${i}.txt`), `work in progress ${i}\n`);
 
@@ -94,5 +105,20 @@ for (const p of PROJECTS) {
   });
 }
 
-console.log('projects:', PROJECTS.length, '| sessions:', sid);
+// nested org/repo (depth 2) to exercise nested scanning: acme-labs/ is a non-repo dir holding a repo
+const np = join(REPOS, 'acme-labs', 'prototype');
+const nd = iso(3);
+mkdirSync(np, { recursive: true });
+git(np, ['-c', 'init.defaultBranch=main', 'init'], nd);
+writeFileSync(join(np, 'README.md'), '# prototype\n');
+git(np, ['add', '-A'], nd);
+git(np, ['commit', '-m', 'init prototype scaffold'], nd);
+const nsd = join(CLAUDE, encode(np));
+mkdirSync(nsd, { recursive: true });
+const nf = join(nsd, uuid(sid++) + '.jsonl');
+writeFileSync(nf, [user('scaffold the prototype'), asst('claude-sonnet-4-6', iso(3, 11), 30000, 5000, 80000), user('wire up the auth flow')].join('\n'));
+const nms = NOW - 3 * DAY;
+utimesSync(nf, new Date(nms), new Date(nms));
+
+console.log('projects:', PROJECTS.length + 1, '| sessions:', sid);
 console.log(HOME);

src/main/gitInfo.test.ts

@@ -5,6 +5,7 @@ import { getGitInfo } from './gitInfo';
 function fakeRunner(map: Record<string, string>) {
   return async (args: string[]): Promise<string> => {
     if (args.includes('rev-parse')) return map.branch ?? '';
+    if (args.includes('rev-list')) return map.ahead ?? '';
     if (args.includes('log')) return map.log ?? '';
     if (args.includes('status')) return map.status ?? '';
     return '';
@@ -17,15 +18,26 @@ describe('getGitInfo', () => {
       branch: 'main\n',
       log: '1717287840|scaffold\n',
       status: ' M a.ts\n?? b.ts\n',
+      ahead: '2\n',
     });
     expect(await getGitInfo('C:\\g\\x', run)).toEqual({
       branch: 'main',
       lastCommitMs: 1717287840000,
       lastSubject: 'scaffold',
       uncommitted: 2,
+      ahead: 2,
     });
   });
 
+  it('reports null ahead when there is no upstream (rev-list throws)', async () => {
+    const run = async (args: string[]): Promise<string> => {
+      if (args.includes('rev-list')) throw new Error('no upstream');
+      if (args.includes('rev-parse')) return 'main\n';
+      return '';
+    };
+    expect((await getGitInfo('C:\\g\\x', run)).ahead).toBeNull();
+  });
+
   it('handles a repo with no commits', async () => {
     const run = fakeRunner({ branch: 'main\n', log: '', status: '' });
     const info = await getGitInfo('C:\\g\\x', run);

src/main/gitInfo.ts

@@ -1,7 +1,7 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import type { GitInfo } from '../shared/types';
-import { parseBranch, parseLastCommit, parsePorcelainCount } from '../shared/gitParse';
+import { parseBranch, parseLastCommit, parsePorcelainCount, parseAheadCount } from '../shared/gitParse';
 
 const execFileAsync = promisify(execFile);
 
@@ -21,16 +21,18 @@ async function safe(run: GitRunner, args: string[]): Promise<string | null> {
 }
 
 export async function getGitInfo(dir: string, run: GitRunner = defaultRunner): Promise<GitInfo> {
-  const [branchOut, logOut, statusOut] = await Promise.all([
+  const [branchOut, logOut, statusOut, aheadOut] = await Promise.all([
     safe(run, ['-C', dir, 'rev-parse', '--abbrev-ref', 'HEAD']),
     safe(run, ['-C', dir, 'log', '-1', '--format=%ct|%s']),
     safe(run, ['-C', dir, 'status', '--porcelain']),
+    safe(run, ['-C', dir, 'rev-list', '--count', '@{upstream}..HEAD']),
   ]);
   const { lastCommitMs, lastSubject } = parseLastCommit(logOut ?? '');
   return {
     branch: branchOut == null ? null : parseBranch(branchOut),
     lastCommitMs,
     lastSubject,
     uncommitted: parsePorcelainCount(statusOut ?? ''),
+    ahead: aheadOut == null ? null : parseAheadCount(aheadOut),
   };
 }

src/main/ipc.ts

@@ -6,7 +6,7 @@ import { scanRepos } from './scanner';
 import { getGitInfo } from './gitInfo';
 import { listSessions, isValidSessionId, lastUserMessageForSession } from './sessions';
 import { buildProjectList } from './projects';
-import { openProjects } from './launcher';
+import { openProjects, openInEditor } from './launcher';
 import type { WtTab } from '../shared/wtArgs';
 import { scanUsage } from './usageScan';
 import { DEFAULT_THRESHOLDS } from '../shared/staleness';
@@ -121,6 +121,15 @@ export function registerIpc(cfg: IpcConfig): void {
     if (err) cfg.sendError(err);
   });
 
+  // Open the project in VS Code (`code <path>`).
+  ipcMain.handle('project:openEditor', (_e, p: string) => {
+    if (!isUnderBase(effBaseDir(), p)) {
+      cfg.sendError(`Path outside base dir: ${p}`);
+      return;
+    }
+    openInEditor(p, { onError: cfg.sendError });
+  });
+
   // Frameless-window controls (the title bar draws its own buttons).
   ipcMain.handle('win:minimize', () => cfg.win.minimize());
   ipcMain.handle('win:toggleMaximize', () => {

src/main/launcher.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { openProjects, resolveShell, resolveWtPath, detectLinuxTerminal } from './launcher';
+import { openProjects, resolveShell, resolveWtPath, detectLinuxTerminal, editorSpec, openInEditor } from './launcher';
 import type { WtTab } from '../shared/wtArgs';
 
 type Call = { file: string; args: string[] };
@@ -65,6 +65,24 @@ describe('detectLinuxTerminal', () => {
   });
 });
 
+describe('editorSpec', () => {
+  it('posix: code with the dir as an args-array entry (no shell)', () => {
+    expect(editorSpec('/g/a', 'darwin')).toEqual({ command: 'code', args: ['/g/a'], shell: false });
+    expect(editorSpec('/g/a', 'linux')).toEqual({ command: 'code', args: ['/g/a'], shell: false });
+  });
+  it('windows: quoted path through a shell (code is code.cmd)', () => {
+    expect(editorSpec('C:\\g\\a', 'win32')).toEqual({ command: 'code "C:\\g\\a"', args: [], shell: true });
+  });
+});
+
+describe('openInEditor', () => {
+  it('dispatches the editor spec to spawnFn', () => {
+    let got: { c: string; a: string[]; s: boolean } | null = null;
+    openInEditor('/g/a', { platform: 'linux', spawnFn: (c, a, s) => { got = { c, a, s }; } });
+    expect(got).toEqual({ c: 'code', a: ['/g/a'], s: false });
+  });
+});
+
 describe('resolveShell', () => {
   it('returns pwsh when present', () => { expect(resolveShell(() => true)).toBe('pwsh'); });
   it('falls back to powershell when absent', () => { expect(resolveShell(() => false)).toBe('powershell'); });

src/main/launcher.ts

@@ -88,6 +88,37 @@ function defaultSpawn(onError?: (msg: string) => void): SpawnFn {
   };
 }
 
+export interface EditorSpec { command: string; args: string[]; shell: boolean; }
+
+/**
+ * How to launch VS Code at a directory. On POSIX `code` is a plain script — pass the
+ * dir as an args-array entry (no shell = injection-safe). On Windows `code` is
+ * `code.cmd`, which Node can only run through a shell, so quote the path (Windows
+ * paths cannot contain `"`, so the quoting is safe).
+ */
+export function editorSpec(dir: string, platform: NodeJS.Platform = process.platform): EditorSpec {
+  if (platform === 'win32') return { command: `code "${dir}"`, args: [], shell: true };
+  return { command: 'code', args: [dir], shell: false };
+}
+
+export interface EditorOptions {
+  platform?: NodeJS.Platform;
+  spawnFn?: (command: string, args: string[], shell: boolean) => void;
+  onError?: (msg: string) => void;
+}
+
+/** Open a directory in VS Code (`code <dir>`). */
+export function openInEditor(dir: string, opts: EditorOptions = {}): void {
+  const spec = editorSpec(dir, opts.platform ?? process.platform);
+  if (opts.spawnFn) { opts.spawnFn(spec.command, spec.args, spec.shell); return; }
+  const child = spawn(spec.command, spec.args, { detached: true, stdio: 'ignore', shell: spec.shell, windowsHide: false });
+  child.on('error', (err) => {
+    console.error('DevDeck: failed to open editor', err);
+    opts.onError?.(`Failed to open editor (is the \`code\` CLI on your PATH?): ${(err as Error).message}`);
+  });
+  child.unref();
+}
+
 /** Open each project in a platform-appropriate terminal running its command. */
 export function openProjects(tabs: WtTab[], opts: OpenOptions = {}): void {
   if (tabs.length === 0) return;

src/main/projects.test.ts

@@ -20,6 +20,7 @@ function deps(over: Partial<BuildDeps>): BuildDeps {
       lastCommitMs: dir.endsWith('fresh') ? NOW - 3_600_000 : NOW - 10 * DAY,
       lastSubject: 'x',
       uncommitted: 0,
+      ahead: null,
     }),
     sessions: () => [],
     resumeCue: () => null,
@@ -59,7 +60,7 @@ describe('buildProjectList', () => {
   it('wires sessions + sessionCount and uses the latest session for activity', async () => {
     const NOW2 = NOW;
     const list = await buildProjectList(deps({
-      git: async (): Promise<GitInfo> => ({ branch: 'main', lastCommitMs: null, lastSubject: null, uncommitted: 0 }),
+      git: async (): Promise<GitInfo> => ({ branch: 'main', lastCommitMs: null, lastSubject: null, uncommitted: 0, ahead: 4 }),
       sessions: (p) => p.endsWith('fresh')
         ? [{ id: 'x', mtimeMs: NOW2 - 3_600_000, firstMessage: 'hi' }]
         : [],
@@ -69,6 +70,7 @@ describe('buildProjectList', () => {
     expect(fresh.sessions[0].firstMessage).toBe('hi');
     expect(fresh.lastSessionMs).toBe(NOW2 - 3_600_000);
     expect(fresh.stale.level).toBe('fresh');
+    expect(fresh.ahead).toBe(4); // unpushed count threaded through
   });
 
   it('derives resumeCue from the newest session via the dep', async () => {

src/main/projects.ts

@@ -34,6 +34,7 @@ export async function buildProjectList(deps: BuildDeps): Promise<ProjectViewMode
         name: r.name,
         branch: git.branch,
         uncommitted: git.uncommitted,
+        ahead: git.ahead,
         lastCommitMs: git.lastCommitMs,
         lastSubject: git.lastSubject,
         lastSessionMs,

src/main/scanner.test.ts

@@ -24,4 +24,19 @@ describe('scanRepos', () => {
     const repos = await scanRepos(base);
     expect(repos[0].path.startsWith(base)).toBe(true);
   });
+
+  it('finds org/repo (depth 2) but not repos inside a repo or beyond maxDepth', async () => {
+    mkdirSync(join(base, 'org', 'repoX', '.git'), { recursive: true });   // depth-2 repo under a non-repo
+    mkdirSync(join(base, 'org', 'repoY', '.git'), { recursive: true });
+    mkdirSync(join(base, 'projA', 'nested', '.git'), { recursive: true }); // inside a repo -> NOT scanned
+    mkdirSync(join(base, 'deep', 'a', 'b', '.git'), { recursive: true });  // depth 3 -> NOT scanned
+    const repos = (await scanRepos(base)).map((p) => p.name).sort();
+    expect(repos).toEqual(['projA', 'projB', 'repoX', 'repoY']);
+  });
+
+  it('respects an explicit maxDepth of 1 (top level only)', async () => {
+    mkdirSync(join(base, 'org', 'repoX', '.git'), { recursive: true });
+    const repos = (await scanRepos(base, 1)).map((p) => p.name).sort();
+    expect(repos).toEqual(['projA', 'projB']);
+  });
 });

src/main/scanner.ts

@@ -1,31 +1,46 @@
 import { readdir, access } from 'node:fs/promises';
 import { join } from 'node:path';
 
-const IGNORE = new Set(['__pycache__', '.pytest_cache', '.claude', '.playwright-mcp']);
+const IGNORE = new Set(['__pycache__', '.pytest_cache', '.claude', '.playwright-mcp', 'node_modules']);
 
 export interface RawProject {
   path: string;
   name: string;
 }
 
-export async function scanRepos(baseDir: string): Promise<RawProject[]> {
-  const out: RawProject[] = [];
+async function isRepo(dir: string): Promise<boolean> {
+  try {
+    await access(join(dir, '.git'));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function walk(dir: string, depth: number, maxDepth: number, out: RawProject[]): Promise<void> {
   let entries;
   try {
-    entries = await readdir(baseDir, { withFileTypes: true });
+    entries = await readdir(dir, { withFileTypes: true });
   } catch {
-    return out;
+    return;
   }
   await Promise.all(
     entries
       .filter((e) => e.isDirectory() && !e.name.startsWith('.') && !IGNORE.has(e.name))
       .map(async (entry) => {
-        const full = join(baseDir, entry.name);
-        try {
-          await access(join(full, '.git'));
-          out.push({ path: full, name: entry.name });
-        } catch { /* no .git */ }
+        const full = join(dir, entry.name);
+        if (await isRepo(full)) {
+          out.push({ path: full, name: entry.name }); // a repo — include it, don't descend into it
+        } else if (depth < maxDepth) {
+          await walk(full, depth + 1, maxDepth, out); // not a repo — look one level deeper (org/repo layouts)
+        }
       }),
   );
+}
+
+/** Find git repos under baseDir, scanning up to maxDepth levels (default 2 = org/repo). */
+export async function scanRepos(baseDir: string, maxDepth = 2): Promise<RawProject[]> {
+  const out: RawProject[] = [];
+  await walk(baseDir, 1, maxDepth, out);
   return out;
 }