@gh-symphony/cli 0.0.5 → 0.0.7

package/README.md

@@ -48,12 +48,12 @@ You can further customize the agent's behavior by editing `WORKFLOW.md` — this
 
 > Currently supported runtimes: **Codex**, **Claude Code**
 
-## 3. Set Orchestrator Runner (Tenant)
+## 3. Set Orchestrator Runner (Project)
 
-On the machine where you want the orchestrator to run, register a tenant:
+On the machine where you want the orchestrator to run, register a project:
 
 ```bash
-gh-symphony tenant add
+gh-symphony project add
 ```
 
 The interactive wizard will:
@@ -61,15 +61,15 @@ The interactive wizard will:
 1. Authenticate via `gh` CLI
 2. Let you select a **GitHub Project**
 3. Select repositories to orchestrate
-4. Auto-detect workflow column mappings
-5. Choose an AI runtime (Codex / Claude Code / custom)
-6. Write tenant configuration to `~/.gh-symphony/`
+4. Optionally limit processing to issues assigned to the authenticated user
+5. Configure the workspace root directory
+6. Write project configuration to `~/.gh-symphony/`
 
-### Tenant Management
+### Project Management
 
 ```bash
-gh-symphony tenant list             # List all configured tenants
-gh-symphony tenant remove <id>      # Remove a tenant
+gh-symphony project list             # List all configured projects
+gh-symphony project remove <id>      # Remove a project
 ```
 
 ## 4. Run the Orchestrator
@@ -127,10 +127,10 @@ Orchestration:
   recover             Recover stalled runs
   logs                View orchestrator logs
 
-Tenant Management:
-  tenant add          Add a new tenant (interactive wizard)
-  tenant list         List all configured tenants
-  tenant remove       Remove a tenant
+Project Management:
+  project add          Add a new project (interactive wizard)
+  project list         List all configured projects
+  project remove       Remove a project
 
 Global Options:
   --config <dir>      Config directory (default: ~/.gh-symphony)

package/dist/commands/config-cmd.js

@@ -31,12 +31,12 @@ async function configShow(options) {
         return;
     }
     process.stdout.write(`Config: ${configFilePath(options.configDir)}\n\n`);
-    process.stdout.write(`Active tenant:    ${config.activeTenant ?? "none"}\n`);
-    process.stdout.write(`Tenants:          ${config.tenants.join(", ") || "none"}\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-tenant": { type: "string" },
+    "active-project": { type: "string" },
 };
 async function configSet(args, options) {
     const [key, value] = args;
@@ -54,17 +54,17 @@ async function configSet(args, options) {
     }
     const config = (await loadGlobalConfig(options.configDir)) ??
         {
-            activeTenant: null,
-            tenants: [],
+            activeProject: null,
+            projects: [],
         };
     switch (key) {
-        case "active-tenant":
-            if (!config.tenants.includes(value)) {
-                process.stderr.write(`Tenant "${value}" not found. Available: ${config.tenants.join(", ")}\n`);
+        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.activeTenant = value;
+            config.activeProject = value;
             break;
     }
     await saveGlobalConfig(options.configDir, config);

package/dist/commands/help.js

@@ -4,7 +4,7 @@ gh-symphony — AI Coding Agent Orchestrator
 Usage: gh-symphony <command> [options]
 
 Setup:
-  init            Interactive tenant setup wizard
+  init            Interactive project setup wizard
   config show     Show current configuration
   config set      Set a configuration value
   config edit     Open config in $EDITOR
@@ -18,15 +18,15 @@ Orchestration:
   recover         Recover stalled runs
   logs            View orchestrator logs
 
-Tenant Management:
-  tenant add      Add a new tenant (interactive wizard)
-  tenant list     List all configured tenants
-  tenant remove   Remove a tenant
+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 tenants
-  project switch  Switch active tenant
-  project status  Show active tenant details
+  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
@@ -40,10 +40,10 @@ Global Options:
   --version, -V   Show version
 
 Examples:
-  gh-symphony tenant add              # Add a tenant (interactive)
-  gh-symphony tenant add --non-interactive --project <id>
-  gh-symphony tenant list             # List all tenants
-  gh-symphony tenant remove <id>      # Remove a tenant
+  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

package/dist/commands/init.d.ts

@@ -1,6 +1,5 @@
 import type { GlobalOptions } from "../index.js";
 import { type ProjectDetail, type ProjectStatusField, type LinkedRepository } from "../github/client.js";
-import { type StateMapping } from "../config.js";
 export declare function abortIfCancelled<T>(input: T | Promise<T>): Promise<Exclude<T, symbol>>;
 declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
 export default handler;
@@ -14,7 +13,7 @@ type EcosystemOptions = {
 };
 export type EcosystemResult = {
     projectId: string;
-    projectTitle: string;
+    githubProjectTitle: string;
     runtime: string;
     skillsDir: string | null;
     contextYamlWritten: boolean;
@@ -24,26 +23,12 @@ export type EcosystemResult = {
 };
 export declare function writeEcosystem(opts: EcosystemOptions): Promise<EcosystemResult>;
 type WriteConfigInput = {
-    tenantId: string;
+    projectId: string;
     project: ProjectDetail;
     repos: LinkedRepository[];
-    statusField: {
-        id: string;
-        name: string;
-        options: Array<{
-            id: string;
-            name: string;
-            color?: string | null;
-        }>;
-    };
-    mappings: Record<string, StateMapping>;
-    runtime: string;
-    agentCommand?: string;
-    workerCommand?: string;
-    pollIntervalMs?: number;
-    concurrency?: number;
+    workspaceDir: string;
     maxAttempts?: number;
     assignedOnly?: boolean;
 };
 export declare function writeConfig(configDir: string, input: WriteConfigInput): Promise<void>;
-export declare function generateTenantId(projectTitle: string, uniqueKey: string): string;
+export declare function generateProjectId(githubProjectTitle: string, uniqueKey: string): string;

package/dist/commands/init.js

@@ -2,11 +2,10 @@ import * as p from "@clack/prompts";
 import { createHash } from "node:crypto";
 import { mkdir, rename, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import { createClient, validateToken, checkRequiredScopes, listUserProjects, getProjectDetail, GitHubScopeError, } from "../github/client.js";
 import { inferAllStateRoles, toWorkflowLifecycleConfig, validateStateMapping, } from "../mapping/smart-defaults.js";
 import { generateWorkflowMarkdown } from "../workflow/generate-workflow-md.js";
-import { loadGlobalConfig, saveGlobalConfig, saveTenantConfig, saveWorkflowMapping, } from "../config.js";
+import { loadGlobalConfig, saveGlobalConfig, saveProjectConfig, } from "../config.js";
 import { getGhToken, ensureGhAuth, GhAuthError } from "../github/gh-auth.js";
 import { detectEnvironment } from "../detection/environment-detector.js";
 import { buildContextYaml, writeContextYaml, } from "../context/generate-context-yaml.js";
@@ -121,7 +120,7 @@ export async function writeEcosystem(opts) {
         const result = await writeAllSkills(cwd, runtime, ALL_SKILL_TEMPLATES, {
             runtime,
             projectId: projectDetail.id,
-            projectTitle: projectDetail.title,
+            githubProjectTitle: projectDetail.title,
             repositories: projectDetail.linkedRepositories.map((r) => ({
                 owner: r.owner,
                 name: r.name,
@@ -140,7 +139,7 @@ export async function writeEcosystem(opts) {
     }
     return {
         projectId: projectDetail.id,
-        projectTitle: projectDetail.title,
+        githubProjectTitle: projectDetail.title,
         runtime,
         skillsDir,
         contextYamlWritten,
@@ -154,7 +153,7 @@ function printEcosystemSummary(result, workflowPath, opts) {
     const cwd = process.cwd();
     const relWorkflow = relative(cwd, workflowPath) || "WORKFLOW.md";
     const lines = [];
-    lines.push(`Project   ${result.projectTitle}  (${result.projectId})`);
+    lines.push(`GitHub Project   ${result.githubProjectTitle}  (${result.projectId})`);
     lines.push(`Runtime   ${result.runtime}`);
     lines.push("");
     lines.push("Generated files");
@@ -218,7 +217,7 @@ async function runNonInteractive(flags, options) {
     }
     // Find project
     const projects = await listUserProjects(client);
-    let project;
+    let githubProject;
     if (flags.project) {
         const match = projects.find((proj) => proj.id === flags.project || proj.url === flags.project);
         if (!match) {
@@ -226,10 +225,10 @@ async function runNonInteractive(flags, options) {
             process.exitCode = 1;
             return;
         }
-        project = await getProjectDetail(client, match.id);
+        githubProject = await getProjectDetail(client, match.id);
     }
     else if (projects.length === 1) {
-        project = await getProjectDetail(client, projects[0].id);
+        githubProject = await getProjectDetail(client, projects[0].id);
     }
     else {
         process.stderr.write("Error: --project is required when multiple projects exist.\n");
@@ -237,8 +236,8 @@ async function runNonInteractive(flags, options) {
         return;
     }
     // Auto-map with smart defaults
-    const statusField = project.statusFields.find((f) => f.name.toLowerCase() === "status") ??
-        project.statusFields[0];
+    const statusField = githubProject.statusFields.find((f) => f.name.toLowerCase() === "status") ??
+        githubProject.statusFields[0];
     if (!statusField) {
         process.stderr.write("Error: No status field found on the project.\n");
         process.exitCode = 1;
@@ -261,7 +260,7 @@ async function runNonInteractive(flags, options) {
     const lifecycleConfig = toWorkflowLifecycleConfig(statusField.name, mappings);
     const outputPath = resolve(flags.output ?? "WORKFLOW.md");
     const workflowMd = generateWorkflowMarkdown({
-        projectId: project.id,
+        projectId: githubProject.id,
         stateFieldName: statusField.name,
         mappings,
         lifecycle: lifecycleConfig,
@@ -270,7 +269,7 @@ async function runNonInteractive(flags, options) {
     await writeFile(outputPath, workflowMd, "utf8");
     const ecosystemResult = await writeEcosystem({
         cwd: process.cwd(),
-        projectDetail: project,
+        projectDetail: githubProject,
         statusField,
         runtime: "codex",
         skipSkills: flags.skipSkills,
@@ -282,7 +281,7 @@ async function runNonInteractive(flags, options) {
     else {
         printEcosystemSummary(ecosystemResult, outputPath, {
             interactive: false,
-            nextSteps: "Run 'gh-symphony tenant add' to register a tenant.",
+            nextSteps: "Run 'gh-symphony project add' to register a project.",
         });
     }
 }
@@ -347,8 +346,8 @@ async function runInteractiveStandalone(_options) {
         process.exitCode = 1;
         return;
     }
-    const selectedProjectId = await abortIfCancelled(p.select({
-        message: "Step 1/2 — Select a GitHub Project:",
+    const selectedGithubProjectId = await abortIfCancelled(p.select({
+        message: "Step 1/2 — Select a GitHub Project board:",
         options: projects.map((proj) => ({
             value: proj.id,
             label: `${proj.owner.login}/${proj.title}`,
@@ -360,7 +359,7 @@ async function runInteractiveStandalone(_options) {
     s2d.start("Loading project details...");
     let projectDetail;
     try {
-        projectDetail = await getProjectDetail(client, selectedProjectId);
+        projectDetail = await getProjectDetail(client, selectedGithubProjectId);
         s2d.stop(`Loaded: ${projectDetail.title}`);
     }
     catch (error) {
@@ -433,32 +432,15 @@ async function runInteractiveStandalone(_options) {
     });
     printEcosystemSummary(ecosystemResult, outputPath, {
         interactive: true,
-        nextSteps: "Run 'gh-symphony tenant add' to register a tenant.",
+        nextSteps: "Run 'gh-symphony project add' to register a project.",
     });
 }
-function resolveWorkerCommand() {
-    try {
-        const url = import.meta.resolve("@gh-symphony/worker/dist/index.js");
-        return `node ${fileURLToPath(url)}`;
-    }
-    catch {
-        return undefined;
-    }
-}
 export async function writeConfig(configDir, input) {
-    const lifecycleConfig = toWorkflowLifecycleConfig(input.statusField.name, input.mappings);
-    // Save workflow mapping
-    const mappingConfig = {
-        stateFieldName: input.statusField.name,
-        mappings: input.mappings,
-        lifecycle: lifecycleConfig,
-    };
-    await saveWorkflowMapping(configDir, input.tenantId, mappingConfig);
-    // Save tenant config (OrchestratorTenantConfig shape)
-    const runtimeDir = `${configDir}/tenants/${input.tenantId}/runtime`;
-    await saveTenantConfig(configDir, input.tenantId, {
-        tenantId: input.tenantId,
-        slug: input.tenantId,
+    await saveProjectConfig(configDir, input.projectId, {
+        projectId: input.projectId,
+        slug: input.projectId,
+        displayName: input.project.title,
+        workspaceDir: input.workspaceDir,
         repositories: input.repos.map((r) => ({
             owner: r.owner,
             name: r.name,
@@ -472,43 +454,24 @@ export async function writeConfig(configDir, input) {
                 ...(input.assignedOnly ? { assignedOnly: true } : {}),
             },
         },
-        runtime: {
-            driver: "local",
-            workspaceRuntimeDir: runtimeDir,
-            projectRoot: process.cwd(),
-            workerCommand: input.workerCommand ?? resolveWorkerCommand(),
-        },
-        workflowMapping: mappingConfig,
     });
     // Save/update global config
     const existing = await loadGlobalConfig(configDir);
     const globalConfig = {
-        activeTenant: input.tenantId,
-        tenants: [
-            ...(existing?.tenants ?? []).filter((t) => t !== input.tenantId),
-            input.tenantId,
+        activeProject: input.projectId,
+        projects: [
+            ...(existing?.projects ?? []).filter((t) => t !== input.projectId),
+            input.projectId,
         ],
     };
     await saveGlobalConfig(configDir, globalConfig);
-    // Generate WORKFLOW.md for tenant-level fallback
-    const workflowMd = generateWorkflowMarkdown({
-        projectId: input.project.id,
-        stateFieldName: input.statusField.name,
-        mappings: input.mappings,
-        lifecycle: lifecycleConfig,
-        runtime: input.agentCommand ?? input.runtime,
-        pollIntervalMs: input.pollIntervalMs,
-        concurrency: input.concurrency,
-    });
-    const workflowMdPath = join(configDir, "tenants", input.tenantId, "WORKFLOW.md");
-    await writeFile(workflowMdPath, workflowMd, "utf8");
 }
-export function generateTenantId(projectTitle, uniqueKey) {
-    const slug = projectTitle
+export function generateProjectId(githubProjectTitle, uniqueKey) {
+    const slug = githubProjectTitle
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-|-$/g, "")
         .slice(0, 32);
     const suffix = createHash("sha1").update(uniqueKey).digest("hex").slice(0, 8);
-    return [slug || "tenant", suffix].join("-");
+    return [slug || "project", suffix].join("-");
 }

package/dist/commands/logs.js

@@ -2,7 +2,7 @@ import { readFile, readdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { createReadStream } from "node:fs";
 import { createInterface } from "node:readline";
-import { loadActiveTenantConfig, orchestratorLogPath } from "../config.js";
+import { loadActiveProjectConfig, loadProjectConfig, orchestratorLogPath, } from "../config.js";
 function parseLogsArgs(args) {
     const parsed = { follow: false };
     for (let i = 0; i < args.length; i += 1) {
@@ -22,14 +22,20 @@ function parseLogsArgs(args) {
             parsed.level = args[i + 1];
             i += 1;
         }
+        if (arg === "--project" || arg === "--project-id") {
+            parsed.projectId = args[i + 1];
+            i += 1;
+        }
     }
     return parsed;
 }
 const handler = async (args, options) => {
     const parsed = parseLogsArgs(args);
-    const tenantConfig = await loadActiveTenantConfig(options.configDir);
-    if (!tenantConfig) {
-        process.stderr.write("No tenant configured. Run 'gh-symphony init' first.\n");
+    const projectConfig = parsed.projectId
+        ? await loadProjectConfig(options.configDir, parsed.projectId)
+        : await loadActiveProjectConfig(options.configDir);
+    if (!projectConfig) {
+        process.stderr.write("No project configured. Run 'gh-symphony project add' first.\n");
         process.exitCode = 1;
         return;
     }
@@ -56,7 +62,7 @@ const handler = async (args, options) => {
     }
     // Default: read orchestrator log or scan all events
     if (parsed.follow) {
-        const logPath = orchestratorLogPath(options.configDir);
+        const logPath = orchestratorLogPath(options.configDir, projectConfig.projectId);
         try {
             const stream = createReadStream(logPath, { encoding: "utf8" });
             const rl = createInterface({ input: stream });

package/dist/commands/parse-cli-args.d.ts

@@ -0,0 +1,6 @@
+import { parseArgs, type ParseArgsOptionsConfig } from "node:util";
+type ParseCliArgsResult = ReturnType<typeof parseArgs> | {
+    error: string;
+};
+export declare function parseCliArgs(args: string[], options: ParseArgsOptionsConfig): ParseCliArgsResult;
+export {};

package/dist/commands/parse-cli-args.js

@@ -0,0 +1,20 @@
+import { parseArgs } from "node:util";
+export function parseCliArgs(args, options) {
+    try {
+        return parseArgs({
+            args,
+            options,
+            allowPositionals: false,
+            strict: true,
+        });
+    }
+    catch (error) {
+        return { error: formatParseArgsError(error) };
+    }
+}
+function formatParseArgsError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return "Invalid arguments";
+}