@gh-symphony/cli 0.0.14 → 0.0.15

package/dist/chunk-ROGRTUFI.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG_DIR = join(homedir(), ".gh-symphony");
+var CONFIG_FILE = "config.json";
+var DAEMON_PID_FILE = "daemon.pid";
+var ORCHESTRATOR_LOG_FILE = "orchestrator.log";
+var HTTP_STATUS_FILE = "http.json";
+function resolveConfigDir(override) {
+  return override ?? process.env.GH_SYMPHONY_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
+}
+function configFilePath(configDir) {
+  return join(configDir, CONFIG_FILE);
+}
+function projectConfigDir(configDir, projectId) {
+  return join(configDir, "projects", projectId);
+}
+function projectConfigPath(configDir, projectId) {
+  return join(projectConfigDir(configDir, projectId), "project.json");
+}
+function daemonPidPath(configDir, projectId) {
+  return join(projectConfigDir(configDir, projectId), DAEMON_PID_FILE);
+}
+function orchestratorLogPath(configDir, projectId) {
+  return join(projectConfigDir(configDir, projectId), ORCHESTRATOR_LOG_FILE);
+}
+function orchestratorWorkspaceRuntimeDir(configDir, projectId) {
+  return join(configDir, "orchestrator", "workspaces", projectId);
+}
+function httpStatusPath(configDir, projectId) {
+  return join(
+    orchestratorWorkspaceRuntimeDir(configDir, projectId),
+    HTTP_STATUS_FILE
+  );
+}
+async function loadGlobalConfig(configDir) {
+  const raw = await readJsonFile(
+    configFilePath(configDir)
+  );
+  if (!raw) {
+    return null;
+  }
+  return {
+    activeProject: typeof raw.activeProject === "string" ? raw.activeProject : null,
+    projects: Array.isArray(raw.projects) ? raw.projects.filter(
+      (projectId) => typeof projectId === "string"
+    ) : []
+  };
+}
+async function saveGlobalConfig(configDir, config) {
+  await writeJsonFile(configFilePath(configDir), config);
+}
+async function loadProjectConfig(configDir, projectId) {
+  return readJsonFile(
+    projectConfigPath(configDir, projectId)
+  );
+}
+async function saveProjectConfig(configDir, projectId, config) {
+  await writeJsonFile(projectConfigPath(configDir, projectId), config);
+}
+async function loadActiveProjectConfig(configDir) {
+  const global = await loadGlobalConfig(configDir);
+  if (!global?.activeProject) {
+    return null;
+  }
+  return loadProjectConfig(configDir, global.activeProject);
+}
+async function readJsonFile(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (isFileMissing(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeJsonFile(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const temporaryPath = `${path}.tmp`;
+  await writeFile(temporaryPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  const { rename } = await import("fs/promises");
+  await rename(temporaryPath, path);
+}
+function isFileMissing(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")
+  );
+}
+
+export {
+  resolveConfigDir,
+  configFilePath,
+  projectConfigDir,
+  daemonPidPath,
+  orchestratorLogPath,
+  httpStatusPath,
+  loadGlobalConfig,
+  saveGlobalConfig,
+  loadProjectConfig,
+  saveProjectConfig,
+  loadActiveProjectConfig,
+  writeJsonFile
+};

package/dist/chunk-TH5QPO3Y.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import {
+  loadGlobalConfig,
+  loadProjectConfig
+} from "./chunk-ROGRTUFI.js";
+
+// src/project-selection.ts
+import * as p from "@clack/prompts";
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function explicitProjectRequiredMessage() {
+  return "Multiple projects are configured. Re-run with --project-id in non-interactive environments.\n";
+}
+async function resolveManagedProjectConfig(input) {
+  if (input.requestedProjectId) {
+    return loadProjectConfig(input.configDir, input.requestedProjectId);
+  }
+  const global = await loadGlobalConfig(input.configDir);
+  const projectIds = global?.projects ?? [];
+  if (projectIds.length === 0) {
+    return null;
+  }
+  if (projectIds.length === 1) {
+    return loadProjectConfig(input.configDir, projectIds[0]);
+  }
+  if (!isInteractiveTerminal()) {
+    process.stderr.write(explicitProjectRequiredMessage());
+    process.exitCode = 1;
+    return null;
+  }
+  const projects = await Promise.all(
+    projectIds.map(async (projectId) => ({
+      projectId,
+      config: await loadProjectConfig(input.configDir, projectId)
+    }))
+  );
+  const selected = await p.select({
+    message: "Select a project:",
+    options: projects.map(({ projectId, config }) => ({
+      value: projectId,
+      label: config?.displayName ?? config?.slug ?? projectId,
+      hint: projectId === global?.activeProject ? "current" : config && config.displayName && config.displayName !== projectId ? projectId : void 0
+    })),
+    maxItems: 10
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Cancelled.");
+    process.exitCode = 130;
+    return null;
+  }
+  return loadProjectConfig(input.configDir, selected);
+}
+function handleMissingManagedProjectConfig() {
+  if (process.exitCode) {
+    return;
+  }
+  process.stderr.write(
+    "No project configured. Run 'gh-symphony project add' first.\n"
+  );
+  process.exitCode = 1;
+}
+
+export {
+  resolveManagedProjectConfig,
+  handleMissingManagedProjectConfig
+};

package/dist/config-cmd-AZ7POMAA.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import {
+  configFilePath,
+  loadGlobalConfig,
+  saveGlobalConfig
+} from "./chunk-ROGRTUFI.js";
+
+// src/commands/config-cmd.ts
+import { spawn } from "child_process";
+var handler = async (args, options) => {
+  const [subcommand, ...rest] = args;
+  switch (subcommand) {
+    case "show":
+      await configShow(options);
+      break;
+    case "set":
+      await configSet(rest, options);
+      break;
+    case "edit":
+      await configEdit(options);
+      break;
+    default:
+      process.stderr.write("Usage: gh-symphony config <show|set|edit>\n");
+      process.exitCode = 2;
+  }
+};
+var config_cmd_default = handler;
+async function configShow(options) {
+  const config = await loadGlobalConfig(options.configDir);
+  if (!config) {
+    process.stderr.write("No configuration found. Run 'gh-symphony init'.\n");
+    process.exitCode = 1;
+    return;
+  }
+  if (options.json) {
+    process.stdout.write(JSON.stringify(config, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write(`Config: ${configFilePath(options.configDir)}
+
+`);
+  process.stdout.write(`Active project:    ${config.activeProject ?? "none"}
+`);
+  process.stdout.write(
+    `Projects:         ${config.projects.join(", ") || "none"}
+`
+  );
+}
+var VALID_KEYS = {
+  "active-project": { type: "string" }
+};
+async function configSet(args, options) {
+  const [key, value] = args;
+  if (!key || value === void 0) {
+    process.stderr.write("Usage: gh-symphony config set <key> <value>\n");
+    process.stderr.write(`Valid keys: ${Object.keys(VALID_KEYS).join(", ")}
+`);
+    process.exitCode = 2;
+    return;
+  }
+  const keyDef = VALID_KEYS[key];
+  if (!keyDef) {
+    process.stderr.write(
+      `Unknown config key: ${key}
+Valid keys: ${Object.keys(VALID_KEYS).join(", ")}
+`
+    );
+    process.exitCode = 2;
+    return;
+  }
+  const config = await loadGlobalConfig(options.configDir) ?? {
+    activeProject: null,
+    projects: []
+  };
+  switch (key) {
+    case "active-project":
+      if (!config.projects.includes(value)) {
+        process.stderr.write(
+          `Project "${value}" not found. Available: ${config.projects.join(", ")}
+`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      config.activeProject = value;
+      break;
+  }
+  await saveGlobalConfig(options.configDir, config);
+  process.stdout.write(`Set ${key} = ${value}
+`);
+}
+async function configEdit(options) {
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+  const path = configFilePath(options.configDir);
+  const child = spawn(editor, [path], {
+    stdio: "inherit"
+  });
+  await new Promise((resolve, reject) => {
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Editor exited with code ${code}`));
+      }
+    });
+  });
+}
+export {
+  config_cmd_default as default
+};

package/dist/index.d.ts

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