@gh-symphony/cli 0.0.6 → 0.0.8

package/dist/index.js

@@ -1,44 +1,9 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
+import { Command, CommanderError, InvalidArgumentError, Option, } from "commander";
 import { resolveConfigDir } from "./config.js";
-export function parseGlobalOptions(argv) {
-    const globalFlags = {
-        configDir: resolveConfigDir(),
-        verbose: false,
-        json: false,
-        noColor: false,
-    };
-    const remaining = [];
-    let i = 0;
-    while (i < argv.length) {
-        const arg = argv[i];
-        if (arg === "--config" || arg === "--config-dir") {
-            globalFlags.configDir = resolveConfigDir(argv[i + 1]);
-            i += 2;
-            continue;
-        }
-        if (arg === "--verbose" || arg === "-v") {
-            globalFlags.verbose = true;
-            i += 1;
-            continue;
-        }
-        if (arg === "--json") {
-            globalFlags.json = true;
-            i += 1;
-            continue;
-        }
-        if (arg === "--no-color") {
-            globalFlags.noColor = true;
-            i += 1;
-            continue;
-        }
-        remaining.push(arg);
-        i += 1;
-    }
-    const [command = "help", ...args] = remaining;
-    return { options: globalFlags, command, args };
-}
+import { renderCompletionScript } from "./completion.js";
 const COMMANDS = {
     init: () => import("./commands/init.js"),
     start: () => import("./commands/start.js"),
@@ -49,34 +14,356 @@ const COMMANDS = {
     logs: () => import("./commands/logs.js"),
     project: () => import("./commands/project.js"),
     repo: () => import("./commands/repo.js"),
-    tenant: () => import("./commands/tenant.js"),
     config: () => import("./commands/config-cmd.js"),
-    help: () => import("./commands/help.js"),
     version: () => import("./commands/version.js"),
 };
-export async function runCli(argv) {
-    const { options, command, args } = parseGlobalOptions(argv);
+function addGlobalOptions(command) {
+    return command
+        .option("--config <dir>", "Config directory")
+        .addOption(new Option("--config-dir <dir>").hideHelp())
+        .option("-v, --verbose", "Enable verbose output")
+        .option("--json", "Output in JSON format")
+        .option("--no-color", "Disable color output");
+}
+function resolveGlobalOptions(values) {
+    const configInput = typeof values.config === "string"
+        ? values.config
+        : typeof values.configDir === "string"
+            ? values.configDir
+            : undefined;
+    const options = {
+        configDir: resolveConfigDir(configInput),
+        verbose: Boolean(values.verbose),
+        json: Boolean(values.json),
+        noColor: Boolean(values.noColor),
+    };
     if (options.noColor) {
         process.env.NO_COLOR = "1";
     }
-    if (command === "--help" || command === "-h") {
-        const helpModule = await COMMANDS.help();
-        await helpModule.default(args, options);
+    return options;
+}
+function resolveProjectId(values) {
+    return values.projectId ?? values.project;
+}
+function pushOption(args, flag, value) {
+    if (typeof value === "string" && value.length > 0) {
+        args.push(flag, value);
         return;
     }
-    if (command === "--version" || command === "-V") {
+    if (value === true) {
+        args.push(flag);
+    }
+}
+async function invokeHandler(key, args, values) {
+    const module = await COMMANDS[key]();
+    await module.default(args, resolveGlobalOptions(values));
+}
+function shellArgument(value) {
+    if (value === "bash" || value === "zsh" || value === "fish") {
+        return value;
+    }
+    throw new InvalidArgumentError("Shell must be one of: bash, zsh, fish");
+}
+function hasVersionFlag(argv) {
+    return argv.some((arg) => arg === "--version" || arg === "-V");
+}
+function resolveVersionOptions(argv) {
+    const options = {
+        configDir: resolveConfigDir(),
+        verbose: argv.some((arg) => arg === "--verbose" || arg === "-v"),
+        json: argv.includes("--json"),
+        noColor: argv.includes("--no-color"),
+    };
+    if (options.noColor) {
+        process.env.NO_COLOR = "1";
+    }
+    return options;
+}
+function createProgram() {
+    let actionInvoked = false;
+    const markInvoked = () => {
+        actionInvoked = true;
+    };
+    const program = addGlobalOptions(new Command()
+        .name("gh-symphony")
+        .description("AI Coding Agent Orchestrator")
+        .exitOverride()
+        .helpOption("-h, --help", "Show help")
+        .addHelpCommand("help [command]", "Show help for command")
+        .showHelpAfterError("(run with --help for usage)")
+        .option("-V, --version", "Show version"));
+    addGlobalOptions(program
+        .command("init")
+        .description("Interactive project setup wizard")
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        await invokeHandler("init", [], this.optsWithGlobals());
+    });
+    addGlobalOptions(program
+        .command("start")
+        .description("Start the orchestrator")
+        .option("-d, --daemon", "Start in daemon mode")
+        .option("--project-id <projectId>", "Project identifier")
+        .addOption(new Option("--project <projectId>").hideHelp())
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = [];
+        pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--daemon", values.daemon);
+        await invokeHandler("start", args, values);
+    });
+    addGlobalOptions(program
+        .command("stop")
+        .description("Stop the background orchestrator")
+        .option("--force", "Force stop with SIGKILL")
+        .option("--project-id <projectId>", "Project identifier")
+        .addOption(new Option("--project <projectId>").hideHelp())
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = [];
+        pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--force", values.force);
+        await invokeHandler("stop", args, values);
+    });
+    addGlobalOptions(program
+        .command("status")
+        .description("Show orchestrator status")
+        .option("-w, --watch", "Watch status continuously")
+        .option("--project-id <projectId>", "Project identifier")
+        .addOption(new Option("--project <projectId>").hideHelp())
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = [];
+        pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--watch", values.watch);
+        await invokeHandler("status", args, values);
+    });
+    addGlobalOptions(program
+        .command("run")
+        .description("Dispatch a single issue")
+        .argument("<issue>", "Issue identifier")
+        .option("-w, --watch", "Watch status after dispatch")
+        .option("--project-id <projectId>", "Project identifier")
+        .addOption(new Option("--project <projectId>").hideHelp())
+        .allowExcessArguments(false)).action(async function (issue) {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = [issue];
+        pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--watch", values.watch);
+        await invokeHandler("run", args, values);
+    });
+    addGlobalOptions(program
+        .command("recover")
+        .description("Recover stalled runs")
+        .option("--dry-run", "Show recoverable runs without recovering")
+        .option("--project-id <projectId>", "Project identifier")
+        .addOption(new Option("--project <projectId>").hideHelp())
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = [];
+        pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--dry-run", values.dryRun);
+        await invokeHandler("recover", args, values);
+    });
+    addGlobalOptions(program
+        .command("logs")
+        .description("View orchestrator logs")
+        .option("-f, --follow", "Follow new log lines")
+        .option("--issue <issue>", "Filter by issue identifier")
+        .option("--run <runId>", "Read events for a specific run")
+        .option("--level <level>", "Filter by log level")
+        .option("--project-id <projectId>", "Project identifier")
+        .addOption(new Option("--project <projectId>").hideHelp())
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = [];
+        pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--follow", values.follow);
+        pushOption(args, "--issue", values.issue);
+        pushOption(args, "--run", values.run);
+        pushOption(args, "--level", values.level);
+        await invokeHandler("logs", args, values);
+    });
+    const project = addGlobalOptions(program.command("project").description("Manage configured projects"));
+    project.action(async function () {
+        markInvoked();
+        await invokeHandler("project", [], this.optsWithGlobals());
+    });
+    addGlobalOptions(project
+        .command("add")
+        .description("Add a new project")
+        .option("--non-interactive", "Run without prompts")
+        .option("--project <id>", "GitHub Project ID")
+        .option("--workspace-dir <path>", "Workspace directory")
+        .option("--assigned-only", "Limit processing to assigned issues")
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = [];
+        pushOption(args, "--non-interactive", values.nonInteractive);
+        pushOption(args, "--project", values.project);
+        pushOption(args, "--workspace-dir", values.workspaceDir);
+        pushOption(args, "--assigned-only", values.assignedOnly);
+        await invokeHandler("project", ["add", ...args], values);
+    });
+    addGlobalOptions(project.command("list").description("List configured projects")).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        await invokeHandler("project", ["list"], values);
+    });
+    addGlobalOptions(project
+        .command("remove")
+        .description("Remove a project")
+        .argument("<projectId>", "Project identifier")
+        .allowExcessArguments(false)).action(async function (projectId) {
+        markInvoked();
+        await invokeHandler("project", ["remove", projectId], this.optsWithGlobals());
+    });
+    addGlobalOptions(project
+        .command("start")
+        .description("Start a specific project")
+        .option("-d, --daemon", "Start in daemon mode")
+        .option("--project-id <projectId>", "Project identifier")
+        .addOption(new Option("--project <projectId>").hideHelp())
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = ["start"];
+        pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--daemon", values.daemon);
+        await invokeHandler("project", args, values);
+    });
+    addGlobalOptions(project
+        .command("stop")
+        .description("Stop a specific project")
+        .option("--force", "Force stop with SIGKILL")
+        .option("--project-id <projectId>", "Project identifier")
+        .addOption(new Option("--project <projectId>").hideHelp())
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = ["stop"];
+        pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--force", values.force);
+        await invokeHandler("project", args, values);
+    });
+    addGlobalOptions(project.command("switch").description("Switch the active project")).action(async function () {
+        markInvoked();
+        await invokeHandler("project", ["switch"], this.optsWithGlobals());
+    });
+    addGlobalOptions(project
+        .command("status")
+        .description("Show status for a specific project")
+        .option("-w, --watch", "Watch status continuously")
+        .option("--project-id <projectId>", "Project identifier")
+        .addOption(new Option("--project <projectId>").hideHelp())
+        .allowExcessArguments(false)).action(async function () {
+        markInvoked();
+        const values = this.optsWithGlobals();
+        const args = ["status"];
+        pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--watch", values.watch);
+        await invokeHandler("project", args, values);
+    });
+    const repo = addGlobalOptions(program
+        .command("repo")
+        .description("Manage repositories in the active project"));
+    repo.action(async function () {
+        markInvoked();
+        await invokeHandler("repo", [], this.optsWithGlobals());
+    });
+    addGlobalOptions(repo.command("list").description("List repositories")).action(async function () {
+        markInvoked();
+        await invokeHandler("repo", ["list"], this.optsWithGlobals());
+    });
+    addGlobalOptions(repo
+        .command("add")
+        .description("Add a repository")
+        .argument("<owner/name>", "Repository spec")
+        .allowExcessArguments(false)).action(async function (repoSpec) {
+        markInvoked();
+        await invokeHandler("repo", ["add", repoSpec], this.optsWithGlobals());
+    });
+    addGlobalOptions(repo
+        .command("remove")
+        .description("Remove a repository")
+        .argument("<owner/name>", "Repository spec")
+        .allowExcessArguments(false)).action(async function (repoSpec) {
+        markInvoked();
+        await invokeHandler("repo", ["remove", repoSpec], this.optsWithGlobals());
+    });
+    const config = addGlobalOptions(program.command("config").description("Manage CLI configuration"));
+    config.action(async function () {
+        markInvoked();
+        await invokeHandler("config", [], this.optsWithGlobals());
+    });
+    addGlobalOptions(config.command("show").description("Show configuration")).action(async function () {
+        markInvoked();
+        await invokeHandler("config", ["show"], this.optsWithGlobals());
+    });
+    addGlobalOptions(config
+        .command("set")
+        .description("Set a configuration value")
+        .argument("<key>", "Configuration key")
+        .argument("<value>", "Configuration value")
+        .allowExcessArguments(false)).action(async function (key, value) {
+        markInvoked();
+        await invokeHandler("config", ["set", key, value], this.optsWithGlobals());
+    });
+    addGlobalOptions(config.command("edit").description("Open config in $EDITOR")).action(async function () {
+        markInvoked();
+        await invokeHandler("config", ["edit"], this.optsWithGlobals());
+    });
+    addGlobalOptions(program
+        .command("completion")
+        .description("Print shell completion script")
+        .argument("<shell>", "Shell name", shellArgument)
+        .allowExcessArguments(false)).action(async function (shell) {
+        markInvoked();
+        process.stdout.write(renderCompletionScript(shell));
+    });
+    program
+        .command("version")
+        .description("Show version")
+        .allowExcessArguments(false)
+        .action(async function () {
+        markInvoked();
+        await invokeHandler("version", [], this.optsWithGlobals());
+    });
+    return { program, wasInvoked: () => actionInvoked };
+}
+export async function runCli(argv) {
+    const { program, wasInvoked } = createProgram();
+    if (hasVersionFlag(argv)) {
         const versionModule = await COMMANDS.version();
-        await versionModule.default(args, options);
+        await versionModule.default([], resolveVersionOptions(argv));
         return;
     }
-    const loader = COMMANDS[command];
-    if (!loader) {
-        process.stderr.write(`Unknown command: ${command}\nRun 'gh-symphony help' for usage.\n`);
-        process.exitCode = 2;
-        return;
+    try {
+        await program.parseAsync(["node", "gh-symphony", ...argv], {
+            from: "node",
+        });
+        if (!wasInvoked()) {
+            program.outputHelp();
+        }
+    }
+    catch (error) {
+        if (error instanceof CommanderError &&
+            error.code === "commander.helpDisplayed") {
+            return;
+        }
+        if (error instanceof CommanderError) {
+            process.exitCode = error.exitCode;
+            return;
+        }
+        throw error;
     }
-    const module = await loader();
-    await module.default(args, options);
 }
 async function main() {
     await runCli(process.argv.slice(2));

package/dist/orchestrator-runtime.d.ts

@@ -1,5 +1,5 @@
-import { type CliTenantConfig } from "./config.js";
+import { type CliProjectConfig } from "./config.js";
 export declare function resolveRuntimeRoot(configDir: string): string;
-export declare function resolveTenantConfig(configDir: string, requestedTenantId?: string): Promise<CliTenantConfig | null>;
-export declare function orchestratorTenantConfigPath(runtimeRoot: string, tenantId: string): string;
-export declare function syncTenantToRuntime(configDir: string, tenantConfig: CliTenantConfig): Promise<string>;
+export declare function resolveProjectConfig(configDir: string, requestedProjectId?: string): Promise<CliProjectConfig | null>;
+export declare function orchestratorProjectConfigPath(runtimeRoot: string, projectId: string): string;
+export declare function syncProjectToRuntime(configDir: string, projectConfig: CliProjectConfig): Promise<string>;

package/dist/orchestrator-runtime.js

@@ -1,26 +1,26 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
-import { loadGlobalConfig, loadTenantConfig, } from "./config.js";
+import { loadGlobalConfig, loadProjectConfig, } from "./config.js";
 export function resolveRuntimeRoot(configDir) {
     return resolve(configDir);
 }
-export async function resolveTenantConfig(configDir, requestedTenantId) {
-    if (requestedTenantId) {
-        return loadTenantConfig(configDir, requestedTenantId);
+export async function resolveProjectConfig(configDir, requestedProjectId) {
+    if (requestedProjectId) {
+        return loadProjectConfig(configDir, requestedProjectId);
     }
     const global = await loadGlobalConfig(configDir);
-    if (!global?.activeTenant) {
+    if (!global?.activeProject) {
         return null;
     }
-    return loadTenantConfig(configDir, global.activeTenant);
+    return loadProjectConfig(configDir, global.activeProject);
 }
-export function orchestratorTenantConfigPath(runtimeRoot, tenantId) {
-    return join(runtimeRoot, "orchestrator", "tenants", tenantId, "config.json");
+export function orchestratorProjectConfigPath(runtimeRoot, projectId) {
+    return join(runtimeRoot, "orchestrator", "projects", projectId, "config.json");
 }
-export async function syncTenantToRuntime(configDir, tenantConfig) {
+export async function syncProjectToRuntime(configDir, projectConfig) {
     const runtimeRoot = resolveRuntimeRoot(configDir);
-    const configPath = orchestratorTenantConfigPath(runtimeRoot, tenantConfig.tenantId);
+    const configPath = orchestratorProjectConfigPath(runtimeRoot, projectConfig.projectId);
     await mkdir(dirname(configPath), { recursive: true });
-    await writeFile(configPath, JSON.stringify(tenantConfig, null, 2) + "\n");
+    await writeFile(configPath, JSON.stringify(projectConfig, null, 2) + "\n");
     return runtimeRoot;
 }

package/dist/orchestrator-status-endpoint.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveProjectOrchestratorStatusBaseUrl(input: {
+    configDir: string;
+    projectId: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<string | null>;

package/dist/orchestrator-status-endpoint.js

@@ -0,0 +1,27 @@
+import { readFile } from "node:fs/promises";
+import { orchestratorPortPath } from "./config.js";
+export async function resolveProjectOrchestratorStatusBaseUrl(input) {
+    const env = input.env ?? process.env;
+    const explicitBaseUrl = env.ORCHESTRATOR_STATUS_BASE_URL;
+    if (explicitBaseUrl) {
+        return explicitBaseUrl;
+    }
+    const host = env.ORCHESTRATOR_STATUS_HOST ?? "127.0.0.1";
+    const port = env.ORCHESTRATOR_STATUS_PORT ??
+        (await readProjectStatusPort(input.configDir, input.projectId));
+    if (!port) {
+        return null;
+    }
+    const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+    return `http://${urlHost}:${port}`;
+}
+async function readProjectStatusPort(configDir, projectId) {
+    try {
+        const raw = await readFile(orchestratorPortPath(configDir, projectId), "utf8");
+        const port = raw.trim();
+        return port.length > 0 ? port : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/project-selection.d.ts

@@ -0,0 +1,8 @@
+import { type CliProjectConfig } from "./config.js";
+type ResolveProjectSelectionInput = {
+    configDir: string;
+    requestedProjectId?: string;
+};
+export declare function resolveManagedProjectConfig(input: ResolveProjectSelectionInput): Promise<CliProjectConfig | null>;
+export declare function handleMissingManagedProjectConfig(): void;
+export {};

package/dist/project-selection.js

@@ -0,0 +1,56 @@
+import * as p from "@clack/prompts";
+import { loadGlobalConfig, loadProjectConfig, } from "./config.js";
+function isInteractiveTerminal() {
+    return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function explicitProjectRequiredMessage() {
+    return "Multiple projects are configured. Re-run with --project-id in non-interactive environments.\n";
+}
+export async function resolveManagedProjectConfig(input) {
+    if (input.requestedProjectId) {
+        return loadProjectConfig(input.configDir, input.requestedProjectId);
+    }
+    const global = await loadGlobalConfig(input.configDir);
+    const projectIds = global?.projects ?? [];
+    if (projectIds.length === 0) {
+        return null;
+    }
+    if (projectIds.length === 1) {
+        return loadProjectConfig(input.configDir, projectIds[0]);
+    }
+    if (!isInteractiveTerminal()) {
+        process.stderr.write(explicitProjectRequiredMessage());
+        process.exitCode = 1;
+        return null;
+    }
+    const projects = await Promise.all(projectIds.map(async (projectId) => ({
+        projectId,
+        config: await loadProjectConfig(input.configDir, projectId),
+    })));
+    const selected = await p.select({
+        message: "Select a project:",
+        options: projects.map(({ projectId, config }) => ({
+            value: projectId,
+            label: config?.displayName ?? config?.slug ?? projectId,
+            hint: projectId === global?.activeProject
+                ? "current"
+                : config && config.displayName && config.displayName !== projectId
+                    ? projectId
+                    : undefined,
+        })),
+        maxItems: 10,
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exitCode = 130;
+        return null;
+    }
+    return loadProjectConfig(input.configDir, selected);
+}
+export function handleMissingManagedProjectConfig() {
+    if (process.exitCode) {
+        return;
+    }
+    process.stderr.write("No project configured. Run 'gh-symphony project add' first.\n");
+    process.exitCode = 1;
+}

package/dist/skills/types.d.ts

@@ -2,7 +2,7 @@ export type SkillRuntime = "claude-code" | "codex";
 export type SkillTemplateContext = {
     runtime: SkillRuntime | string;
     projectId: string;
-    projectTitle: string;
+    githubProjectTitle: string;
     repositories: Array<{
         owner: string;
         name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -36,10 +36,11 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.9.1",
-    "@gh-symphony/core": "0.0.6",
-    "@gh-symphony/orchestrator": "0.0.6",
-    "@gh-symphony/tracker-github": "0.0.6",
-    "@gh-symphony/worker": "0.0.6"
+    "commander": "^14.0.1",
+    "@gh-symphony/core": "0.0.8",
+    "@gh-symphony/orchestrator": "0.0.8",
+    "@gh-symphony/tracker-github": "0.0.8",
+    "@gh-symphony/worker": "0.0.8"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",