@gh-symphony/cli 0.0.18 → 0.0.20

package/dist/setup-VWB7RZUQ.js

@@ -0,0 +1,431 @@
+#!/usr/bin/env node
+import {
+  promptProjectRegistrationOptions,
+  renderProjectRegistrationSummary
+} from "./chunk-3AWF54PI.js";
+import {
+  abortIfCancelled,
+  buildAutomaticStateMappings,
+  generateProjectId,
+  planWorkflowArtifacts,
+  promptStateMappings,
+  renderDryRunPreview,
+  resolveStatusField,
+  validateStateMapping,
+  writeConfig,
+  writeEcosystem,
+  writeWorkflowPlan
+} from "./chunk-RN2PACNV.js";
+import "./chunk-EKKT5USP.js";
+import "./chunk-HZVDTAPS.js";
+import "./chunk-M3IFVLQS.js";
+import {
+  GhAuthError,
+  GitHubScopeError,
+  checkRequiredScopes,
+  createClient,
+  ensureGhAuth,
+  getGhToken,
+  getProjectDetail,
+  listUserProjects,
+  validateToken
+} from "./chunk-TILHWBP6.js";
+import "./chunk-XN5ABWZ6.js";
+import "./chunk-MVRF7BES.js";
+import "./chunk-5NV3LSAJ.js";
+import "./chunk-Y6TYJMNT.js";
+import "./chunk-C7G7RJ4G.js";
+import "./chunk-ROGRTUFI.js";
+
+// src/commands/setup.ts
+import * as p from "@clack/prompts";
+import { join, resolve } from "path";
+var KNOWN_REQUIRED_SCOPES = ["repo", "read:org", "project"];
+function parseSetupFlags(args) {
+  const flags = {
+    nonInteractive: false,
+    skipSkills: false,
+    skipContext: 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;
+      case "--output":
+        flags.output = next;
+        i += 1;
+        break;
+      case "--skip-skills":
+        flags.skipSkills = true;
+        break;
+      case "--skip-context":
+        flags.skipContext = true;
+        break;
+    }
+  }
+  return flags;
+}
+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}
+
+Then re-run: ${retryCommand}`,
+    "Fix missing scope"
+  );
+}
+async function resolveProjectDetail(client, projectArg) {
+  const projects = await listUserProjects(client);
+  if (projects.length === 0) {
+    throw new Error(
+      "No GitHub Projects found. Create a project first and re-run setup."
+    );
+  }
+  if (projectArg) {
+    const match = projects.find(
+      (project) => project.id === projectArg || project.url === projectArg
+    );
+    if (!match) {
+      throw new Error(`Project not found: ${projectArg}`);
+    }
+    return getProjectDetail(client, match.id);
+  }
+  if (projects.length === 1) {
+    return getProjectDetail(client, projects[0].id);
+  }
+  throw new Error("Error: --project is required when multiple projects exist.");
+}
+async function selectProjectSummary(client) {
+  const projects = await listUserProjects(client);
+  if (projects.length === 0) {
+    throw new Error(
+      "No GitHub Projects found. Create a project at https://github.com/orgs/YOUR_ORG/projects and re-run."
+    );
+  }
+  const selectedProjectId = await abortIfCancelled(
+    p.select({
+      message: "Step 1/3 \u2014 Select a GitHub Project board:",
+      options: projects.map((project) => ({
+        value: project.id,
+        label: `${project.owner.login}/${project.title}`,
+        hint: `${project.openItemCount} items`
+      })),
+      maxItems: 15
+    })
+  );
+  return projects.find((project) => project.id === selectedProjectId);
+}
+function formatRepoSummary(projectDetail, selectedRepos) {
+  return selectedRepos.length === projectDetail.linkedRepositories.length ? `${selectedRepos.map((repo) => `${repo.owner}/${repo.name}`).join(", ")}  (all ${selectedRepos.length} linked)` : `${selectedRepos.map((repo) => `${repo.owner}/${repo.name}`).join(", ")}  (${selectedRepos.length} of ${projectDetail.linkedRepositories.length} linked)`;
+}
+function printNonInteractiveSummary(input) {
+  process.stdout.write(
+    [
+      `GitHub Project   ${input.githubProjectTitle}  (${input.githubProjectId})`,
+      `Managed project  ${input.projectId}`,
+      `WORKFLOW.md      ${input.workflowPath}`,
+      `Workspace root   ${input.workspaceDir}`,
+      "Ready. Run 'gh-symphony start' to begin orchestration."
+    ].map((line) => `  ${line}`).join("\n") + "\n"
+  );
+}
+var handler = async (args, options) => {
+  const flags = parseSetupFlags(args);
+  if (flags.nonInteractive) {
+    await runNonInteractive(flags, options);
+    return;
+  }
+  await runInteractive(flags, options);
+};
+var setup_default = handler;
+async function runNonInteractive(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(", ")}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  let projectDetail;
+  try {
+    projectDetail = await resolveProjectDetail(client, flags.project);
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : "Unknown error"}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const statusField = resolveStatusField(projectDetail);
+  if (!statusField) {
+    process.stderr.write("Error: No status field found on the project.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const mappings = buildAutomaticStateMappings(statusField);
+  const workflowValidation = validateStateMapping(mappings);
+  if (!workflowValidation.valid) {
+    process.stderr.write(
+      `Error: Cannot auto-map columns. ${workflowValidation.errors.join("; ")}
+Run setup without --non-interactive for manual mapping.
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const workflowPath = resolve(flags.output ?? "WORKFLOW.md");
+  const { workflowPlan } = await planWorkflowArtifacts({
+    cwd: process.cwd(),
+    outputPath: workflowPath,
+    projectDetail,
+    statusField,
+    mappings,
+    runtime: "codex",
+    skipSkills: flags.skipSkills,
+    skipContext: flags.skipContext
+  });
+  await writeWorkflowPlan(workflowPlan);
+  await writeEcosystem({
+    cwd: process.cwd(),
+    projectDetail,
+    statusField,
+    runtime: "codex",
+    skipSkills: flags.skipSkills,
+    skipContext: flags.skipContext
+  });
+  const projectId = generateProjectId(projectDetail.title, projectDetail.id);
+  const workspaceDir = flags.workspaceDir ?? join(options.configDir, "workspaces");
+  await writeConfig(options.configDir, {
+    projectId,
+    project: projectDetail,
+    repos: projectDetail.linkedRepositories,
+    workspaceDir,
+    assignedOnly: flags.assignedOnly
+  });
+  if (options.json) {
+    process.stdout.write(
+      JSON.stringify({
+        status: "created",
+        output: workflowPath,
+        projectId,
+        githubProjectId: projectDetail.id
+      }) + "\n"
+    );
+    return;
+  }
+  printNonInteractiveSummary({
+    projectId,
+    githubProjectTitle: projectDetail.title,
+    githubProjectId: projectDetail.id,
+    workflowPath,
+    workspaceDir
+  });
+}
+async function runInteractive(flags, options) {
+  p.intro("gh-symphony \u2014 One-command Setup");
+  const authSpinner = p.spinner();
+  authSpinner.start("Checking gh CLI authentication...");
+  let login;
+  let client;
+  try {
+    const auth = ensureGhAuth();
+    login = auth.login;
+    client = createClient(auth.token);
+    authSpinner.stop(`Authenticated as ${login}`);
+  } catch (error) {
+    authSpinner.stop("Authentication failed.");
+    if (error instanceof GhAuthError) {
+      if (error.code === "not_installed") {
+        p.log.error("gh CLI\uAC00 \uC124\uCE58\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. https://cli.github.com \uC5D0\uC11C \uC124\uCE58\uD558\uC138\uC694.");
+      } else if (error.code === "not_authenticated") {
+        p.log.error("gh auth login --scopes repo,read:org,project \uB97C \uC2E4\uD589\uD558\uC138\uC694.");
+      } else if (error.code === "missing_scopes") {
+        p.log.error("gh auth refresh --scopes repo,read:org,project \uB97C \uC2E4\uD589\uD558\uC138\uC694.");
+      } else {
+        p.log.error(error.message);
+      }
+    } else {
+      p.log.error(error instanceof Error ? error.message : "Unknown error");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const projectsSpinner = p.spinner();
+  projectsSpinner.start("Loading GitHub Project boards...");
+  let selectedProject;
+  try {
+    selectedProject = await selectProjectSummary(client);
+    projectsSpinner.stop(`Selected: ${selectedProject.title}`);
+  } catch (error) {
+    projectsSpinner.stop("Failed to load projects.");
+    if (error instanceof GitHubScopeError) {
+      displayScopeError(error, "gh-symphony setup");
+    } else {
+      p.log.error(error instanceof Error ? error.message : "Unknown error");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const detailSpinner = p.spinner();
+  detailSpinner.start("Loading project details...");
+  let projectDetail;
+  try {
+    projectDetail = await getProjectDetail(client, selectedProject.id);
+    detailSpinner.stop(`Loaded: ${projectDetail.title}`);
+  } catch (error) {
+    detailSpinner.stop("Failed to load project details.");
+    p.log.error(error instanceof Error ? error.message : "Unknown error");
+    process.exitCode = 1;
+    return;
+  }
+  if (projectDetail.linkedRepositories.length === 0) {
+    p.log.error(
+      "No linked repositories found in this project. Add issues from repositories to the project first."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const statusField = resolveStatusField(projectDetail);
+  if (!statusField) {
+    p.log.error(
+      "No status field found on the project. The project needs a single-select 'Status' field."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const mappings = await promptStateMappings(statusField, {
+    stepLabel: "Step 2/3"
+  });
+  const workflowValidation = validateStateMapping(mappings);
+  if (!workflowValidation.valid) {
+    p.log.error("Mapping validation failed:");
+    for (const error of workflowValidation.errors) {
+      p.log.error(`  \u2022 ${error}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  for (const warning of workflowValidation.warnings) {
+    p.log.warn(`  \u26A0 ${warning}`);
+  }
+  const {
+    assignedOnly: promptAssignedOnly,
+    selectedRepos,
+    workspaceDir
+  } = await promptProjectRegistrationOptions({
+    projectDetail,
+    defaultWorkspaceDir: flags.workspaceDir ?? join(options.configDir, "workspaces"),
+    assignedOnlyMessage: "Step 3/3 \u2014 Only process issues assigned to the authenticated GitHub user?",
+    assignedOnlyInitialValue: flags.assignedOnly
+  });
+  const assignedOnly = flags.assignedOnly || promptAssignedOnly;
+  const workflowPath = resolve(flags.output ?? "WORKFLOW.md");
+  const { workflowPlan, ecosystemPlan } = await planWorkflowArtifacts({
+    cwd: process.cwd(),
+    outputPath: workflowPath,
+    projectDetail,
+    statusField,
+    mappings,
+    runtime: "codex",
+    skipSkills: flags.skipSkills,
+    skipContext: flags.skipContext
+  });
+  const projectId = generateProjectId(projectDetail.title, projectDetail.id);
+  p.note(
+    [
+      renderProjectRegistrationSummary({
+        login,
+        projectTitle: projectDetail.title,
+        repoSummary: formatRepoSummary(projectDetail, selectedRepos),
+        assignedOnly,
+        workspaceDir
+      }),
+      "",
+      renderDryRunPreview(workflowPath, workflowPlan, ecosystemPlan).trimEnd()
+    ].join("\n"),
+    "Final summary"
+  );
+  const confirmed = await abortIfCancelled(
+    p.confirm({ message: "Write files and register this managed project?" })
+  );
+  if (!confirmed) {
+    p.cancel("Setup cancelled.");
+    process.exitCode = 130;
+    return;
+  }
+  const writeSpinner = p.spinner();
+  writeSpinner.start("Writing setup files...");
+  try {
+    await writeWorkflowPlan(workflowPlan);
+    await writeEcosystem({
+      cwd: process.cwd(),
+      projectDetail,
+      statusField,
+      runtime: "codex",
+      skipSkills: flags.skipSkills,
+      skipContext: flags.skipContext
+    });
+    await writeConfig(options.configDir, {
+      projectId,
+      project: projectDetail,
+      repos: selectedRepos,
+      workspaceDir,
+      assignedOnly
+    });
+    writeSpinner.stop("Setup saved.");
+  } catch (error) {
+    writeSpinner.stop("Setup failed.");
+    p.log.error(error instanceof Error ? error.message : "Unknown error");
+    process.exitCode = 1;
+    return;
+  }
+  p.outro(
+    `Project "${projectId}" is ready.
+  Run 'gh-symphony start' to begin orchestration.`
+  );
+}
+export {
+  setup_default as default
+};

package/dist/{start-5JGGJIMC.js → start-ENFLZUI6.js}

@@ -2,11 +2,11 @@
 import {
   shutdownForegroundOrchestrator,
   start_default
-} from "./chunk-ZYYY55WB.js";
-import "./chunk-7UBUBSMH.js";
+} from "./chunk-EKKT5USP.js";
+import "./chunk-HZVDTAPS.js";
+import "./chunk-M3IFVLQS.js";
+import "./chunk-TILHWBP6.js";
 import "./chunk-MVRF7BES.js";
-import "./chunk-LZE6YUSB.js";
-import "./chunk-OL73UN2X.js";
 import "./chunk-5NV3LSAJ.js";
 import "./chunk-C7G7RJ4G.js";
 import "./chunk-ROGRTUFI.js";

package/dist/upgrade-3YNF3VKY.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+// src/commands/upgrade.ts
+import { readFileSync } from "fs";
+import { execFile as execFileCallback, spawn } from "child_process";
+var PACKAGE_NAME = "@gh-symphony/cli";
+function execFileAsync(file, args, execFileImpl = execFileCallback) {
+  return new Promise((resolve, reject) => {
+    execFileImpl(file, args, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+function resolveCurrentCliVersion() {
+  if ("0.0.20".length > 0) {
+    return "0.0.20";
+  }
+  const pkg = JSON.parse(
+    readFileSync(new URL("../../package.json", import.meta.url), "utf8")
+  );
+  if (typeof pkg.version === "string" && pkg.version.length > 0) {
+    return pkg.version;
+  }
+  throw new Error("Unable to determine the current CLI version.");
+}
+function resolvePackageManagerExecutable(command, platform = process.platform) {
+  return platform === "win32" ? `${command}.cmd` : command;
+}
+async function fetchLatestCliVersion(deps) {
+  const runExecFile = deps?.execFileImpl ?? execFileAsync;
+  const { stdout } = await runExecFile(
+    resolvePackageManagerExecutable("npm", deps?.platform),
+    [
+      "view",
+      PACKAGE_NAME,
+      "dist-tags.latest",
+      "--json"
+    ]
+  );
+  const raw = stdout.trim();
+  if (raw.length === 0) {
+    throw new Error("Failed to resolve the latest CLI version from npm.");
+  }
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "string" || parsed.length === 0) {
+    throw new Error("npm returned an invalid latest version response.");
+  }
+  return parsed;
+}
+async function detectGlobalPackageManager(deps) {
+  const runExecFile = deps?.execFileImpl ?? execFileAsync;
+  try {
+    const { stdout } = await runExecFile(
+      resolvePackageManagerExecutable("npm", deps?.platform),
+      ["prefix", "-g"]
+    );
+    return stdout.toLowerCase().includes("pnpm") ? "pnpm" : "npm";
+  } catch {
+    return "npm";
+  }
+}
+function packageManagerCommand(manager, platform) {
+  if (manager === "pnpm") {
+    return [
+      resolvePackageManagerExecutable("pnpm", platform),
+      "add",
+      "-g",
+      `${PACKAGE_NAME}@latest`
+    ];
+  }
+  return [
+    resolvePackageManagerExecutable("npm", platform),
+    "install",
+    "-g",
+    `${PACKAGE_NAME}@latest`
+  ];
+}
+function pipeInstallOutput(child) {
+  child.stdout?.on("data", (chunk) => {
+    process.stderr.write(chunk);
+  });
+  child.stderr?.on("data", (chunk) => {
+    process.stderr.write(chunk);
+  });
+}
+async function runUpgradeInstall(manager, deps, jsonOutput = false) {
+  const spawnCommand = deps?.spawnImpl ?? spawn;
+  const [command, ...args] = packageManagerCommand(manager, deps?.platform);
+  await new Promise((resolve, reject) => {
+    const child = jsonOutput ? spawnCommand(command, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    }) : spawnCommand(command, args, {
+      stdio: "inherit"
+    });
+    if (jsonOutput) {
+      pipeInstallOutput(child);
+    }
+    child.once("error", reject);
+    child.once("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(
+        new Error(`${command} exited with code ${code ?? "unknown"}.`)
+      );
+    });
+  });
+}
+async function runUpgradeCommand(options, deps) {
+  const latestVersion = await fetchLatestCliVersion(deps);
+  const currentVersion = deps?.currentVersion ?? resolveCurrentCliVersion();
+  if (currentVersion === latestVersion) {
+    if (options.json) {
+      process.stdout.write(
+        JSON.stringify({
+          status: "up_to_date",
+          currentVersion,
+          latestVersion,
+          packageManager: null
+        }) + "\n"
+      );
+    } else {
+      process.stdout.write(`Already up to date (v${currentVersion})
+`);
+    }
+    return;
+  }
+  const manager = await detectGlobalPackageManager(deps);
+  if (!options.json) {
+    process.stdout.write(
+      `Upgrading ${PACKAGE_NAME} from v${currentVersion} to v${latestVersion} using ${manager}...
+`
+    );
+  }
+  await runUpgradeInstall(manager, deps, options.json);
+  if (options.json) {
+    process.stdout.write(
+      JSON.stringify({
+        status: "upgraded",
+        previousVersion: currentVersion,
+        latestVersion,
+        packageManager: manager
+      }) + "\n"
+    );
+  } else {
+    process.stdout.write(`Upgrade complete (v${latestVersion})
+`);
+  }
+}
+var handler = async (_args, options) => {
+  await runUpgradeCommand(options);
+};
+var upgrade_default = handler;
+export {
+  upgrade_default as default,
+  detectGlobalPackageManager,
+  fetchLatestCliVersion,
+  runUpgradeCommand,
+  runUpgradeInstall
+};

package/dist/{version-N7YXKG6V.js → version-NUBTTOG7.js}

@@ -2,7 +2,7 @@
 
 // src/commands/version.ts
 var handler = async (_args, options) => {
-  const version = "0.0.18";
+  const version = "0.0.20";
   if (options.json) {
     process.stdout.write(JSON.stringify({ version }) + "\n");
   } else {