@gh-symphony/cli 0.0.1

package/dist/github/client.js

@@ -0,0 +1,300 @@
+const DEFAULT_API_URL = "https://api.github.com/graphql";
+const REST_API_URL = "https://api.github.com";
+export class GitHubApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "GitHubApiError";
+    }
+}
+export function createClient(token, options) {
+    return {
+        token,
+        apiUrl: options?.apiUrl ?? DEFAULT_API_URL,
+        fetchImpl: options?.fetchImpl ?? fetch,
+    };
+}
+// ── 2.1: Token validation & scope check ──────────────────────────────────────
+export async function validateToken(client) {
+    // Use REST to get X-OAuth-Scopes header (GraphQL doesn't expose scopes)
+    const restUrl = client.apiUrl.replace("/graphql", "");
+    const baseUrl = restUrl === client.apiUrl ? REST_API_URL : restUrl;
+    const response = await client.fetchImpl(`${baseUrl}/user`, {
+        headers: {
+            authorization: `Bearer ${client.token}`,
+            accept: "application/vnd.github+json",
+        },
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new GitHubApiError("Invalid token: authentication failed.", 401);
+        }
+        throw new GitHubApiError(`GitHub API error: ${response.status} ${response.statusText}`, response.status);
+    }
+    const scopes = response.headers
+        .get("x-oauth-scopes")
+        ?.split(",")
+        .map((s) => s.trim())
+        .filter(Boolean) ?? [];
+    const user = (await response.json());
+    return {
+        login: user.login,
+        name: user.name,
+        scopes,
+    };
+}
+export function checkRequiredScopes(scopes) {
+    const required = ["repo", "read:org", "project"];
+    const normalizedScopes = scopes.map((s) => s.toLowerCase());
+    const missing = required.filter((r) => !normalizedScopes.includes(r));
+    return { valid: missing.length === 0, missing };
+}
+// ── 2.2: Projects v2 list ────────────────────────────────────────────────────
+export async function listUserProjects(client) {
+    const data = await graphql(client, VIEWER_PROJECTS_QUERY);
+    const projects = [];
+    for (const node of data.viewer.projectsV2?.nodes ?? []) {
+        if (!node)
+            continue;
+        projects.push(normalizeProjectSummary(node, {
+            login: data.viewer.login,
+            type: "User",
+        }));
+    }
+    for (const orgNode of data.viewer.organizations?.nodes ?? []) {
+        if (!orgNode)
+            continue;
+        for (const projNode of orgNode.projectsV2?.nodes ?? []) {
+            if (!projNode)
+                continue;
+            projects.push(normalizeProjectSummary(projNode, {
+                login: orgNode.login,
+                type: "Organization",
+            }));
+        }
+    }
+    return projects;
+}
+function normalizeProjectSummary(node, owner) {
+    return {
+        id: node.id,
+        title: node.title,
+        shortDescription: node.shortDescription ?? "",
+        url: node.url,
+        openItemCount: node.items?.totalCount ?? 0,
+        owner,
+    };
+}
+// ── 2.3: Project detail (status fields + linked repos) ───────────────────────
+export async function getProjectDetail(client, projectId) {
+    const data = await graphql(client, PROJECT_DETAIL_QUERY, { projectId });
+    const project = data.node;
+    if (!project || project.__typename !== "ProjectV2") {
+        throw new GitHubApiError(`Project not found: ${projectId}`);
+    }
+    const statusFields = [];
+    for (const field of project.fields?.nodes ?? []) {
+        if (!field || field.__typename !== "ProjectV2SingleSelectField")
+            continue;
+        statusFields.push({
+            id: field.id,
+            name: field.name,
+            options: (field.options ?? []).map((opt) => ({
+                id: opt.id,
+                name: opt.name,
+                description: opt.description ?? null,
+                color: opt.color ?? null,
+            })),
+        });
+    }
+    const repoMap = new Map();
+    let cursor = null;
+    let hasMore = true;
+    // Use initial page from the detail query
+    for (const item of project.items?.nodes ?? []) {
+        const repo = item?.content?.repository;
+        if (!repo)
+            continue;
+        const key = `${repo.owner.login}/${repo.name}`;
+        if (!repoMap.has(key)) {
+            repoMap.set(key, {
+                owner: repo.owner.login,
+                name: repo.name,
+                url: repo.url,
+                cloneUrl: repo.url.endsWith(".git") ? repo.url : `${repo.url}.git`,
+            });
+        }
+    }
+    hasMore = project.items?.pageInfo?.hasNextPage ?? false;
+    cursor = project.items?.pageInfo?.endCursor ?? null;
+    // Paginate remaining items for linked repos
+    while (hasMore && cursor) {
+        const pageData = await graphql(client, PROJECT_ITEMS_PAGE_QUERY, { projectId, cursor });
+        const items = pageData.node?.items;
+        if (!items)
+            break;
+        for (const item of items.nodes ?? []) {
+            const repo = item?.content?.repository;
+            if (!repo)
+                continue;
+            const key = `${repo.owner.login}/${repo.name}`;
+            if (!repoMap.has(key)) {
+                repoMap.set(key, {
+                    owner: repo.owner.login,
+                    name: repo.name,
+                    url: repo.url,
+                    cloneUrl: repo.url.endsWith(".git") ? repo.url : `${repo.url}.git`,
+                });
+            }
+        }
+        hasMore = items.pageInfo?.hasNextPage ?? false;
+        cursor = items.pageInfo?.endCursor ?? null;
+    }
+    return {
+        id: project.id,
+        title: project.title,
+        url: project.url,
+        statusFields,
+        linkedRepositories: [...repoMap.values()],
+    };
+}
+// ── GraphQL helpers ──────────────────────────────────────────────────────────
+async function graphql(client, query, variables) {
+    const response = await client.fetchImpl(client.apiUrl, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${client.token}`,
+        },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new GitHubApiError(`GitHub GraphQL request failed: ${response.status} ${response.statusText}. ${text}`, response.status);
+    }
+    const payload = (await response.json());
+    if (payload.errors?.length) {
+        throw new GitHubApiError(`GraphQL errors: ${payload.errors.map((e) => e.message).join("; ")}`);
+    }
+    if (!payload.data) {
+        throw new GitHubApiError("GraphQL response missing data.");
+    }
+    return payload.data;
+}
+// ── GraphQL queries ──────────────────────────────────────────────────────────
+const VIEWER_PROJECTS_QUERY = `
+  query ViewerProjects {
+    viewer {
+      login
+      projectsV2(first: 50) {
+        nodes {
+          id
+          title
+          shortDescription
+          url
+          items { totalCount }
+        }
+      }
+      organizations(first: 20) {
+        nodes {
+          login
+          projectsV2(first: 50) {
+            nodes {
+              id
+              title
+              shortDescription
+              url
+              items { totalCount }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+const PROJECT_DETAIL_QUERY = `
+  query ProjectDetail($projectId: ID!) {
+    node(id: $projectId) {
+      __typename
+      ... on ProjectV2 {
+        id
+        title
+        url
+        fields(first: 50) {
+          nodes {
+            __typename
+            ... on ProjectV2SingleSelectField {
+              id
+              name
+              options {
+                id
+                name
+                description
+                color
+              }
+            }
+          }
+        }
+        items(first: 100) {
+          nodes {
+            content {
+              __typename
+              ... on Issue {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+              ... on PullRequest {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+const PROJECT_ITEMS_PAGE_QUERY = `
+  query ProjectItemsPage($projectId: ID!, $cursor: String) {
+    node(id: $projectId) {
+      ... on ProjectV2 {
+        items(first: 100, after: $cursor) {
+          nodes {
+            content {
+              __typename
+              ... on Issue {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+              ... on PullRequest {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+export type GlobalOptions = {
+    configDir: string;
+    verbose: boolean;
+    json: boolean;
+    noColor: boolean;
+};
+export declare function parseGlobalOptions(argv: string[]): {
+    options: GlobalOptions;
+    command: string;
+    args: string[];
+};
+export type CommandHandler = (args: string[], options: GlobalOptions) => Promise<void>;
+export declare function runCli(argv: string[]): Promise<void>;

package/dist/index.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { pathToFileURL } from "node:url";
+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 };
+}
+const COMMANDS = {
+    init: () => import("./commands/init.js"),
+    start: () => import("./commands/start.js"),
+    stop: () => import("./commands/stop.js"),
+    status: () => import("./commands/status.js"),
+    run: () => import("./commands/run.js"),
+    recover: () => import("./commands/recover.js"),
+    logs: () => import("./commands/logs.js"),
+    project: () => import("./commands/project.js"),
+    repo: () => import("./commands/repo.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);
+    if (options.noColor) {
+        process.env.NO_COLOR = "1";
+    }
+    if (command === "--help" || command === "-h") {
+        const helpModule = await COMMANDS.help();
+        await helpModule.default(args, options);
+        return;
+    }
+    if (command === "--version" || command === "-V") {
+        const versionModule = await COMMANDS.version();
+        await versionModule.default(args, options);
+        return;
+    }
+    const loader = COMMANDS[command];
+    if (!loader) {
+        process.stderr.write(`Unknown command: ${command}\nRun 'gh-symphony help' for usage.\n`);
+        process.exitCode = 2;
+        return;
+    }
+    const module = await loader();
+    await module.default(args, options);
+}
+async function main() {
+    await runCli(process.argv.slice(2));
+}
+if (process.argv[1] &&
+    import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : "Unknown error"}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/mapping/smart-defaults.d.ts

@@ -0,0 +1,33 @@
+import type { WorkflowLifecycleConfig } from "@hojinzs/gh-symphony-core";
+import type { ColumnRole, HumanReviewMode } from "../config.js";
+export type ColumnMapping = {
+    columnName: string;
+    role: ColumnRole | null;
+    confidence: "high" | "low";
+};
+export declare function inferColumnRole(columnName: string): ColumnMapping;
+export declare function inferAllColumnRoles(columnNames: string[]): ColumnMapping[];
+export type PhaseMapping = {
+    planningStates: string[];
+    humanReviewStates: string[];
+    implementationStates: string[];
+    awaitingMergeStates: string[];
+    completedStates: string[];
+};
+/**
+ * Map column roles to Symphony execution phases based on the human-review mode.
+ *
+ * Modes:
+ * - plan-and-pr: Human reviews both plans and PRs (full review pipeline)
+ * - plan-only: Human reviews plans, PRs auto-merge
+ * - pr-only: No plan review, human reviews PRs
+ * - none: No human review at all (full auto)
+ */
+export declare function buildPhaseMapping(roles: Record<string, ColumnRole>, mode: HumanReviewMode): PhaseMapping;
+export declare function toWorkflowLifecycleConfig(stateFieldName: string, roles: Record<string, ColumnRole>, mode: HumanReviewMode): WorkflowLifecycleConfig;
+export type MappingValidationResult = {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+export declare function validateMapping(roles: Record<string, ColumnRole>): MappingValidationResult;

package/dist/mapping/smart-defaults.js

@@ -0,0 +1,159 @@
+// ── 3.1: Smart defaults pattern matching ─────────────────────────────────────
+const ROLE_PATTERNS = [
+    {
+        role: "trigger",
+        pattern: /^(todo|to.do|to-do|ready|queued|open|new|triage)$/i,
+    },
+    {
+        role: "working",
+        pattern: /^(in.progress|working|active|doing|in.development|developing|wip)$/i,
+    },
+    {
+        role: "human-review",
+        pattern: /^(review|in.review|pr.review|needs.review|plan.review|awaiting.review|code.review)$/i,
+    },
+    {
+        role: "done",
+        pattern: /^(done|completed?|closed|merged|shipped|resolved|finished)$/i,
+    },
+    {
+        role: "ignored",
+        pattern: /^(icebox|someday|later|blocked|on.hold|paused|won.?t.do|cancelled|deferred|draft|backlog)$/i,
+    },
+];
+export function inferColumnRole(columnName) {
+    const normalized = columnName.trim();
+    for (const { role, pattern } of ROLE_PATTERNS) {
+        if (pattern.test(normalized)) {
+            return { columnName: normalized, role, confidence: "high" };
+        }
+    }
+    return { columnName: normalized, role: null, confidence: "low" };
+}
+export function inferAllColumnRoles(columnNames) {
+    return columnNames.map(inferColumnRole);
+}
+/**
+ * Map column roles to Symphony execution phases based on the human-review mode.
+ *
+ * Modes:
+ * - plan-and-pr: Human reviews both plans and PRs (full review pipeline)
+ * - plan-only: Human reviews plans, PRs auto-merge
+ * - pr-only: No plan review, human reviews PRs
+ * - none: No human review at all (full auto)
+ */
+export function buildPhaseMapping(roles, mode) {
+    const planningStates = [];
+    const humanReviewStates = [];
+    const implementationStates = [];
+    const awaitingMergeStates = [];
+    const completedStates = [];
+    for (const [columnName, role] of Object.entries(roles)) {
+        switch (role) {
+            case "trigger":
+                planningStates.push(columnName);
+                break;
+            case "working":
+                implementationStates.push(columnName);
+                break;
+            case "human-review":
+                switch (mode) {
+                    case "plan-and-pr":
+                        humanReviewStates.push(columnName);
+                        break;
+                    case "plan-only":
+                        humanReviewStates.push(columnName);
+                        break;
+                    case "pr-only":
+                        awaitingMergeStates.push(columnName);
+                        break;
+                    case "none":
+                        // In "none" mode, review columns are treated as implementation
+                        implementationStates.push(columnName);
+                        break;
+                }
+                break;
+            case "done":
+                completedStates.push(columnName);
+                break;
+            case "ignored":
+                // Ignored columns don't map to any phase
+                break;
+        }
+    }
+    return {
+        planningStates,
+        humanReviewStates,
+        implementationStates,
+        awaitingMergeStates,
+        completedStates,
+    };
+}
+// ── 3.3: Mapping → WorkflowLifecycleConfig conversion ───────────────────────
+export function toWorkflowLifecycleConfig(stateFieldName, roles, mode) {
+    const phases = buildPhaseMapping(roles, mode);
+    // Transition targets: where issues move when a phase completes
+    const planningCompleteState = resolveTransitionTarget(phases, "planning", mode);
+    const implementationCompleteState = resolveTransitionTarget(phases, "implementation", mode);
+    const mergeCompleteState = phases.completedStates[0] ?? phases.awaitingMergeStates[0] ?? "Done";
+    return {
+        stateFieldName,
+        planningStates: phases.planningStates,
+        humanReviewStates: phases.humanReviewStates,
+        implementationStates: phases.implementationStates,
+        awaitingMergeStates: phases.awaitingMergeStates,
+        completedStates: phases.completedStates,
+        planningCompleteState,
+        implementationCompleteState,
+        mergeCompleteState,
+    };
+}
+function resolveTransitionTarget(phases, fromPhase, mode) {
+    if (fromPhase === "planning") {
+        // After planning: go to human-review (if exists) or implementation
+        if ((mode === "plan-and-pr" || mode === "plan-only") &&
+            phases.humanReviewStates.length > 0) {
+            return phases.humanReviewStates[0];
+        }
+        return phases.implementationStates[0] ?? "In Progress";
+    }
+    // After implementation: go to awaiting-merge (if exists) or completed
+    if ((mode === "plan-and-pr" || mode === "pr-only") &&
+        phases.awaitingMergeStates.length > 0) {
+        return phases.awaitingMergeStates[0];
+    }
+    return phases.completedStates[0] ?? "Done";
+}
+export function validateMapping(roles) {
+    const errors = [];
+    const warnings = [];
+    const roleEntries = Object.entries(roles);
+    const triggerColumns = roleEntries.filter(([, r]) => r === "trigger");
+    const workingColumns = roleEntries.filter(([, r]) => r === "working");
+    const doneColumns = roleEntries.filter(([, r]) => r === "done");
+    const reviewColumns = roleEntries.filter(([, r]) => r === "human-review");
+    // Required roles
+    if (triggerColumns.length === 0) {
+        errors.push("Missing required role: 'trigger' — at least one column must trigger work.");
+    }
+    if (workingColumns.length === 0) {
+        errors.push("Missing required role: 'working' — at least one column must represent active work.");
+    }
+    if (doneColumns.length === 0) {
+        errors.push("Missing required role: 'done' — at least one column must represent completion.");
+    }
+    // Warnings for unusual setups
+    if (triggerColumns.length > 1) {
+        warnings.push(`Multiple trigger columns: ${triggerColumns.map(([n]) => n).join(", ")}. ` +
+            "All will be treated as planning states.");
+    }
+    if (doneColumns.length > 1) {
+        warnings.push(`Multiple done columns: ${doneColumns.map(([n]) => n).join(", ")}. ` +
+            "All will be treated as completed states.");
+    }
+    if (reviewColumns.length > 2) {
+        warnings.push(`${reviewColumns.length} review columns detected. ` +
+            "Consider simplifying to one or two review stages.");
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/orchestrator-runtime.d.ts

@@ -0,0 +1,5 @@
+import { type CliWorkspaceConfig } from "./config.js";
+export declare function resolveRuntimeRoot(configDir: string): string;
+export declare function resolveWorkspaceConfig(configDir: string, requestedWorkspaceId?: string): Promise<CliWorkspaceConfig | null>;
+export declare function orchestratorWorkspaceConfigPath(runtimeRoot: string, workspaceId: string): string;
+export declare function syncWorkspaceToRuntime(configDir: string, workspaceConfig: CliWorkspaceConfig): Promise<string>;

package/dist/orchestrator-runtime.js

@@ -0,0 +1,26 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { loadGlobalConfig, loadWorkspaceConfig, } from "./config.js";
+export function resolveRuntimeRoot(configDir) {
+    return resolve(configDir);
+}
+export async function resolveWorkspaceConfig(configDir, requestedWorkspaceId) {
+    if (requestedWorkspaceId) {
+        return loadWorkspaceConfig(configDir, requestedWorkspaceId);
+    }
+    const global = await loadGlobalConfig(configDir);
+    if (!global?.activeWorkspace) {
+        return null;
+    }
+    return loadWorkspaceConfig(configDir, global.activeWorkspace);
+}
+export function orchestratorWorkspaceConfigPath(runtimeRoot, workspaceId) {
+    return join(runtimeRoot, "orchestrator", "workspaces", workspaceId, "config.json");
+}
+export async function syncWorkspaceToRuntime(configDir, workspaceConfig) {
+    const runtimeRoot = resolveRuntimeRoot(configDir);
+    const configPath = orchestratorWorkspaceConfigPath(runtimeRoot, workspaceConfig.workspaceId);
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify(workspaceConfig, null, 2) + "\n");
+    return runtimeRoot;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@gh-symphony/cli",
+  "version": "0.0.1",
+  "license": "MIT",
+  "author": "hojinzs",
+  "description": "Interactive CLI for GitHub Symphony orchestration",
+  "type": "module",
+  "bin": {
+    "gh-symphony": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hojinzs/github-symphony.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/hojinzs/github-symphony#readme",
+  "bugs": {
+    "url": "https://github.com/hojinzs/github-symphony/issues"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "@gh-symphony/core": "0.0.1",
+    "@gh-symphony/orchestrator": "0.0.1",
+    "@gh-symphony/tracker-github": "0.0.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "eslint src --ext .ts",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}