@gh-symphony/cli 0.0.14 → 0.0.15

package/dist/recover-T6ME6C56.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import {
+  runCli
+} from "./chunk-RNWX7DQU.js";
+import {
+  resolveRuntimeRoot
+} from "./chunk-5NV3LSAJ.js";
+import {
+  handleMissingManagedProjectConfig,
+  resolveManagedProjectConfig
+} from "./chunk-TH5QPO3Y.js";
+import "./chunk-ROGRTUFI.js";
+
+// src/commands/recover.ts
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+function parseRecoverArgs(args) {
+  const parsed = { dryRun: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--dry-run") {
+      parsed.dryRun = true;
+    }
+    if (arg === "--project" || arg === "--project-id") {
+      parsed.projectId = args[i + 1];
+      i += 1;
+    }
+  }
+  return parsed;
+}
+var handler = async (args, options) => {
+  const parsed = parseRecoverArgs(args);
+  const projectConfig = await resolveManagedProjectConfig({
+    configDir: options.configDir,
+    requestedProjectId: parsed.projectId
+  });
+  if (!projectConfig) {
+    handleMissingManagedProjectConfig();
+    return;
+  }
+  const runtimeRoot = resolveRuntimeRoot(options.configDir);
+  const projectId = projectConfig.projectId;
+  if (parsed.dryRun) {
+    process.stdout.write("Dry run \u2014 scanning for stalled runs...\n");
+    const candidates = await listRecoverCandidates(runtimeRoot, projectId);
+    if (options.json) {
+      process.stdout.write(JSON.stringify(candidates, null, 2) + "\n");
+      return;
+    }
+    if (candidates.length === 0) {
+      process.stdout.write("No recoverable runs found.\n");
+      return;
+    }
+    for (const candidate of candidates) {
+      process.stdout.write(
+        `${candidate.issueIdentifier} (${candidate.runId}) \u2014 ${candidate.reason}
+`
+      );
+    }
+    return;
+  }
+  process.stdout.write("Recovering stalled runs...\n");
+  await runCli([
+    "recover",
+    "--runtime-root",
+    runtimeRoot,
+    "--project-id",
+    projectId
+  ]);
+};
+var recover_default = handler;
+async function listRecoverCandidates(runtimeRoot, projectId) {
+  const runsDir = join(runtimeRoot, "projects", projectId, "runs");
+  const candidates = [];
+  let entries = [];
+  try {
+    entries = await readdir(runsDir);
+  } catch {
+    return candidates;
+  }
+  for (const entry of entries) {
+    const runPath = join(runsDir, entry, "run.json");
+    try {
+      const raw = await readFile(runPath, "utf8");
+      const run = JSON.parse(raw);
+      if (run.projectId !== projectId) {
+        continue;
+      }
+      const reason = detectRecoveryReason(run);
+      if (!reason) {
+        continue;
+      }
+      candidates.push({
+        runId: run.runId,
+        issueIdentifier: run.issueIdentifier,
+        status: run.status,
+        reason
+      });
+    } catch {
+    }
+  }
+  return candidates;
+}
+function detectRecoveryReason(run) {
+  if (run.processId) {
+    const startedAt = run.startedAt ? new Date(run.startedAt).getTime() : 0;
+    const runningForMs = Date.now() - startedAt;
+    if (isProcessRunning(run.processId) && runningForMs > 30 * 60 * 1e3) {
+      return "worker appears stuck";
+    }
+    if (!isProcessRunning(run.processId)) {
+      return "worker process is no longer running";
+    }
+  }
+  if (run.status === "retrying" && run.nextRetryAt && new Date(run.nextRetryAt).getTime() <= Date.now()) {
+    return "retry window has elapsed";
+  }
+  return null;
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  recover_default as default
+};

package/dist/repo-R3XBIVAX.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import {
+  loadActiveProjectConfig,
+  loadGlobalConfig,
+  saveProjectConfig
+} from "./chunk-ROGRTUFI.js";
+
+// src/commands/repo.ts
+var handler = async (args, options) => {
+  const [subcommand, ...rest] = args;
+  switch (subcommand) {
+    case "list":
+      await repoList(options);
+      break;
+    case "add":
+      await repoAdd(rest, options);
+      break;
+    case "remove":
+      await repoRemove(rest, options);
+      break;
+    default:
+      process.stderr.write(
+        "Usage: gh-symphony repo <list|add|remove> [repo]\n"
+      );
+      process.exitCode = 2;
+  }
+};
+var repo_default = handler;
+async function repoList(options) {
+  const ws = await loadActiveProjectConfig(options.configDir);
+  if (!ws) {
+    process.stderr.write("No project configured.\n");
+    process.exitCode = 1;
+    return;
+  }
+  if (options.json) {
+    process.stdout.write(JSON.stringify(ws.repositories, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write("Repositories:\n");
+  for (const repo of ws.repositories) {
+    process.stdout.write(`  ${repo.owner}/${repo.name}
+`);
+  }
+}
+async function repoAdd(args, options) {
+  const [repoSpec] = args;
+  if (!repoSpec || !repoSpec.includes("/")) {
+    process.stderr.write("Usage: gh-symphony repo add <owner/name>\n");
+    process.exitCode = 2;
+    return;
+  }
+  const global = await loadGlobalConfig(options.configDir);
+  if (!global?.activeProject) {
+    process.stderr.write("No active project.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const ws = await loadActiveProjectConfig(options.configDir);
+  if (!ws) {
+    process.stderr.write("Project config missing.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const [owner, name] = repoSpec.split("/");
+  if (!owner || !name) {
+    process.stderr.write("Invalid repo format. Use: owner/name\n");
+    process.exitCode = 2;
+    return;
+  }
+  if (ws.repositories.some((r) => r.owner === owner && r.name === name)) {
+    process.stdout.write(`Repository ${repoSpec} is already configured.
+`);
+    return;
+  }
+  ws.repositories.push({
+    owner,
+    name,
+    cloneUrl: `https://github.com/${owner}/${name}.git`
+  });
+  await saveProjectConfig(options.configDir, global.activeProject, ws);
+  process.stdout.write(`Added repository: ${repoSpec}
+`);
+}
+async function repoRemove(args, options) {
+  const [repoSpec] = args;
+  if (!repoSpec || !repoSpec.includes("/")) {
+    process.stderr.write("Usage: gh-symphony repo remove <owner/name>\n");
+    process.exitCode = 2;
+    return;
+  }
+  const global = await loadGlobalConfig(options.configDir);
+  if (!global?.activeProject) {
+    process.stderr.write("No active project.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const ws = await loadActiveProjectConfig(options.configDir);
+  if (!ws) {
+    process.stderr.write("Project config missing.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const [owner, name] = repoSpec.split("/");
+  const idx = ws.repositories.findIndex(
+    (r) => r.owner === owner && r.name === name
+  );
+  if (idx === -1) {
+    process.stderr.write(`Repository ${repoSpec} is not configured.
+`);
+    process.exitCode = 1;
+    return;
+  }
+  ws.repositories.splice(idx, 1);
+  await saveProjectConfig(options.configDir, global.activeProject, ws);
+  process.stdout.write(`Removed repository: ${repoSpec}
+`);
+}
+export {
+  repo_default as default
+};

package/dist/run-DYINRZHK.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import {
+  runCli
+} from "./chunk-RNWX7DQU.js";
+import {
+  resolveRuntimeRoot
+} from "./chunk-5NV3LSAJ.js";
+import {
+  handleMissingManagedProjectConfig,
+  resolveManagedProjectConfig
+} from "./chunk-TH5QPO3Y.js";
+import "./chunk-ROGRTUFI.js";
+
+// src/commands/run.ts
+function parseRunArgs(args) {
+  const parsed = {
+    watch: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--watch" || arg === "-w") {
+      parsed.watch = true;
+    } else if (arg === "--project" || arg === "--project-id") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        parsed.error = `Option '${arg}' argument missing`;
+        return parsed;
+      }
+      parsed.projectId = value;
+      i += 1;
+    } else if (arg === "--log-level") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        parsed.error = `Option '${arg}' argument missing`;
+        return parsed;
+      }
+      parsed.logLevel = value;
+      i += 1;
+    } else if (!arg?.startsWith("-")) {
+      parsed.issue = arg;
+    } else {
+      parsed.error = `Unknown option '${arg}'`;
+      return parsed;
+    }
+  }
+  return parsed;
+}
+var handler = async (args, options) => {
+  const parsed = parseRunArgs(args);
+  if (parsed.error) {
+    process.stderr.write(`${parsed.error}
+`);
+    process.exitCode = 2;
+    return;
+  }
+  if (!parsed.issue) {
+    process.stderr.write("Usage: gh-symphony run <owner/repo#number>\n");
+    process.exitCode = 2;
+    return;
+  }
+  const projectConfig = await resolveManagedProjectConfig({
+    configDir: options.configDir,
+    requestedProjectId: parsed.projectId
+  });
+  if (!projectConfig) {
+    handleMissingManagedProjectConfig();
+    return;
+  }
+  const runtimeRoot = resolveRuntimeRoot(options.configDir);
+  const projectId = projectConfig.projectId;
+  const [repoSpec] = parsed.issue.split("#");
+  if (repoSpec && !projectConfig.repositories.some((r) => `${r.owner}/${r.name}` === repoSpec)) {
+    process.stderr.write(
+      `Repository "${repoSpec}" is not configured in this project.
+Configured repos: ${projectConfig.repositories.map((r) => `${r.owner}/${r.name}`).join(", ")}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`Dispatching issue: ${parsed.issue}
+`);
+  await runCli([
+    "run-issue",
+    "--runtime-root",
+    runtimeRoot,
+    "--project-id",
+    projectId,
+    "--issue",
+    parsed.issue,
+    ...parsed.logLevel ? ["--log-level", parsed.logLevel] : []
+  ]);
+  if (parsed.watch) {
+    process.stdout.write("\nWatching for status changes...\n");
+    await runCli([
+      "status",
+      "--runtime-root",
+      runtimeRoot,
+      "--project-id",
+      projectId
+    ]);
+  }
+};
+var run_default = handler;
+export {
+  run_default as default
+};

package/dist/start-PIFQMIC2.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  shutdownForegroundOrchestrator,
+  start_default
+} from "./chunk-M7OSMUTN.js";
+import "./chunk-JO3AXHQI.js";
+import "./chunk-MVRF7BES.js";
+import "./chunk-RNWX7DQU.js";
+import "./chunk-5NV3LSAJ.js";
+import "./chunk-TH5QPO3Y.js";
+import "./chunk-ROGRTUFI.js";
+export {
+  start_default as default,
+  shutdownForegroundOrchestrator
+};

package/dist/status-3WK5BWRZ.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  status_default
+} from "./chunk-6HBZC3BE.js";
+import "./chunk-MVRF7BES.js";
+import "./chunk-5NV3LSAJ.js";
+import "./chunk-TH5QPO3Y.js";
+import "./chunk-ROGRTUFI.js";
+export {
+  status_default as default
+};

package/dist/stop-AA3AP5M6.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  stop_default
+} from "./chunk-76QPITKI.js";
+import "./chunk-TH5QPO3Y.js";
+import "./chunk-ROGRTUFI.js";
+export {
+  stop_default as default
+};

package/dist/version-VBB62JWI.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+// src/commands/version.ts
+import { readFile } from "fs/promises";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+var handler = async (_args, options) => {
+  let version = "0.0.0";
+  try {
+    const pkgPath = resolve(
+      dirname(fileURLToPath(import.meta.url)),
+      "..",
+      "..",
+      "package.json"
+    );
+    const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+    version = pkg.version ?? version;
+  } catch {
+  }
+  if (options.json) {
+    process.stdout.write(JSON.stringify({ version }) + "\n");
+  } else {
+    process.stdout.write(`gh-symphony v${version}
+`);
+  }
+};
+var version_default = handler;
+export {
+  version_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -37,13 +37,18 @@
   "dependencies": {
     "@clack/prompts": "^0.9.1",
     "commander": "^14.0.1",
+    "liquidjs": "^10.25.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
     "@gh-symphony/core": "0.0.14",
-    "@gh-symphony/tracker-github": "0.0.14",
     "@gh-symphony/orchestrator": "0.0.14",
-    "@gh-symphony/worker": "0.0.14"
+    "@gh-symphony/dashboard": "0.0.14",
+    "@gh-symphony/worker": "0.0.14",
+    "@gh-symphony/tracker-github": "0.0.14"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsup",
     "lint": "eslint src --ext .ts",
     "test": "vitest run --passWithNoTests",
     "typecheck": "tsc -p tsconfig.json --noEmit"

package/dist/ansi.d.ts

@@ -1,15 +0,0 @@
-export declare const ESC = "\u001B[";
-export declare function bold(s: string): string;
-export declare function dim(s: string): string;
-export declare function green(s: string): string;
-export declare function red(s: string): string;
-export declare function yellow(s: string): string;
-export declare function cyan(s: string): string;
-export declare function magenta(s: string): string;
-export declare function blue(s: string): string;
-export declare function stripAnsi(s: string): string;
-export declare function setNoColor(value: boolean): void;
-export declare function getNoColor(): boolean;
-export declare function clearScreen(): string;
-export declare function hideCursor(): string;
-export declare function showCursor(): string;

package/dist/ansi.js

@@ -1,53 +0,0 @@
-// ── ANSI color and formatting utilities ────────────────────────────────────
-export const ESC = "\x1b[";
-let noColor = false;
-const _bold = (s) => `${ESC}1m${s}${ESC}0m`;
-const _dim = (s) => `${ESC}2m${s}${ESC}0m`;
-const _green = (s) => `${ESC}32m${s}${ESC}0m`;
-const _red = (s) => `${ESC}31m${s}${ESC}0m`;
-const _yellow = (s) => `${ESC}33m${s}${ESC}0m`;
-const _cyan = (s) => `${ESC}36m${s}${ESC}0m`;
-const _magenta = (s) => `${ESC}35m${s}${ESC}0m`;
-const _blue = (s) => `${ESC}34m${s}${ESC}0m`;
-export function bold(s) {
-    return noColor ? s : _bold(s);
-}
-export function dim(s) {
-    return noColor ? s : _dim(s);
-}
-export function green(s) {
-    return noColor ? s : _green(s);
-}
-export function red(s) {
-    return noColor ? s : _red(s);
-}
-export function yellow(s) {
-    return noColor ? s : _yellow(s);
-}
-export function cyan(s) {
-    return noColor ? s : _cyan(s);
-}
-export function magenta(s) {
-    return noColor ? s : _magenta(s);
-}
-export function blue(s) {
-    return noColor ? s : _blue(s);
-}
-export function stripAnsi(s) {
-    return s.replace(new RegExp(`${ESC}\\[[0-9;]*m`, "g"), "");
-}
-export function setNoColor(value) {
-    noColor = value;
-}
-export function getNoColor() {
-    return noColor;
-}
-export function clearScreen() {
-    return "\x1b[2J\x1b[H";
-}
-export function hideCursor() {
-    return "\x1b[?25l";
-}
-export function showCursor() {
-    return "\x1b[?25h";
-}

package/dist/commands/config-cmd.d.ts

@@ -1,3 +0,0 @@
-import type { GlobalOptions } from "../index.js";
-declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
-export default handler;

package/dist/commands/config-cmd.js

@@ -1,90 +0,0 @@
-import { spawn } from "node:child_process";
-import { loadGlobalConfig, saveGlobalConfig, configFilePath, } from "../config.js";
-const handler = async (args, options) => {
-    const [subcommand, ...rest] = args;
-    switch (subcommand) {
-        case "show":
-            await configShow(options);
-            break;
-        case "set":
-            await configSet(rest, options);
-            break;
-        case "edit":
-            await configEdit(options);
-            break;
-        default:
-            process.stderr.write("Usage: gh-symphony config <show|set|edit>\n");
-            process.exitCode = 2;
-    }
-};
-export default handler;
-// ── 7.1: config show ─────────────────────────────────────────────────────────
-async function configShow(options) {
-    const config = await loadGlobalConfig(options.configDir);
-    if (!config) {
-        process.stderr.write("No configuration found. Run 'gh-symphony init'.\n");
-        process.exitCode = 1;
-        return;
-    }
-    if (options.json) {
-        process.stdout.write(JSON.stringify(config, null, 2) + "\n");
-        return;
-    }
-    process.stdout.write(`Config: ${configFilePath(options.configDir)}\n\n`);
-    process.stdout.write(`Active project:    ${config.activeProject ?? "none"}\n`);
-    process.stdout.write(`Projects:         ${config.projects.join(", ") || "none"}\n`);
-}
-// ── 7.2: config set ──────────────────────────────────────────────────────────
-const VALID_KEYS = {
-    "active-project": { type: "string" },
-};
-async function configSet(args, options) {
-    const [key, value] = args;
-    if (!key || value === undefined) {
-        process.stderr.write("Usage: gh-symphony config set <key> <value>\n");
-        process.stderr.write(`Valid keys: ${Object.keys(VALID_KEYS).join(", ")}\n`);
-        process.exitCode = 2;
-        return;
-    }
-    const keyDef = VALID_KEYS[key];
-    if (!keyDef) {
-        process.stderr.write(`Unknown config key: ${key}\nValid keys: ${Object.keys(VALID_KEYS).join(", ")}\n`);
-        process.exitCode = 2;
-        return;
-    }
-    const config = (await loadGlobalConfig(options.configDir)) ??
-        {
-            activeProject: null,
-            projects: [],
-        };
-    switch (key) {
-        case "active-project":
-            if (!config.projects.includes(value)) {
-                process.stderr.write(`Project "${value}" not found. Available: ${config.projects.join(", ")}\n`);
-                process.exitCode = 1;
-                return;
-            }
-            config.activeProject = value;
-            break;
-    }
-    await saveGlobalConfig(options.configDir, config);
-    process.stdout.write(`Set ${key} = ${value}\n`);
-}
-// ── 7.3: config edit ─────────────────────────────────────────────────────────
-async function configEdit(options) {
-    const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-    const path = configFilePath(options.configDir);
-    const child = spawn(editor, [path], {
-        stdio: "inherit",
-    });
-    await new Promise((resolve, reject) => {
-        child.on("close", (code) => {
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`Editor exited with code ${code}`));
-            }
-        });
-    });
-}

package/dist/commands/help.d.ts

@@ -1,3 +0,0 @@
-import type { GlobalOptions } from "../index.js";
-declare const handler: (_args: string[], _options: GlobalOptions) => Promise<void>;
-export default handler;

package/dist/commands/help.js

@@ -1,55 +0,0 @@
-const HELP_TEXT = `
-gh-symphony — AI Coding Agent Orchestrator
-
-Usage: gh-symphony <command> [options]
-
-Setup:
-  init            Interactive project setup wizard
-  config show     Show current configuration
-  config set      Set a configuration value
-  config edit     Open config in $EDITOR
-
-Orchestration:
-  start           Start the orchestrator (foreground)
-  start --daemon  Start the orchestrator (background)
-  stop            Stop the background orchestrator
-  status          Show orchestrator status
-  run <issue>     Dispatch a single issue
-  recover         Recover stalled runs
-  logs            View orchestrator logs
-
-Project Management:
-  project add      Add a new project (interactive wizard)
-  project list     List all configured projects
-  project remove   Remove a project
-
-Project / Repo:
-  project list    List projects
-  project switch  Switch active project
-  project status  Show orchestrator status for a project
-  repo list       List configured repositories
-  repo add        Add a repository
-  repo remove     Remove a repository
-
-Global Options:
-  --config <dir>  Config directory (default: ~/.gh-symphony)
-  --verbose       Enable verbose output
-  --json          Output in JSON format
-  --no-color      Disable color output
-  --help, -h      Show this help message
-  --version, -V   Show version
-
-Examples:
-  gh-symphony project add              # Add a project (interactive)
-  gh-symphony project add --non-interactive --project <id> --workspace-dir <path>
-  gh-symphony project list             # List all projects
-  gh-symphony project remove <id>      # Remove a project
-  gh-symphony start                   # Start orchestrator
-  gh-symphony start --daemon          # Start in background
-  gh-symphony run org/repo#123        # Dispatch a specific issue
-  gh-symphony status --watch          # Watch status in real-time
-`.trimStart();
-const handler = async (_args, _options) => {
-    process.stdout.write(HELP_TEXT);
-};
-export default handler;