@gh-symphony/cli 0.0.6 → 0.0.8

package/dist/commands/project.js

@@ -1,101 +1,631 @@
 import * as p from "@clack/prompts";
-import { loadGlobalConfig, saveGlobalConfig, loadTenantConfig, } from "../config.js";
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { stripAnsi } from "../ansi.js";
+import { createClient, validateToken, checkRequiredScopes, listUserProjects, getProjectDetail, GitHubScopeError, } from "../github/client.js";
+import { ensureGhAuth, getGhToken, GhAuthError } from "../github/gh-auth.js";
+import { loadGlobalConfig, saveGlobalConfig, loadProjectConfig, projectConfigDir, daemonPidPath, } from "../config.js";
+import { writeConfig, generateProjectId, abortIfCancelled } from "./init.js";
+import startCommand from "./start.js";
+import statusCommand from "./status.js";
+import stopCommand from "./stop.js";
+import { resolveProjectOrchestratorStatusBaseUrl, } from "../orchestrator-status-endpoint.js";
+import { resolveRuntimeRoot } from "../orchestrator-runtime.js";
+const execFile = promisify(execFileCallback);
+const STATUS_REQUEST_TIMEOUT_MS = 1_500;
+const KNOWN_REQUIRED_SCOPES = ["repo", "read:org", "project"];
+function displayScopeError(error, retryCommand) {
+    const plural = error.requiredScopes.length === 1 ? "" : "s";
+    p.log.error(`Token is missing required scope${plural}: ${error.requiredScopes.join(", ")}`);
+    const currentSet = new Set(error.currentScopes.map((s) => s.toLowerCase()));
+    const scopesToAdd = KNOWN_REQUIRED_SCOPES.filter((s) => !currentSet.has(s));
+    const scopeArg = scopesToAdd.length > 0
+        ? scopesToAdd.join(",")
+        : error.requiredScopes.join(",");
+    p.note(`gh auth refresh --scopes ${scopeArg}\n\nThen re-run: ${retryCommand}`, "Fix missing scope");
+}
+function parseProjectAddFlags(args) {
+    const flags = { nonInteractive: false, assignedOnly: false };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        const next = args[i + 1];
+        switch (arg) {
+            case "--non-interactive":
+                flags.nonInteractive = true;
+                break;
+            case "--project":
+                flags.project = next;
+                i += 1;
+                break;
+            case "--workspace-dir":
+                flags.workspaceDir = next;
+                i += 1;
+                break;
+            case "--assigned-only":
+                flags.assignedOnly = true;
+                break;
+        }
+    }
+    return flags;
+}
 const handler = async (args, options) => {
-    const [subcommand] = args;
+    const [subcommand, ...rest] = args;
     switch (subcommand) {
+        case "add":
+            await projectAdd(rest, options);
+            return;
         case "list":
             await projectList(options);
-            break;
+            return;
+        case "remove":
+            await projectRemove(rest, options);
+            return;
+        case "start":
+            await startCommand(rest, options);
+            return;
+        case "stop":
+            await stopCommand(rest, options);
+            return;
         case "switch":
             await projectSwitch(options);
-            break;
+            return;
         case "status":
-            await projectStatus(options);
-            break;
+            await statusCommand(rest, options);
+            return;
         default:
-            process.stderr.write("Usage: gh-symphony project <list|switch|status>\n");
-            process.exitCode = 2;
+            process.stdout.write("Usage: gh-symphony project <add|list|remove|start|stop|switch|status>\n");
     }
 };
 export default handler;
-// ── 6.1: project list ────────────────────────────────────────────────────────
-async function projectList(options) {
-    const global = await loadGlobalConfig(options.configDir);
-    if (!global || global.tenants.length === 0) {
-        process.stdout.write("No tenants configured. Run 'gh-symphony init'.\n");
+function relativeTimeFromNow(isoString, now = new Date()) {
+    const then = new Date(isoString);
+    if (!Number.isFinite(then.getTime())) {
+        return "-";
+    }
+    const diffMs = Math.max(0, now.getTime() - then.getTime());
+    const diffS = Math.floor(diffMs / 1000);
+    const diffM = Math.floor(diffS / 60);
+    const diffH = Math.floor(diffM / 60);
+    const diffD = Math.floor(diffH / 24);
+    if (diffS < 60)
+        return `${diffS}s ago`;
+    if (diffM < 60)
+        return `${diffM}m ago`;
+    if (diffH < 24)
+        return `${diffH}h ago`;
+    return `${diffD}d ago`;
+}
+function formatDuration(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    const days = Math.floor(seconds / 86_400);
+    const hours = Math.floor((seconds % 86_400) / 3_600);
+    const minutes = Math.floor((seconds % 3_600) / 60);
+    if (days > 0) {
+        return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+    }
+    if (hours > 0) {
+        return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+    }
+    return `${minutes}m`;
+}
+function parsePsElapsedTime(raw) {
+    const value = raw.trim();
+    if (value.length === 0) {
+        return null;
+    }
+    const [dayPart, timePart] = value.includes("-")
+        ? value.split("-", 2)
+        : [null, value];
+    const timeSegments = timePart
+        .split(":")
+        .map((segment) => Number.parseInt(segment, 10));
+    if (timeSegments.some((segment) => !Number.isFinite(segment))) {
+        return null;
+    }
+    let seconds = 0;
+    if (timeSegments.length === 3) {
+        seconds += timeSegments[0] * 3_600;
+        seconds += timeSegments[1] * 60;
+        seconds += timeSegments[2];
+    }
+    else if (timeSegments.length === 2) {
+        seconds += timeSegments[0] * 60;
+        seconds += timeSegments[1];
+    }
+    else {
+        return null;
+    }
+    if (dayPart !== null) {
+        const days = Number.parseInt(dayPart, 10);
+        if (!Number.isFinite(days)) {
+            return null;
+        }
+        seconds += days * 86_400;
+    }
+    return seconds;
+}
+async function readPid(configDir, projectId) {
+    try {
+        const raw = await readFile(daemonPidPath(configDir, projectId), "utf8");
+        const pid = Number.parseInt(raw.trim(), 10);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "EPERM") {
+            return true;
+        }
+        return false;
+    }
+}
+async function readPersistedSnapshot(configDir, projectId) {
+    try {
+        const runtimeRoot = resolveRuntimeRoot(configDir);
+        const content = await readFile(join(runtimeRoot, "orchestrator", "projects", projectId, "status.json"), "utf8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchProjectSnapshot(configDir, projectId, baseUrl) {
+    if (!baseUrl) {
+        return readPersistedSnapshot(configDir, projectId);
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), STATUS_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(`${baseUrl}/api/v1/status`, {
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return readPersistedSnapshot(configDir, projectId);
+        }
+        return (await response.json());
+    }
+    catch {
+        return readPersistedSnapshot(configDir, projectId);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function readProcessUptime(pid) {
+    if (process.platform === "win32") {
+        return "-";
+    }
+    try {
+        const { stdout } = await execFile("ps", ["-o", "etime=", "-p", String(pid)]);
+        const seconds = parsePsElapsedTime(stdout);
+        return seconds === null ? "-" : formatDuration(seconds);
+    }
+    catch {
+        return "-";
+    }
+}
+function defaultProjectName(config, projectId) {
+    return config?.displayName ?? config?.slug ?? projectId;
+}
+function isCombiningCodePoint(codePoint) {
+    return ((codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe20 && codePoint <= 0xfe2f));
+}
+function isWideCodePoint(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+            (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+}
+function stringDisplayWidth(value) {
+    const visible = stripAnsi(value);
+    let width = 0;
+    for (const char of visible) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint === undefined) {
+            continue;
+        }
+        if (codePoint === 0 ||
+            codePoint < 0x20 ||
+            (codePoint >= 0x7f && codePoint < 0xa0) ||
+            isCombiningCodePoint(codePoint)) {
+            continue;
+        }
+        width += isWideCodePoint(codePoint) ? 2 : 1;
+    }
+    return width;
+}
+async function collectProjectListRows(configDir, global) {
+    return Promise.all(global.projects.map(async (projectId) => {
+        const config = await loadProjectConfig(configDir, projectId);
+        const pid = await readPid(configDir, projectId);
+        const running = pid !== null && isProcessRunning(pid);
+        const endpointBaseUrl = running
+            ? await resolveProjectOrchestratorStatusBaseUrl({
+                configDir,
+                projectId,
+            })
+            : null;
+        const endpoint = endpointBaseUrl ?? "-";
+        const snapshot = running
+            ? await fetchProjectSnapshot(configDir, projectId, endpointBaseUrl)
+            : null;
+        return {
+            id: projectId,
+            name: defaultProjectName(config, projectId),
+            status: running ? "running" : "stopped",
+            endpoint,
+            health: snapshot?.health ?? "-",
+            activeRuns: snapshot?.summary.activeRuns ?? null,
+            lastTick: snapshot?.lastTickAt
+                ? relativeTimeFromNow(snapshot.lastTickAt)
+                : "-",
+            uptime: pid !== null && running ? await readProcessUptime(pid) : "-",
+            active: global.activeProject === projectId,
+        };
+    }));
+}
+function renderTable(headers, rows) {
+    const widths = headers.map((header, index) => Math.max(stringDisplayWidth(header), ...rows.map((row) => stringDisplayWidth(row[index] ?? ""))));
+    const formatRow = (left, sep, right, values) => left +
+        values
+            .map((value, index) => {
+            const width = widths[index];
+            const displayWidth = stringDisplayWidth(value);
+            return ` ${value}${" ".repeat(width - displayWidth)} `;
+        })
+            .join(sep) +
+        right;
+    const border = (left, middle, right) => left + widths.map((width) => "─".repeat(width + 2)).join(middle) + right;
+    return [
+        border("┌", "┬", "┐"),
+        formatRow("│", "│", "│", headers),
+        border("├", "┼", "┤"),
+        ...rows.map((row) => formatRow("│", "│", "│", row)),
+        border("└", "┴", "┘"),
+    ].join("\n");
+}
+async function projectAdd(args, options) {
+    const flags = parseProjectAddFlags(args);
+    if (flags.nonInteractive) {
+        await projectAddNonInteractive(flags, options);
         return;
     }
-    if (options.json) {
-        const configs = [];
-        for (const tId of global.tenants) {
-            const t = await loadTenantConfig(options.configDir, tId);
-            configs.push({
-                id: tId,
-                active: tId === global.activeTenant,
-                repos: t?.repositories.length ?? 0,
-            });
+    await projectAddInteractive(options);
+}
+async function projectAddNonInteractive(flags, options) {
+    let token;
+    try {
+        token = getGhToken();
+    }
+    catch {
+        process.stderr.write("Error: GitHub token not found. Run 'gh auth login --scopes repo,read:org,project' or set GITHUB_GRAPHQL_TOKEN.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const client = createClient(token);
+    let viewer;
+    try {
+        viewer = await validateToken(client);
+    }
+    catch {
+        process.stderr.write("Error: Invalid GitHub token.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const scopeCheck = checkRequiredScopes(viewer.scopes);
+    if (!scopeCheck.valid) {
+        process.stderr.write(`Error: Missing required PAT scopes: ${scopeCheck.missing.join(", ")}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const projects = await listUserProjects(client);
+    let project;
+    if (flags.project) {
+        const match = projects.find((entry) => entry.id === flags.project || entry.url === flags.project);
+        if (!match) {
+            process.stderr.write(`Error: Project not found: ${flags.project}\n`);
+            process.exitCode = 1;
+            return;
         }
-        process.stdout.write(JSON.stringify(configs, null, 2) + "\n");
+        project = await getProjectDetail(client, match.id);
+    }
+    else if (projects.length === 1) {
+        project = await getProjectDetail(client, projects[0].id);
+    }
+    else {
+        process.stderr.write("Error: --project is required when multiple projects exist.\n");
+        process.exitCode = 1;
         return;
     }
-    process.stdout.write("Tenants:\n\n");
-    for (const tId of global.tenants) {
-        const t = await loadTenantConfig(options.configDir, tId);
-        const active = tId === global.activeTenant ? " (active)" : "";
-        const repos = t?.repositories.length ?? 0;
-        process.stdout.write(`  ${tId}${active} — ${repos} repo${repos === 1 ? "" : "s"}\n`);
+    const projectId = generateProjectId(project.title, project.id);
+    const workspaceDir = flags.workspaceDir ?? `${options.configDir}/workspaces`;
+    await writeConfig(options.configDir, {
+        projectId,
+        project,
+        repos: project.linkedRepositories,
+        workspaceDir,
+        assignedOnly: flags.assignedOnly,
+    });
+    if (options.json) {
+        process.stdout.write(JSON.stringify({ projectId, status: "created" }) + "\n");
+    }
+    else {
+        process.stdout.write(`Project created: ${projectId}\n`);
+        process.stdout.write(`Run 'gh-symphony start' to begin orchestration.\n`);
     }
 }
-// ── 6.2: project switch ──────────────────────────────────────────────────────
-async function projectSwitch(options) {
-    const global = await loadGlobalConfig(options.configDir);
-    if (!global || global.tenants.length === 0) {
-        process.stderr.write("No tenants configured. Run 'gh-symphony init'.\n");
+async function projectAddInteractive(options) {
+    p.intro("gh-symphony - Project Setup");
+    const existingConfig = await loadGlobalConfig(options.configDir);
+    if (existingConfig) {
+        const action = await abortIfCancelled(p.select({
+            message: "Existing configuration detected. What would you like to do?",
+            options: [
+                { value: "add", label: "Add a new project" },
+                { value: "overwrite", label: "Start fresh (overwrite)" },
+            ],
+        }));
+        if (action === "overwrite") {
+            // Continue with fresh setup and overwrite the active config.
+        }
+    }
+    const s1 = p.spinner();
+    s1.start("Checking gh CLI authentication...");
+    let login;
+    let client;
+    try {
+        const { login: ghLogin, token } = ensureGhAuth();
+        login = ghLogin;
+        client = createClient(token);
+        s1.stop(`Authenticated as ${login}`);
+    }
+    catch (error) {
+        s1.stop("Authentication failed.");
+        if (error instanceof GhAuthError) {
+            if (error.code === "not_installed") {
+                p.log.error("gh CLI가 설치되어 있지 않습니다. https://cli.github.com 에서 설치하세요.");
+            }
+            else if (error.code === "not_authenticated") {
+                p.log.error("gh auth login --scopes repo,read:org,project 를 실행하세요.");
+            }
+            else if (error.code === "missing_scopes") {
+                p.log.error("gh auth refresh --scopes repo,read:org,project 를 실행하세요.");
+            }
+            else {
+                p.log.error(error.message);
+            }
+        }
+        else {
+            p.log.error(error instanceof Error ? error.message : "Unknown error");
+        }
         process.exitCode = 1;
         return;
     }
-    if (global.tenants.length === 1) {
-        process.stdout.write(`Only one tenant exists: ${global.tenants[0]}\n`);
+    const s2 = p.spinner();
+    s2.start("Loading GitHub Project boards...");
+    let projects;
+    try {
+        projects = await listUserProjects(client);
+        s2.stop(`Found ${projects.length} project${projects.length === 1 ? "" : "s"}`);
+    }
+    catch (error) {
+        s2.stop("Failed to load projects.");
+        if (error instanceof GitHubScopeError) {
+            displayScopeError(error, "gh-symphony project add");
+        }
+        else {
+            p.log.error(error instanceof Error ? error.message : "Unknown error");
+        }
+        process.exitCode = 1;
         return;
     }
-    const selected = await p.select({
-        message: "Select tenant to activate:",
-        options: global.tenants.map((tId) => ({
-            value: tId,
-            label: tId,
-            hint: tId === global.activeTenant ? "current" : undefined,
+    if (projects.length === 0) {
+        p.log.error("No GitHub Projects found. Create a project at https://github.com/orgs/YOUR_ORG/projects and re-run.");
+        process.exitCode = 1;
+        return;
+    }
+    const selectedProjectId = await abortIfCancelled(p.select({
+        message: "Step 1/4 - Select a GitHub Project board:",
+        options: projects.map((project) => ({
+            value: project.id,
+            label: `${project.owner.login}/${project.title}`,
+            hint: `${project.openItemCount} items`,
         })),
-    });
-    if (p.isCancel(selected)) {
-        p.cancel("Cancelled.");
+        maxItems: 15,
+    }));
+    const s2d = p.spinner();
+    s2d.start("Loading project details...");
+    let projectDetail;
+    try {
+        projectDetail = await getProjectDetail(client, selectedProjectId);
+        s2d.stop(`Loaded: ${projectDetail.title}`);
+    }
+    catch (error) {
+        s2d.stop("Failed to load project details.");
+        p.log.error(error instanceof Error ? error.message : "Unknown error");
+        process.exitCode = 1;
         return;
     }
-    global.activeTenant = selected;
-    await saveGlobalConfig(options.configDir, global);
-    process.stdout.write(`Switched to tenant: ${selected}\n`);
+    if (projectDetail.linkedRepositories.length === 0) {
+        p.log.warn("No linked repositories found in this project. Add issues from repositories to the project first.");
+        process.exitCode = 1;
+        return;
+    }
+    const selectedRepos = await abortIfCancelled(p.multiselect({
+        message: "Step 2/4 - Select repositories to orchestrate:",
+        options: projectDetail.linkedRepositories.map((repo) => ({
+            value: repo,
+            label: `${repo.owner}/${repo.name}`,
+        })),
+        required: true,
+    }));
+    const assignedOnly = await abortIfCancelled(p.confirm({
+        message: "Step 3/4 - Only process issues assigned to the authenticated GitHub user?",
+        initialValue: false,
+    }));
+    const workspaceDir = await abortIfCancelled(p.text({
+        message: "Step 4/4 - Workspace root directory:",
+        placeholder: `${options.configDir}/workspaces`,
+        defaultValue: `${options.configDir}/workspaces`,
+        validate(value) {
+            return value.trim().length > 0
+                ? undefined
+                : "Workspace directory is required.";
+        },
+    }));
+    p.note([
+        `User:       ${login}`,
+        `Project:    ${projectDetail.title}`,
+        `Repos:      ${selectedRepos.map((repo) => `${repo.owner}/${repo.name}`).join(", ")}`,
+        `Assigned:   ${assignedOnly ? `Only issues assigned to ${login}` : "All project issues"}`,
+        `Workspace:  ${workspaceDir}`,
+    ].join("\n"), "Configuration Summary");
+    const confirmed = await abortIfCancelled(p.confirm({ message: "Apply this configuration?" }));
+    if (!confirmed) {
+        p.cancel("Setup cancelled.");
+        process.exitCode = 130;
+        return;
+    }
+    const projectId = generateProjectId(projectDetail.title, projectDetail.id);
+    const s6 = p.spinner();
+    s6.start("Writing configuration...");
+    try {
+        await writeConfig(options.configDir, {
+            projectId,
+            project: projectDetail,
+            repos: selectedRepos,
+            workspaceDir,
+            assignedOnly,
+        });
+        s6.stop("Configuration saved.");
+    }
+    catch (error) {
+        s6.stop("Failed to write configuration.");
+        p.log.error(error instanceof Error ? error.message : "Unknown error");
+        process.exitCode = 1;
+        return;
+    }
+    p.outro(`Project "${projectId}" created.\n  Run 'gh-symphony start' to begin orchestration.`);
 }
-// ── 6.3: project status ──────────────────────────────────────────────────────
-async function projectStatus(options) {
+async function projectList(options) {
     const global = await loadGlobalConfig(options.configDir);
-    if (!global?.activeTenant) {
-        process.stderr.write("No active tenant.\n");
+    if (!global?.projects?.length) {
+        process.stdout.write("No projects configured.\n");
+        return;
+    }
+    const rows = await collectProjectListRows(options.configDir, global);
+    if (options.json) {
+        process.stdout.write(JSON.stringify(rows, null, 2) + "\n");
+        return;
+    }
+    const table = renderTable([
+        "ID",
+        "Name",
+        "Status",
+        "Endpoint",
+        "Health",
+        "Active Runs",
+        "Last Tick",
+        "Uptime",
+    ], rows.map((row) => [
+        row.id,
+        row.name,
+        row.status,
+        row.endpoint,
+        row.health,
+        row.activeRuns === null ? "-" : String(row.activeRuns),
+        row.lastTick,
+        row.uptime,
+    ]));
+    process.stdout.write(`${table}\n`);
+}
+async function projectRemove(args, options) {
+    const projectId = args[0];
+    if (!projectId) {
+        process.stderr.write("Usage: gh-symphony project remove <project-id>\n");
         process.exitCode = 1;
         return;
     }
-    const t = await loadTenantConfig(options.configDir, global.activeTenant);
-    if (!t) {
-        process.stderr.write(`Tenant config missing: ${global.activeTenant}\n`);
+    const global = await loadGlobalConfig(options.configDir);
+    if (!global) {
+        process.stderr.write("No configuration found.\n");
         process.exitCode = 1;
         return;
     }
-    if (options.json) {
-        process.stdout.write(JSON.stringify(t, null, 2) + "\n");
+    const updatedProjects = global.projects.filter((entry) => entry !== projectId);
+    if (updatedProjects.length === global.projects.length) {
+        process.stderr.write(`Project "${projectId}" not found.\n`);
+        process.exitCode = 1;
         return;
     }
-    process.stdout.write(`Tenant:      ${t.tenantId}\n`);
-    process.stdout.write(`Tracker:     ${t.tracker.adapter} (${t.tracker.bindingId})\n`);
-    process.stdout.write(`Repositories:\n`);
-    for (const repo of t.repositories) {
-        process.stdout.write(`  - ${repo.owner}/${repo.name}\n`);
+    const updatedConfig = {
+        ...global,
+        projects: updatedProjects,
+        activeProject: global.activeProject === projectId ? null : global.activeProject,
+    };
+    await saveGlobalConfig(options.configDir, updatedConfig);
+    const { rm } = await import("node:fs/promises");
+    try {
+        await rm(projectConfigDir(options.configDir, projectId), {
+            recursive: true,
+            force: true,
+        });
     }
+    catch {
+        // Directory may not exist.
+    }
+    process.stdout.write(`Project "${projectId}" removed.\n`);
+}
+async function projectSwitch(options) {
+    const global = await loadGlobalConfig(options.configDir);
+    if (!global || global.projects.length === 0) {
+        process.stderr.write("No projects configured. Run 'gh-symphony init'.\n");
+        process.exitCode = 1;
+        return;
+    }
+    if (global.projects.length === 1) {
+        process.stdout.write(`Only one project exists: ${global.projects[0]}\n`);
+        return;
+    }
+    const selected = await p.select({
+        message: "Select project to activate:",
+        options: global.projects.map((projectId) => ({
+            value: projectId,
+            label: projectId,
+            hint: projectId === global.activeProject ? "current" : undefined,
+        })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        return;
+    }
+    global.activeProject = selected;
+    await saveGlobalConfig(options.configDir, global);
+    process.stdout.write(`Switched to project: ${selected}\n`);
 }