@gh-symphony/cli 0.0.13 → 0.0.15

package/dist/project-3ELXQ35D.js

@@ -0,0 +1,678 @@
+#!/usr/bin/env node
+import {
+  GitHubScopeError,
+  abortIfCancelled,
+  checkRequiredScopes,
+  createClient,
+  generateProjectId,
+  getProjectDetail,
+  listUserProjects,
+  validateToken,
+  writeConfig
+} from "./chunk-IWR4UQEJ.js";
+import {
+  start_default
+} from "./chunk-M7OSMUTN.js";
+import {
+  GhAuthError,
+  ensureGhAuth,
+  getGhToken
+} from "./chunk-JO3AXHQI.js";
+import {
+  stop_default
+} from "./chunk-76QPITKI.js";
+import {
+  status_default
+} from "./chunk-6HBZC3BE.js";
+import {
+  stripAnsi
+} from "./chunk-MVRF7BES.js";
+import "./chunk-RNWX7DQU.js";
+import {
+  resolveRuntimeRoot
+} from "./chunk-5NV3LSAJ.js";
+import "./chunk-TH5QPO3Y.js";
+import {
+  daemonPidPath,
+  httpStatusPath,
+  loadGlobalConfig,
+  loadProjectConfig,
+  projectConfigDir,
+  saveGlobalConfig
+} from "./chunk-ROGRTUFI.js";
+
+// src/commands/project.ts
+import * as p from "@clack/prompts";
+import { execFile as execFileCallback } from "child_process";
+import { promisify } from "util";
+import { readFile } from "fs/promises";
+import { join } from "path";
+var execFile = promisify(execFileCallback);
+var 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}
+
+Then 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;
+}
+var handler = async (args, options) => {
+  const [subcommand, ...rest] = args;
+  switch (subcommand) {
+    case "add":
+      await projectAdd(rest, options);
+      return;
+    case "list":
+      await projectList(options);
+      return;
+    case "remove":
+      await projectRemove(rest, options);
+      return;
+    case "start":
+      await start_default(rest, options);
+      return;
+    case "stop":
+      await stop_default(rest, options);
+      return;
+    case "switch":
+      await projectSwitch(options);
+      return;
+    case "status":
+      await status_default(rest, options);
+      return;
+    default:
+      process.stdout.write(
+        "Usage: gh-symphony project <add|list|remove|start|stop|switch|status>\n"
+      );
+  }
+};
+var project_default = handler;
+function relativeTimeFromNow(isoString, now = /* @__PURE__ */ 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 / 1e3);
+  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 / 86400);
+  const hours = Math.floor(seconds % 86400 / 3600);
+  const minutes = Math.floor(seconds % 3600 / 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] * 3600;
+    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 * 86400;
+  }
+  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, "projects", projectId, "status.json"),
+      "utf8"
+    );
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function fetchProjectSnapshot(configDir, projectId) {
+  return readPersistedSnapshot(configDir, projectId);
+}
+async function readHttpEndpoint(configDir, projectId) {
+  try {
+    const content = await readFile(httpStatusPath(configDir, projectId), "utf8");
+    const state = JSON.parse(content);
+    return typeof state.endpoint === "string" && state.endpoint.length > 0 ? state.endpoint : null;
+  } catch {
+    return null;
+  }
+}
+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 >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071;
+}
+function isWideCodePoint(codePoint) {
+  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141);
+}
+function stringDisplayWidth(value) {
+  const visible = stripAnsi(value);
+  let width = 0;
+  for (const char of visible) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === void 0) {
+      continue;
+    }
+    if (codePoint === 0 || codePoint < 32 || codePoint >= 127 && codePoint < 160 || 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 snapshot = running ? await fetchProjectSnapshot(configDir, projectId) : null;
+      return {
+        id: projectId,
+        name: defaultProjectName(config, projectId),
+        status: running ? "running" : "stopped",
+        health: snapshot?.health ?? "-",
+        activeRuns: snapshot?.summary.activeRuns ?? null,
+        lastTick: snapshot?.lastTickAt ? relativeTimeFromNow(snapshot.lastTickAt) : "-",
+        uptime: pid !== null && running ? await readProcessUptime(pid) : "-",
+        endpoint: running ? await readHttpEndpoint(configDir, projectId) : null,
+        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) => "\u2500".repeat(width + 2)).join(middle) + right;
+  return [
+    border("\u250C", "\u252C", "\u2510"),
+    formatRow("\u2502", "\u2502", "\u2502", headers),
+    border("\u251C", "\u253C", "\u2524"),
+    ...rows.map((row) => formatRow("\u2502", "\u2502", "\u2502", row)),
+    border("\u2514", "\u2534", "\u2518")
+  ].join("\n");
+}
+async function projectAdd(args, options) {
+  const flags = parseProjectAddFlags(args);
+  if (flags.nonInteractive) {
+    await projectAddNonInteractive(flags, options);
+    return;
+  }
+  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(", ")}
+`
+    );
+    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}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    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;
+  }
+  const projectId = generateProjectId(project.title, project.id);
+  const workspaceDir = flags.workspaceDir ?? join(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}
+`);
+    process.stdout.write(`Run 'gh-symphony start' to begin orchestration.
+`);
+  }
+}
+async function projectAddInteractive(options) {
+  p.intro("gh-symphony - Project Setup");
+  const defaultWorkspaceDir = join(options.configDir, "workspaces");
+  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") {
+    }
+  }
+  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\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 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;
+  }
+  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/2 - Select a GitHub Project board:",
+      options: projects.map((project) => ({
+        value: project.id,
+        label: `${project.owner.login}/${project.title}`,
+        hint: `${project.openItemCount} items`
+      })),
+      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;
+  }
+  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 assignedOnly = await abortIfCancelled(
+    p.confirm({
+      message: "Step 2/2 - Only process issues assigned to the authenticated GitHub user?",
+      initialValue: false
+    })
+  );
+  const customizeAdvancedOptions = await abortIfCancelled(
+    p.confirm({
+      message: "Customize advanced options? (default: No)",
+      initialValue: false
+    })
+  );
+  let selectedRepos = projectDetail.linkedRepositories;
+  let workspaceDir = defaultWorkspaceDir;
+  if (customizeAdvancedOptions) {
+    const filterRepositories = await abortIfCancelled(
+      p.confirm({
+        message: "Filter specific repositories? (default: No)",
+        initialValue: false
+      })
+    );
+    if (filterRepositories) {
+      selectedRepos = await abortIfCancelled(
+        p.multiselect({
+          message: "Select repositories to orchestrate:",
+          options: projectDetail.linkedRepositories.map((repo) => ({
+            value: repo,
+            label: `${repo.owner}/${repo.name}`
+          })),
+          required: true
+        })
+      );
+    }
+    workspaceDir = await abortIfCancelled(
+      p.text({
+        message: "Workspace root directory:",
+        placeholder: defaultWorkspaceDir,
+        defaultValue: defaultWorkspaceDir,
+        validate(value) {
+          return value.trim().length > 0 ? void 0 : "Workspace directory is required.";
+        }
+      })
+    );
+  }
+  const repoSummary = 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)`;
+  p.note(
+    [
+      `User:       ${login}`,
+      `Project:    ${projectDetail.title}`,
+      `Repos:      ${repoSummary}`,
+      `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.
+  Run 'gh-symphony start' to begin orchestration.`
+  );
+}
+async function projectList(options) {
+  const global = await loadGlobalConfig(options.configDir);
+  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 showEndpointColumn = rows.some((row) => row.endpoint !== null);
+  const headers = [
+    "ID",
+    "Name",
+    "Status",
+    "Health",
+    "Active Runs",
+    "Last Tick",
+    "Uptime",
+    ...showEndpointColumn ? ["Endpoint"] : []
+  ];
+  const table = renderTable(
+    headers,
+    rows.map((row) => [
+      row.id,
+      row.name,
+      row.status,
+      row.health,
+      row.activeRuns === null ? "-" : String(row.activeRuns),
+      row.lastTick,
+      row.uptime,
+      ...showEndpointColumn ? [row.endpoint ?? "-"] : []
+    ])
+  );
+  process.stdout.write(`${table}
+`);
+}
+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 global = await loadGlobalConfig(options.configDir);
+  if (!global) {
+    process.stderr.write("No configuration found.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const updatedProjects = global.projects.filter((entry) => entry !== projectId);
+  if (updatedProjects.length === global.projects.length) {
+    process.stderr.write(`Project "${projectId}" not found.
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const updatedConfig = {
+    ...global,
+    projects: updatedProjects,
+    activeProject: global.activeProject === projectId ? null : global.activeProject
+  };
+  await saveGlobalConfig(options.configDir, updatedConfig);
+  const { rm } = await import("fs/promises");
+  try {
+    await rm(projectConfigDir(options.configDir, projectId), {
+      recursive: true,
+      force: true
+    });
+  } catch {
+  }
+  process.stdout.write(`Project "${projectId}" removed.
+`);
+}
+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]}
+`);
+    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" : void 0
+    }))
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Cancelled.");
+    return;
+  }
+  global.activeProject = selected;
+  await saveGlobalConfig(options.configDir, global);
+  process.stdout.write(`Switched to project: ${selected}
+`);
+}
+export {
+  project_default as default
+};