@gh-symphony/cli 0.0.1

package/dist/commands/status.js

@@ -0,0 +1,218 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { resolveRuntimeRoot, resolveWorkspaceConfig, syncWorkspaceToRuntime, } from "../orchestrator-runtime.js";
+// ANSI color helpers
+function bold(s) {
+    return `\x1b[1m${s}\x1b[0m`;
+}
+function dim(s) {
+    return `\x1b[2m${s}\x1b[0m`;
+}
+function green(s) {
+    return `\x1b[32m${s}\x1b[0m`;
+}
+function red(s) {
+    return `\x1b[31m${s}\x1b[0m`;
+}
+function yellow(s) {
+    return `\x1b[33m${s}\x1b[0m`;
+}
+function cyan(s) {
+    return `\x1b[36m${s}\x1b[0m`;
+}
+function white(s) {
+    return `\x1b[37m${s}\x1b[0m`;
+}
+function stripAnsi(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function healthIcon(health) {
+    switch (health) {
+        case "idle":
+        case "running":
+            return green("●");
+        case "degraded":
+            return red("●");
+    }
+}
+function relativeTime(isoString) {
+    const now = new Date();
+    const then = new Date(isoString);
+    const diffMs = now.getTime() - then.getTime();
+    const diffS = Math.floor(diffMs / 1000);
+    const diffM = Math.floor(diffS / 60);
+    const diffH = Math.floor(diffM / 60);
+    if (diffS < 60)
+        return `${diffS}s ago`;
+    if (diffM < 60)
+        return `${diffM}m ago`;
+    return `${diffH}h ago`;
+}
+function truncate(s, len) {
+    if (s.length <= len)
+        return s;
+    return s.slice(0, len - 3) + "...";
+}
+function renderDashboard(snapshot, noColor) {
+    const apply = noColor ? (s) => stripAnsi(s) : (s) => s;
+    const lines = [];
+    // Header
+    const headerTitle = `gh-symphony ∙ ${snapshot.slug}`;
+    const headerWidth = 45;
+    const headerPadding = Math.max(0, headerWidth - stripAnsi(headerTitle).length);
+    lines.push("╭" + "─".repeat(headerWidth) + "╮");
+    lines.push("│  " + apply(bold(headerTitle)) + " ".repeat(headerPadding) + "│");
+    lines.push("╰" + "─".repeat(headerWidth) + "╯");
+    lines.push("");
+    // Health and last tick
+    const healthStr = apply(`${healthIcon(snapshot.health)} Health    ${snapshot.health}`);
+    const lastTickStr = apply(`Last tick  ${relativeTime(snapshot.lastTickAt)}`);
+    lines.push(`  ${healthStr}${" ".repeat(Math.max(0, 30 - stripAnsi(healthStr).length))}${lastTickStr}`);
+    lines.push("");
+    // Summary stats
+    const dispatchedStr = apply(`Dispatched   ${snapshot.summary.dispatched}`);
+    const activeRunsStr = apply(`Active Runs  ${snapshot.summary.activeRuns}`);
+    const suppressedStr = apply(`Suppressed   ${snapshot.summary.suppressed}`);
+    const recoveredStr = apply(`Recovered    ${snapshot.summary.recovered}`);
+    lines.push(`  ${dispatchedStr}${" ".repeat(Math.max(0, 20 - stripAnsi(dispatchedStr).length))}${activeRunsStr}`);
+    lines.push(`  ${suppressedStr}${" ".repeat(Math.max(0, 20 - stripAnsi(suppressedStr).length))}${recoveredStr}`);
+    lines.push("");
+    // Active runs table
+    if (snapshot.activeRuns.length > 0) {
+        lines.push("  Active Runs:");
+        for (const run of snapshot.activeRuns) {
+            const runIdDisplay = truncate(run.runId, 12);
+            const phaseColor = run.phase === "planning"
+                ? cyan
+                : run.phase === "human-review"
+                    ? yellow
+                    : run.phase === "implementation"
+                        ? cyan
+                        : run.phase === "awaiting-merge"
+                            ? yellow
+                            : white;
+            const phaseStr = apply(phaseColor(run.phase));
+            const statusColor = run.status === "running"
+                ? green
+                : run.status === "failed"
+                    ? red
+                    : run.status === "succeeded"
+                        ? green
+                        : dim;
+            const statusStr = apply(statusColor(run.status));
+            lines.push(`    ${runIdDisplay}  ${run.issueIdentifier}  ${phaseStr}  ${statusStr}`);
+        }
+        lines.push("");
+    }
+    else {
+        lines.push("  No active runs.");
+        lines.push("");
+    }
+    // Retry queue
+    if (snapshot.retryQueue.length > 0) {
+        lines.push("  Retry Queue:");
+        for (const retry of snapshot.retryQueue) {
+            const runIdDisplay = truncate(retry.runId, 12);
+            const nextRetryDisplay = retry.nextRetryAt
+                ? relativeTime(retry.nextRetryAt)
+                : "pending";
+            lines.push(`    ${runIdDisplay}  ${retry.issueIdentifier}  ${apply(yellow(retry.retryKind))}  ${nextRetryDisplay}`);
+        }
+        lines.push("");
+    }
+    // Last error
+    if (snapshot.lastError) {
+        lines.push(apply(red(`  ✗ ${snapshot.lastError}`)));
+        lines.push("");
+    }
+    // Token usage
+    if (snapshot.codexTotals) {
+        const tokenStr = apply(`Tokens: ${snapshot.codexTotals.inputTokens} in / ${snapshot.codexTotals.outputTokens} out / ${snapshot.codexTotals.totalTokens} total`);
+        lines.push(`  ${tokenStr}`);
+    }
+    else {
+        lines.push("  Tokens: 0 in / 0 out / 0 total");
+    }
+    return lines.join("\n");
+}
+function parseStatusArgs(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;
+        }
+        if (arg === "--workspace" || arg === "--workspace-id") {
+            parsed.workspaceId = args[i + 1];
+            i += 1;
+        }
+    }
+    return parsed;
+}
+async function readStatusSnapshot(runtimeRoot, workspaceId) {
+    try {
+        const statusPath = join(runtimeRoot, "orchestrator", "workspaces", workspaceId, "status.json");
+        const content = await readFile(statusPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+const handler = async (args, options) => {
+    const parsed = parseStatusArgs(args);
+    const wsConfig = await resolveWorkspaceConfig(options.configDir, parsed.workspaceId);
+    if (!wsConfig) {
+        process.stderr.write("No workspace configured. Run 'gh-symphony init' first.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const runtimeRoot = resolveRuntimeRoot(options.configDir);
+    const workspaceId = wsConfig.workspaceId;
+    await syncWorkspaceToRuntime(options.configDir, wsConfig);
+    if (parsed.watch) {
+        // Watch mode: poll every 2 seconds
+        const clear = () => process.stdout.write("\x1b[2J\x1b[H");
+        const run = async () => {
+            clear();
+            const snapshot = await readStatusSnapshot(runtimeRoot, workspaceId);
+            if (snapshot) {
+                if (options.json) {
+                    process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");
+                }
+                else {
+                    process.stdout.write(renderDashboard(snapshot, options.noColor) + "\n");
+                }
+            }
+            else {
+                process.stdout.write("Unable to read status snapshot.\n");
+            }
+        };
+        await run();
+        const interval = setInterval(() => void run(), 2000);
+        const shutdown = () => {
+            clearInterval(interval);
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        // Keep alive
+        await new Promise(() => { });
+    }
+    // Single status query
+    const snapshot = await readStatusSnapshot(runtimeRoot, workspaceId);
+    if (snapshot) {
+        if (options.json) {
+            process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");
+        }
+        else {
+            process.stdout.write(renderDashboard(snapshot, options.noColor) + "\n");
+        }
+    }
+    else {
+        process.stderr.write("Unable to read status snapshot.\n");
+        process.exitCode = 1;
+    }
+};
+export default handler;

package/dist/commands/stop.d.ts

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

package/dist/commands/stop.js

@@ -0,0 +1,46 @@
+import { readFile, rm } from "node:fs/promises";
+import { daemonPidPath } from "../config.js";
+function parseStopArgs(args) {
+    return { force: args.includes("--force") };
+}
+const handler = async (args, options) => {
+    const { force } = parseStopArgs(args);
+    const pidPath = daemonPidPath(options.configDir);
+    let pidStr;
+    try {
+        pidStr = await readFile(pidPath, "utf8");
+    }
+    catch {
+        process.stderr.write("No running daemon found (PID file missing).\n");
+        process.exitCode = 1;
+        return;
+    }
+    const pid = Number.parseInt(pidStr.trim(), 10);
+    if (!Number.isFinite(pid)) {
+        process.stderr.write(`Invalid PID in ${pidPath}: ${pidStr}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        // Check if process is running
+        process.kill(pid, 0);
+    }
+    catch {
+        process.stdout.write(`Daemon (PID ${pid}) is not running. Cleaning up PID file.\n`);
+        await rm(pidPath, { force: true });
+        return;
+    }
+    const signal = force ? "SIGKILL" : "SIGTERM";
+    try {
+        process.kill(pid, signal);
+        process.stdout.write(`Sent ${signal} to orchestrator (PID ${pid}).\n`);
+    }
+    catch (error) {
+        process.stderr.write(`Failed to stop process ${pid}: ${error instanceof Error ? error.message : "Unknown error"}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    await rm(pidPath, { force: true });
+    process.stdout.write("Daemon stopped.\n");
+};
+export default handler;

package/dist/commands/version.d.ts

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

package/dist/commands/version.js

@@ -0,0 +1,21 @@
+import { readFile } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const 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 {
+        // Fall back to default
+    }
+    if (options.json) {
+        process.stdout.write(JSON.stringify({ version }) + "\n");
+    }
+    else {
+        process.stdout.write(`gh-symphony v${version}\n`);
+    }
+};
+export default handler;

package/dist/config.d.ts

@@ -0,0 +1,36 @@
+import type { OrchestratorWorkspaceConfig, WorkflowLifecycleConfig } from "@hojinzs/gh-symphony-core";
+export declare const DEFAULT_CONFIG_DIR: string;
+export declare const CONFIG_FILE = "config.json";
+export declare const DAEMON_PID_FILE = "daemon.pid";
+export declare const LOGS_DIR = "logs";
+export type CliGlobalConfig = {
+    activeWorkspace: string | null;
+    token: string | null;
+    workspaces: string[];
+};
+export type CliWorkspaceConfig = OrchestratorWorkspaceConfig & {
+    workflowMapping?: WorkflowMappingConfig;
+};
+export type WorkflowMappingConfig = {
+    stateFieldName: string;
+    columnRoles: Record<string, ColumnRole>;
+    humanReviewMode: HumanReviewMode;
+    lifecycle: WorkflowLifecycleConfig;
+};
+export type ColumnRole = "trigger" | "working" | "human-review" | "done" | "ignored";
+export type HumanReviewMode = "plan-and-pr" | "plan-only" | "pr-only" | "none";
+export declare function resolveConfigDir(override?: string): string;
+export declare function configFilePath(configDir: string): string;
+export declare function workspaceConfigDir(configDir: string, workspaceId: string): string;
+export declare function workspaceConfigPath(configDir: string, workspaceId: string): string;
+export declare function workflowMappingPath(configDir: string, workspaceId: string): string;
+export declare function daemonPidPath(configDir: string): string;
+export declare function logsDir(configDir: string): string;
+export declare function orchestratorLogPath(configDir: string): string;
+export declare function loadGlobalConfig(configDir: string): Promise<CliGlobalConfig | null>;
+export declare function saveGlobalConfig(configDir: string, config: CliGlobalConfig): Promise<void>;
+export declare function loadWorkspaceConfig(configDir: string, workspaceId: string): Promise<CliWorkspaceConfig | null>;
+export declare function saveWorkspaceConfig(configDir: string, workspaceId: string, config: CliWorkspaceConfig): Promise<void>;
+export declare function loadWorkflowMapping(configDir: string, workspaceId: string): Promise<WorkflowMappingConfig | null>;
+export declare function saveWorkflowMapping(configDir: string, workspaceId: string, mapping: WorkflowMappingConfig): Promise<void>;
+export declare function loadActiveWorkspaceConfig(configDir: string): Promise<CliWorkspaceConfig | null>;

package/dist/config.js

@@ -0,0 +1,81 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+export const DEFAULT_CONFIG_DIR = join(homedir(), ".gh-symphony");
+export const CONFIG_FILE = "config.json";
+export const DAEMON_PID_FILE = "daemon.pid";
+export const LOGS_DIR = "logs";
+export function resolveConfigDir(override) {
+    return override ?? process.env.GH_SYMPHONY_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
+}
+export function configFilePath(configDir) {
+    return join(configDir, CONFIG_FILE);
+}
+export function workspaceConfigDir(configDir, workspaceId) {
+    return join(configDir, "workspaces", workspaceId);
+}
+export function workspaceConfigPath(configDir, workspaceId) {
+    return join(workspaceConfigDir(configDir, workspaceId), "workspace.json");
+}
+export function workflowMappingPath(configDir, workspaceId) {
+    return join(workspaceConfigDir(configDir, workspaceId), "workflow-mapping.json");
+}
+export function daemonPidPath(configDir) {
+    return join(configDir, DAEMON_PID_FILE);
+}
+export function logsDir(configDir) {
+    return join(configDir, LOGS_DIR);
+}
+export function orchestratorLogPath(configDir) {
+    return join(logsDir(configDir), "orchestrator.log");
+}
+export async function loadGlobalConfig(configDir) {
+    return readJsonFile(configFilePath(configDir));
+}
+export async function saveGlobalConfig(configDir, config) {
+    await writeJsonFile(configFilePath(configDir), config);
+}
+export async function loadWorkspaceConfig(configDir, workspaceId) {
+    return readJsonFile(workspaceConfigPath(configDir, workspaceId));
+}
+export async function saveWorkspaceConfig(configDir, workspaceId, config) {
+    await writeJsonFile(workspaceConfigPath(configDir, workspaceId), config);
+}
+export async function loadWorkflowMapping(configDir, workspaceId) {
+    return readJsonFile(workflowMappingPath(configDir, workspaceId));
+}
+export async function saveWorkflowMapping(configDir, workspaceId, mapping) {
+    await writeJsonFile(workflowMappingPath(configDir, workspaceId), mapping);
+}
+export async function loadActiveWorkspaceConfig(configDir) {
+    const global = await loadGlobalConfig(configDir);
+    if (!global?.activeWorkspace) {
+        return null;
+    }
+    return loadWorkspaceConfig(configDir, global.activeWorkspace);
+}
+async function readJsonFile(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (isFileMissing(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function writeJsonFile(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    const temporaryPath = `${path}.tmp`;
+    await writeFile(temporaryPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+    const { rename } = await import("node:fs/promises");
+    await rename(temporaryPath, path);
+}
+function isFileMissing(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}

package/dist/github/client.d.ts

@@ -0,0 +1,60 @@
+export type GitHubClient = {
+    token: string;
+    apiUrl: string;
+    fetchImpl: typeof fetch;
+};
+export type ViewerInfo = {
+    login: string;
+    name: string | null;
+    scopes: string[];
+};
+export type ProjectSummary = {
+    id: string;
+    title: string;
+    shortDescription: string;
+    url: string;
+    openItemCount: number;
+    owner: {
+        login: string;
+        type: "User" | "Organization";
+    };
+};
+export type StatusFieldOption = {
+    id: string;
+    name: string;
+    description: string | null;
+    color: string | null;
+};
+export type ProjectStatusField = {
+    id: string;
+    name: string;
+    options: StatusFieldOption[];
+};
+export type LinkedRepository = {
+    owner: string;
+    name: string;
+    url: string;
+    cloneUrl: string;
+};
+export type ProjectDetail = {
+    id: string;
+    title: string;
+    url: string;
+    statusFields: ProjectStatusField[];
+    linkedRepositories: LinkedRepository[];
+};
+export declare class GitHubApiError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+export declare function createClient(token: string, options?: {
+    apiUrl?: string;
+    fetchImpl?: typeof fetch;
+}): GitHubClient;
+export declare function validateToken(client: GitHubClient): Promise<ViewerInfo>;
+export declare function checkRequiredScopes(scopes: string[]): {
+    valid: boolean;
+    missing: string[];
+};
+export declare function listUserProjects(client: GitHubClient): Promise<ProjectSummary[]>;
+export declare function getProjectDetail(client: GitHubClient, projectId: string): Promise<ProjectDetail>;