@amenophis1er/foreman 0.1.6 → 0.1.7

package/bin/foreman.mjs

@@ -33,6 +33,7 @@ const USAGE = `foreman ${pkg.version}
 
   foreman uninstall          Remove the service and the background server; keeps ~/.foreman
   foreman uninstall --purge --yes   …and delete ~/.foreman (every run's history) too
+  foreman completion install Tab-completion for these commands (zsh, bash, fish); or "completion zsh" to print it
   foreman --version | --help
 
 Environment:
@@ -55,7 +56,7 @@ if (command === '--help' || command === '-h' || command === 'help') {
 } else if (command === 'start') {
   register();
   await import(new URL('../src/server.ts', import.meta.url).href);
-} else if (['doctor', 'open', 'service', 'up', 'down', 'stop', 'restart', 'status', 'logs', 'uninstall', 'update'].includes(command)) {
+} else if (['doctor', 'open', 'service', 'up', 'down', 'stop', 'restart', 'status', 'logs', 'uninstall', 'update', 'completion'].includes(command)) {
   register();
   const { runCli } = await import(new URL('../src/cli.ts', import.meta.url).href);
   process.exitCode = await runCli(command, rest, { version: pkg.version, bin: new URL(import.meta.url) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amenophis1er/foreman",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Autonomous mission runner on the Claude Agent SDK: a director plans, delegates to workers, verifies, and reports — from one dashboard, your phone, or the CLI.",
   "keywords": [
     "claude",

package/src/cli.ts

@@ -493,6 +493,19 @@ export async function runCli(command: string, rest: string[], ctx: { version: st
     case 'uninstall': return uninstall(rest);
     case 'status': return status();
     case 'doctor': return doctor();
+    case 'completion': {
+      const { completionScript, detectShell, installCompletion } = await import('./completion.js');
+      const arg = rest[0];
+      if (arg === 'zsh' || arg === 'bash' || arg === 'fish') { process.stdout.write(completionScript(arg)); return 0; }
+      if (arg === 'install') {
+        const shell = (rest[1] === 'zsh' || rest[1] === 'bash' || rest[1] === 'fish') ? rest[1] : detectShell();
+        if (!shell) { console.error('Could not tell your shell from $SHELL. Say which: foreman completion install zsh|bash|fish'); return 1; }
+        console.log(await installCompletion(shell));
+        return 0;
+      }
+      console.error('Usage: foreman completion zsh|bash|fish   (prints the script)\n       foreman completion install [zsh|bash|fish]   (adds it to your shell rc, once)');
+      return 1;
+    }
     case 'open': return open();
     case 'service': {
       const sub = rest[0];

package/src/completion.test.ts

@@ -0,0 +1,30 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { COMMANDS, SERVICE_COMMANDS, completionScript, detectShell, installTarget } from './completion.js';
+
+test('every shell script names every command and the service verbs', () => {
+  for (const shell of ['zsh', 'bash', 'fish'] as const) {
+    const s = completionScript(shell);
+    for (const [c] of COMMANDS) assert.ok(s.includes(c), `${shell} lacks ${c}`);
+    for (const c of SERVICE_COMMANDS) assert.ok(s.includes(c), `${shell} lacks service ${c}`);
+    const flags = shell === 'fish' ? ['-l force', '-l purge'] : ['--force', '--purge'];
+    for (const f of flags) assert.ok(s.includes(f), `${shell} lacks flag ${f}`);
+  }
+  assert.match(completionScript('zsh'), /^#compdef foreman\n/);
+  assert.match(completionScript('zsh'), /compdef _foreman foreman\n$/);
+  assert.match(completionScript('bash'), /complete -F _foreman foreman\n$/);
+  assert.match(completionScript('fish'), /^complete -c foreman -f\n/);
+});
+
+test('detectShell reads $SHELL and ignores anything else', () => {
+  assert.equal(detectShell({ SHELL: '/bin/zsh' }), 'zsh');
+  assert.equal(detectShell({ SHELL: '/opt/homebrew/bin/fish' }), 'fish');
+  assert.equal(detectShell({ SHELL: '/bin/tcsh' }), null);
+  assert.equal(detectShell({}), null);
+});
+
+test('installTarget: rc line for zsh and bash, a completions file for fish', () => {
+  assert.deepEqual(installTarget('zsh', '/home/u'), { file: '/home/u/.zshrc', line: 'eval "$(foreman completion zsh)" # foreman completion' });
+  assert.equal(installTarget('bash', '/home/u').file, '/home/u/.bashrc');
+  assert.deepEqual(installTarget('fish', '/home/u'), { file: '/home/u/.config/fish/completions/foreman.fish' });
+});

package/src/completion.ts

@@ -0,0 +1,113 @@
+/**
+ * Shell completion for the `foreman` command.
+ *
+ * `foreman completion <shell>` prints a script; `foreman completion install`
+ * wires it into the shell's rc file, once, behind a marker — the only file
+ * outside ~/.foreman the CLI ever writes, and only when asked by name.
+ */
+import os from 'node:os';
+import path from 'node:path';
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+
+export type Shell = 'zsh' | 'bash' | 'fish';
+
+/** Every top-level command with the one line the menu shows for it. Keep in step with bin/foreman.mjs USAGE. */
+export const COMMANDS: Array<[string, string]> = [
+  ['start', 'Start in this terminal'],
+  ['up', 'Start in the background'],
+  ['stop', 'Stop it, however it was started'],
+  ['restart', 'Stop and start it again the same way'],
+  ['status', 'Is a server up, on which port, started how'],
+  ['logs', 'Tail the log'],
+  ['open', 'Open the dashboard in your browser'],
+  ['doctor', 'Check credentials, providers, browser, port, Tailscale'],
+  ['update', 'Install the latest version and restart'],
+  ['service', 'Keep Foreman running at login'],
+  ['uninstall', 'Remove the service and the background server'],
+  ['completion', 'Shell completion: zsh, bash, fish, or install'],
+  ['help', 'Show usage'],
+  ['version', 'Print the version'],
+];
+export const SERVICE_COMMANDS = ['install', 'uninstall', 'start', 'stop', 'restart', 'status', 'logs'];
+export const COMPLETION_ARGS = ['zsh', 'bash', 'fish', 'install'];
+const FLAGS: Record<string, string[]> = { update: ['--force'], uninstall: ['--purge', '--yes'] };
+
+const q = (s: string) => `'${s.replace(/'/g, "'\\''")}'`;
+
+export function completionScript(shell: Shell): string {
+  const names = COMMANDS.map(([c]) => c).join(' ');
+  if (shell === 'zsh') {
+    return [
+      '#compdef foreman',
+      '_foreman() {',
+      '  local -a cmds',
+      `  cmds=(${COMMANDS.map(([c, d]) => q(`${c}:${d}`)).join(' ')})`,
+      '  if (( CURRENT == 2 )); then _describe -t commands "foreman command" cmds; return; fi',
+      '  case "${words[2]}" in',
+      `    service) local -a svc; svc=(${SERVICE_COMMANDS.map(q).join(' ')}); _describe -t commands "service command" svc ;;`,
+      `    completion) local -a sh; sh=(${COMPLETION_ARGS.map(q).join(' ')}); _describe -t commands "shell" sh ;;`,
+      ...Object.entries(FLAGS).map(([c, f]) => `    ${c}) local -a fl; fl=(${f.map(q).join(' ')}); _describe -t options "flag" fl ;;`),
+      '  esac',
+      '}',
+      'compdef _foreman foreman',
+      '',
+    ].join('\n');
+  }
+  if (shell === 'bash') {
+    return [
+      '_foreman() {',
+      '  local cur prev',
+      '  cur="${COMP_WORDS[COMP_CWORD]}"',
+      '  prev="${COMP_WORDS[COMP_CWORD-1]}"',
+      `  if [ "$COMP_CWORD" -eq 1 ]; then COMPREPLY=( $(compgen -W "${names}" -- "$cur") ); return; fi`,
+      '  case "$prev" in',
+      `    service) COMPREPLY=( $(compgen -W "${SERVICE_COMMANDS.join(' ')}" -- "$cur") ) ;;`,
+      `    completion) COMPREPLY=( $(compgen -W "${COMPLETION_ARGS.join(' ')}" -- "$cur") ) ;;`,
+      ...Object.entries(FLAGS).map(([c, f]) => `    ${c}) COMPREPLY=( $(compgen -W "${f.join(' ')}" -- "$cur") ) ;;`),
+      '  esac',
+      '}',
+      'complete -F _foreman foreman',
+      '',
+    ].join('\n');
+  }
+  return [
+    'complete -c foreman -f',
+    ...COMMANDS.map(([c, d]) => `complete -c foreman -n __fish_use_subcommand -a ${c} -d ${q(d)}`),
+    `complete -c foreman -n '__fish_seen_subcommand_from service' -a '${SERVICE_COMMANDS.join(' ')}'`,
+    `complete -c foreman -n '__fish_seen_subcommand_from completion' -a '${COMPLETION_ARGS.join(' ')}'`,
+    ...Object.entries(FLAGS).flatMap(([c, f]) => f.map((flag) => `complete -c foreman -n '__fish_seen_subcommand_from ${c}' -l ${flag.replace(/^--/, '')}`)),
+    '',
+  ].join('\n');
+}
+
+/** The user's shell from $SHELL, or null when it is none of the three. */
+export function detectShell(env: NodeJS.ProcessEnv = process.env): Shell | null {
+  const name = path.basename(env.SHELL ?? '');
+  return name === 'zsh' || name === 'bash' || name === 'fish' ? name : null;
+}
+
+const MARKER = '# foreman completion';
+
+/**
+ * Where the hook goes, and what it is. zsh and bash source the script at
+ * shell start; fish loads a file from its completions directory on demand.
+ */
+export function installTarget(shell: Shell, home = os.homedir()): { file: string; line?: string } {
+  if (shell === 'fish') return { file: path.join(home, '.config', 'fish', 'completions', 'foreman.fish') };
+  const file = shell === 'zsh' ? path.join(home, '.zshrc') : path.join(home, '.bashrc');
+  return { file, line: `eval "$(foreman completion ${shell})" ${MARKER}` };
+}
+
+/** Idempotent: a second install finds the marker and changes nothing. Returns what happened. */
+export async function installCompletion(shell: Shell, home = os.homedir()): Promise<string> {
+  const target = installTarget(shell, home);
+  if (!target.line) {
+    await mkdir(path.dirname(target.file), { recursive: true });
+    await writeFile(target.file, completionScript('fish'));
+    return `Wrote ${target.file}. Open a new fish shell.`;
+  }
+  const current = await readFile(target.file, 'utf8').catch(() => '');
+  if (current.includes(MARKER)) return `Already installed in ${target.file}.`;
+  await appendFile(target.file, `${current.endsWith('\n') || !current ? '' : '\n'}${target.line}\n`);
+  return `Added one line to ${target.file}. Open a new shell, or run: source ${target.file}`;
+}

package/src/server.ts

@@ -24,6 +24,7 @@
  *   POST   /runs/{id}/resume     Resume an interrupted/failed run
  *   POST   /permission           Resolve an approval {id, behavior, message?}
  *   POST   /answer               Answer a director question {id, text}
+ *   GET    /search?q=            Runs across the fleet matching title, brief, project or folder
  *   POST   /fleet/chat           One turn with the fleet planner {text} → {text, costUsd}
  *   POST   /fleet/stop           Stop the fleet planner reply in flight
  *   DELETE /fleet/chat           Forget the fleet conversation
@@ -2193,6 +2194,26 @@ const server = http.createServer(async (req, res) => {
       if (!ok) return json(res, 404, { error: 'no pending question with that id' });
       json(res, 200, { ok: true });
 
+    } else if (req.method === 'GET' && url.pathname === '/search') {
+      // Every run across the fleet whose title, brief, project or folder
+      // says the words. Run records are small and already on disk; no index.
+      const q = (url.searchParams.get('q') ?? '').trim().toLowerCase();
+      if (q.length < 2) return json(res, 200, { runs: [] });
+      const [runs, projects] = await Promise.all([store.listRuns(), store.listProjects()]);
+      const byFolder = new Map(projects.map((p) => [p.folder, p]));
+      const hits = runs.filter((r) => {
+        const project = byFolder.get(r.folder);
+        return [r.title, r.mission, r.folder, project?.name].some((f) => f?.toLowerCase().includes(q));
+      }).sort((a, b) => b.createdAt - a.createdAt).slice(0, 30).map((r) => {
+        const project = byFolder.get(r.folder);
+        return {
+          id: r.id, projectId: r.projectId ?? project?.id ?? null, projectName: project?.name ?? path.basename(r.folder),
+          folder: r.folder, title: r.title, mission: firstLine(r.mission), status: r.status,
+          createdAt: r.createdAt, endedAt: r.endedAt, costUsd: r.costUsd, costBasis: costBasisOf(r),
+        };
+      });
+      json(res, 200, { runs: hits });
+
     } else if (req.method === 'POST' && url.pathname === '/fleet/chat') {
       // One turn at the front desk, answered in the response. The same
       // session the phone uses, so a conversation can move between them.