@gh-symphony/cli 0.0.6 → 0.0.7

package/dist/commands/status.js

@@ -1,10 +1,12 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { resolveRuntimeRoot, resolveTenantConfig, syncTenantToRuntime, } from "../orchestrator-runtime.js";
+import { resolveRuntimeRoot, resolveProjectConfig, syncProjectToRuntime, } from "../orchestrator-runtime.js";
 import { bold, dim, green, red, yellow, cyan, stripAnsi } from "../ansi.js";
 import { clearScreen, showCursor, hideCursor } from "../ansi.js";
 import { renderDashboard } from "../dashboard/renderer.js";
+import { resolveProjectOrchestratorStatusBaseUrl } from "../orchestrator-status-endpoint.js";
 import { requestOrchestratorRefresh } from "./status-refresh.js";
+import { parseCliArgs } from "./parse-cli-args.js";
 const WATCH_REFRESH_TIMEOUT_MS = 1_500;
 function healthIcon(health) {
     switch (health) {
@@ -107,22 +109,22 @@ function renderLegacyStatus(snapshot, noColor) {
     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 === "--tenant" || arg === "--tenant-id") {
-            parsed.tenantId = args[i + 1];
-            i += 1;
-        }
-    }
-    return parsed;
+    const parsed = parseCliArgs(args, {
+        watch: { type: "boolean", short: "w" },
+        project: { type: "string" },
+        "project-id": { type: "string" },
+    });
+    if ("error" in parsed) {
+        return { watch: false, error: parsed.error };
+    }
+    return {
+        watch: Boolean(parsed.values.watch),
+        projectId: (parsed.values["project-id"] ?? parsed.values.project),
+    };
 }
-async function readStatusSnapshot(runtimeRoot, tenantId) {
+async function readStatusSnapshot(runtimeRoot, projectId) {
     try {
-        const statusPath = join(runtimeRoot, "orchestrator", "tenants", tenantId, "status.json");
+        const statusPath = join(runtimeRoot, "orchestrator", "projects", projectId, "status.json");
         const content = await readFile(statusPath, "utf-8");
         return JSON.parse(content);
     }
@@ -130,56 +132,47 @@ async function readStatusSnapshot(runtimeRoot, tenantId) {
         return null;
     }
 }
-async function readAllStatusSnapshots(runtimeRoot) {
-    try {
-        const tenantsDir = join(runtimeRoot, "orchestrator", "tenants");
-        const { readdir } = await import("node:fs/promises");
-        const entries = await readdir(tenantsDir, { withFileTypes: true });
-        const snapshots = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const statusPath = join(tenantsDir, entry.name, "status.json");
-            try {
-                const content = await readFile(statusPath, "utf-8");
-                snapshots.push(JSON.parse(content));
-            }
-            catch {
-                // skip missing/invalid files
-            }
-        }
-        return snapshots;
-    }
-    catch {
-        return [];
-    }
-}
 const handler = async (args, options) => {
     const parsed = parseStatusArgs(args);
-    const tenantConfig = await resolveTenantConfig(options.configDir, parsed.tenantId);
-    if (!tenantConfig) {
-        process.stderr.write("No tenant configured. Run 'gh-symphony init' first.\n");
+    if (parsed.error) {
+        process.stderr.write(`${parsed.error}\n`);
+        process.stderr.write("Usage: gh-symphony status [--project-id <project-id>] [--watch]\n");
+        process.exitCode = 2;
+        return;
+    }
+    const projectConfig = await resolveProjectConfig(options.configDir, parsed.projectId);
+    if (!projectConfig) {
+        process.stderr.write("No project configured. Run 'gh-symphony project add' first.\n");
         process.exitCode = 1;
         return;
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
-    const tenantId = tenantConfig.tenantId;
-    await syncTenantToRuntime(options.configDir, tenantConfig);
+    const projectId = projectConfig.projectId;
+    await syncProjectToRuntime(options.configDir, projectConfig);
     if (parsed.watch) {
         const isTTY = process.stdout.isTTY === true;
         let terminalWidth = process.stdout.columns ?? 115;
         let runPromise = null;
         const run = async () => {
+            const baseUrl = await resolveProjectOrchestratorStatusBaseUrl({
+                configDir: options.configDir,
+                projectId,
+            });
             await requestOrchestratorRefresh({
+                baseUrl,
                 timeoutMs: WATCH_REFRESH_TIMEOUT_MS,
             });
-            const snapshots = await readAllStatusSnapshots(runtimeRoot);
+            const snapshot = await readStatusSnapshot(runtimeRoot, projectId);
             if (options.json || !isTTY) {
-                process.stdout.write(JSON.stringify(snapshots, null, 2) + "\n");
+                process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");
             }
             else {
+                if (!snapshot) {
+                    process.stdout.write(clearScreen() + "Unable to read status snapshot.\n");
+                    return;
+                }
                 process.stdout.write(clearScreen() +
-                    renderDashboard(snapshots, {
+                    renderDashboard([snapshot], {
                         terminalWidth,
                         noColor: options.noColor,
                     }) +
@@ -213,7 +206,7 @@ const handler = async (args, options) => {
         await new Promise(() => { });
     }
     // Single status query
-    const snapshot = await readStatusSnapshot(runtimeRoot, tenantId);
+    const snapshot = await readStatusSnapshot(runtimeRoot, projectId);
     if (snapshot) {
         if (options.json) {
             process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");

package/dist/commands/stop.js

@@ -1,17 +1,43 @@
 import { readFile, rm } from "node:fs/promises";
-import { daemonPidPath } from "../config.js";
+import { daemonPidPath, orchestratorPortPath } from "../config.js";
+import { parseCliArgs } from "./parse-cli-args.js";
 function parseStopArgs(args) {
-    return { force: args.includes("--force") };
+    const parsed = parseCliArgs(args, {
+        force: { type: "boolean" },
+        project: { type: "string" },
+        "project-id": { type: "string" },
+    });
+    if ("error" in parsed) {
+        return { force: false, error: parsed.error };
+    }
+    return {
+        force: Boolean(parsed.values.force),
+        projectId: (parsed.values["project-id"] ?? parsed.values.project),
+    };
 }
 const handler = async (args, options) => {
-    const { force } = parseStopArgs(args);
-    const pidPath = daemonPidPath(options.configDir);
+    const parsed = parseStopArgs(args);
+    if (parsed.error) {
+        process.stderr.write(`${parsed.error}\n`);
+        process.stderr.write("Usage: gh-symphony stop --project-id <project-id> [--force]\n");
+        process.exitCode = 2;
+        return;
+    }
+    if (!parsed.projectId) {
+        process.stderr.write("Usage: gh-symphony stop --project-id <project-id> [--force]\n");
+        process.exitCode = 2;
+        return;
+    }
+    const resolvedForce = parsed.force;
+    const resolvedProjectId = parsed.projectId;
+    const pidPath = daemonPidPath(options.configDir, resolvedProjectId);
+    const portPath = orchestratorPortPath(options.configDir, resolvedProjectId);
     let pidStr;
     try {
         pidStr = await readFile(pidPath, "utf8");
     }
     catch {
-        process.stderr.write("No running daemon found (PID file missing).\n");
+        process.stderr.write(`No running daemon found for project "${resolvedProjectId}" (PID file missing).\n`);
         process.exitCode = 1;
         return;
     }
@@ -26,11 +52,12 @@ const handler = async (args, options) => {
         process.kill(pid, 0);
     }
     catch {
-        process.stdout.write(`Daemon (PID ${pid}) is not running. Cleaning up PID file.\n`);
+        process.stdout.write(`Daemon for project "${resolvedProjectId}" (PID ${pid}) is not running. Cleaning up PID file.\n`);
         await rm(pidPath, { force: true });
+        await rm(portPath, { force: true });
         return;
     }
-    const signal = force ? "SIGKILL" : "SIGTERM";
+    const signal = resolvedForce ? "SIGKILL" : "SIGTERM";
     try {
         process.kill(pid, signal);
         process.stdout.write(`Sent ${signal} to orchestrator (PID ${pid}).\n`);
@@ -41,6 +68,9 @@ const handler = async (args, options) => {
         return;
     }
     await rm(pidPath, { force: true });
+    if (resolvedForce) {
+        await rm(portPath, { force: true });
+    }
     process.stdout.write("Daemon stopped.\n");
 };
 export default handler;

package/dist/config.d.ts

@@ -1,19 +1,21 @@
-import type { OrchestratorTenantConfig } from "@gh-symphony/core";
+import type { OrchestratorProjectConfig } from "@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 declare const ORCHESTRATOR_LOG_FILE = "orchestrator.log";
+export declare const ORCHESTRATOR_PORT_FILE = "port";
 export type CliGlobalConfig = {
-    activeTenant: string | null;
-    tenants: string[];
+    activeProject: string | null;
+    projects: string[];
 };
-export type CliTenantTrackerSettings = Record<string, string | boolean> & {
+export type CliProjectTrackerSettings = Record<string, string | boolean> & {
     projectId?: string;
     assignedOnly?: boolean;
 };
-export type CliTenantConfig = Omit<OrchestratorTenantConfig, "tracker"> & {
-    tracker: Omit<OrchestratorTenantConfig["tracker"], "settings"> & {
-        settings?: CliTenantTrackerSettings;
+export type CliProjectConfig = Omit<OrchestratorProjectConfig, "tracker"> & {
+    displayName?: string;
+    tracker: Omit<OrchestratorProjectConfig["tracker"], "settings"> & {
+        settings?: CliProjectTrackerSettings;
     };
 };
 export type StateRole = "active" | "wait" | "terminal";
@@ -23,13 +25,13 @@ export type StateMapping = {
 };
 export declare function resolveConfigDir(override?: string): string;
 export declare function configFilePath(configDir: string): string;
-export declare function tenantConfigDir(configDir: string, tenantId: string): string;
-export declare function tenantConfigPath(configDir: string, tenantId: 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 projectConfigDir(configDir: string, projectId: string): string;
+export declare function projectConfigPath(configDir: string, projectId: string): string;
+export declare function daemonPidPath(configDir: string, projectId: string): string;
+export declare function orchestratorLogPath(configDir: string, projectId: string): string;
+export declare function orchestratorPortPath(configDir: string, projectId: string): string;
 export declare function loadGlobalConfig(configDir: string): Promise<CliGlobalConfig | null>;
 export declare function saveGlobalConfig(configDir: string, config: CliGlobalConfig): Promise<void>;
-export declare function loadTenantConfig(configDir: string, tenantId: string): Promise<CliTenantConfig | null>;
-export declare function saveTenantConfig(configDir: string, tenantId: string, config: CliTenantConfig): Promise<void>;
-export declare function loadActiveTenantConfig(configDir: string): Promise<CliTenantConfig | null>;
+export declare function loadProjectConfig(configDir: string, projectId: string): Promise<CliProjectConfig | null>;
+export declare function saveProjectConfig(configDir: string, projectId: string, config: CliProjectConfig): Promise<void>;
+export declare function loadActiveProjectConfig(configDir: string): Promise<CliProjectConfig | null>;

package/dist/config.js

@@ -4,46 +4,56 @@ 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 const ORCHESTRATOR_LOG_FILE = "orchestrator.log";
+export const ORCHESTRATOR_PORT_FILE = "port";
 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 tenantConfigDir(configDir, tenantId) {
-    return join(configDir, "tenants", tenantId);
+export function projectConfigDir(configDir, projectId) {
+    return join(configDir, "projects", projectId);
 }
-export function tenantConfigPath(configDir, tenantId) {
-    return join(tenantConfigDir(configDir, tenantId), "tenant.json");
+export function projectConfigPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), "project.json");
 }
-export function daemonPidPath(configDir) {
-    return join(configDir, DAEMON_PID_FILE);
+export function daemonPidPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), DAEMON_PID_FILE);
 }
-export function logsDir(configDir) {
-    return join(configDir, LOGS_DIR);
+export function orchestratorLogPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), ORCHESTRATOR_LOG_FILE);
 }
-export function orchestratorLogPath(configDir) {
-    return join(logsDir(configDir), "orchestrator.log");
+export function orchestratorPortPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), ORCHESTRATOR_PORT_FILE);
 }
 export async function loadGlobalConfig(configDir) {
-    return readJsonFile(configFilePath(configDir));
+    const raw = await readJsonFile(configFilePath(configDir));
+    if (!raw) {
+        return null;
+    }
+    return {
+        activeProject: typeof raw.activeProject === "string" ? raw.activeProject : null,
+        projects: Array.isArray(raw.projects)
+            ? raw.projects.filter((projectId) => typeof projectId === "string")
+            : [],
+    };
 }
 export async function saveGlobalConfig(configDir, config) {
     await writeJsonFile(configFilePath(configDir), config);
 }
-export async function loadTenantConfig(configDir, tenantId) {
-    return readJsonFile(tenantConfigPath(configDir, tenantId));
+export async function loadProjectConfig(configDir, projectId) {
+    return readJsonFile(projectConfigPath(configDir, projectId));
 }
-export async function saveTenantConfig(configDir, tenantId, config) {
-    await writeJsonFile(tenantConfigPath(configDir, tenantId), config);
+export async function saveProjectConfig(configDir, projectId, config) {
+    await writeJsonFile(projectConfigPath(configDir, projectId), config);
 }
-export async function loadActiveTenantConfig(configDir) {
+export async function loadActiveProjectConfig(configDir) {
     const global = await loadGlobalConfig(configDir);
-    if (!global?.activeTenant) {
+    if (!global?.activeProject) {
         return null;
     }
-    return loadTenantConfig(configDir, global.activeTenant);
+    return loadProjectConfig(configDir, global.activeProject);
 }
 async function readJsonFile(path) {
     try {

package/dist/dashboard/renderer.d.ts

@@ -1,4 +1,4 @@
-import type { TenantStatusSnapshot } from "@gh-symphony/core";
+import type { ProjectStatusSnapshot } from "@gh-symphony/core";
 export type DashboardOptions = {
     terminalWidth: number;
     noColor: boolean;
@@ -6,4 +6,4 @@ export type DashboardOptions = {
     /** Override Date.now() for deterministic testing */
     now?: number;
 };
-export declare function renderDashboard(snapshots: TenantStatusSnapshot[], options: DashboardOptions): string;
+export declare function renderDashboard(snapshots: ProjectStatusSnapshot[], options: DashboardOptions): string;

package/dist/dashboard/renderer.js

@@ -2,7 +2,7 @@
 import { bold, dim, green, red, yellow, cyan, magenta, blue, stripAnsi, } from "../ansi.js";
 // ── Column widths (from Elixir spec) ─────────────────────────────────────────
 const COL_ID = 24;
-const COL_STAGE = 14;
+const COL_STATUS = 14;
 const COL_PID = 8;
 const COL_AGE_TURN = 12;
 const COL_TOKENS = 10;
@@ -81,7 +81,7 @@ const COL_SEPARATORS = 6;
 function eventColWidth(termWidth) {
     const fixed = 2 +
         COL_ID_HEADER +
-        COL_STAGE +
+        COL_STATUS +
         COL_PID +
         COL_AGE_TURN +
         COL_TOKENS +
@@ -140,7 +140,7 @@ function buildSummaryLines(snapshots, options, c) {
 function tableHeaderRow(c) {
     const cols = [
         pad("ID", COL_ID_HEADER),
-        pad("STAGE", COL_STAGE),
+        pad("STATUS", COL_STATUS),
         pad("PID", COL_PID),
         pad("AGE/TURN", COL_AGE_TURN),
         pad("TOKENS", COL_TOKENS),
@@ -152,7 +152,7 @@ function tableHeaderRow(c) {
 function activeRunRow(run, now, evtWidth, c) {
     const dot = statusDot(run, c);
     const id = pad(run.issueIdentifier, COL_ID);
-    const stage = pad(run.issueState || "\u2014", COL_STAGE);
+    const status = pad(run.issueState ?? run.executionPhase ?? "\u2014", COL_STATUS);
     const pid = pad(run.processId != null ? String(run.processId) : "\u2014", COL_PID);
     const age = fmtAge(run.startedAt, now);
     const turn = run.turnCount ?? 0;
@@ -161,7 +161,7 @@ function activeRunRow(run, now, evtWidth, c) {
     const sessionId = run.runtimeSession?.sessionId ?? run.runtimeSession?.threadId ?? null;
     const session = pad(compactSessionId(sessionId), COL_SESSION);
     const event = pad(run.lastEvent ?? "\u2014", evtWidth);
-    const columns = [id, stage, pid, ageTurn, tokens, session, event].join(" ");
+    const columns = [id, status, pid, ageTurn, tokens, session, event].join(" ");
     return `  ${dot} ${columns}`;
 }
 function retryRow(entry, snapshot, now, c) {

package/dist/index.js

@@ -49,7 +49,6 @@ 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"),

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/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.7",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -36,10 +36,10 @@
   },
   "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"
+    "@gh-symphony/orchestrator": "0.0.7",
+    "@gh-symphony/core": "0.0.7",
+    "@gh-symphony/tracker-github": "0.0.7",
+    "@gh-symphony/worker": "0.0.7"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",