@gh-symphony/cli 0.0.21 → 0.1.2

package/dist/chunk-GHVDABFO.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+import {
+  resolveRepoRuntimeRoot
+} from "./chunk-6I753NYO.js";
+import {
+  parseWorkflowMarkdown
+} from "./chunk-GPRCOJDJ.js";
+import {
+  saveGlobalConfig,
+  saveProjectConfig
+} from "./chunk-WOVNN5NW.js";
+
+// src/repo-runtime.ts
+import { execFileSync } from "child_process";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import { basename, dirname, join, resolve } from "path";
+var INTERNAL_PROJECT_ID = "repository";
+var RepoRuntimeMigrationError = class extends Error {
+};
+function parseRepoRuntimeFlags(args) {
+  const flags = { repoDir: process.cwd() };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const value = args[i + 1];
+    if (arg === "--repo-dir") {
+      if (!value || value.startsWith("-")) {
+        throw new Error("Option '--repo-dir' argument missing");
+      }
+      flags.repoDir = resolve(value);
+      i += 1;
+      continue;
+    }
+    if (arg === "--workflow-file") {
+      if (!value || value.startsWith("-")) {
+        throw new Error("Option '--workflow-file' argument missing");
+      }
+      flags.workflowFile = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("-")) {
+      throw new Error(`Unknown option '${arg}'`);
+    }
+  }
+  return flags;
+}
+async function initRepoRuntime(flags) {
+  const repoDir = resolve(flags.repoDir);
+  const runtimeRoot = resolveRepoRuntimeRoot(repoDir);
+  await migrateLegacyRuntime(runtimeRoot);
+  const workflowPath = resolve(repoDir, flags.workflowFile ?? "WORKFLOW.md");
+  const workflow = parseWorkflowMarkdown(await readFile(workflowPath, "utf8"));
+  const repository = resolveRepository(repoDir);
+  const trackerAdapter = workflow.tracker.kind ?? "github-project";
+  const trackerBindingId = workflow.tracker.projectId ?? workflow.tracker.projectSlug ?? "";
+  const trackerSettings = {
+    ...workflow.tracker.projectId ? { projectId: workflow.tracker.projectId } : {},
+    repository: `${repository.owner}/${repository.name}`
+  };
+  if (flags.assignedOnly) {
+    trackerSettings.assignedOnly = true;
+  }
+  if (trackerAdapter === "file") {
+    if (!process.env.GH_SYMPHONY_FILE_TRACKER_ISSUES_PATH) {
+      throw new Error(
+        "File tracker repo init requires GH_SYMPHONY_FILE_TRACKER_ISSUES_PATH to point to the issues fixture."
+      );
+    }
+    trackerSettings.issuesPath = process.env.GH_SYMPHONY_FILE_TRACKER_ISSUES_PATH;
+  }
+  const projectConfig = {
+    projectId: INTERNAL_PROJECT_ID,
+    slug: basename(repoDir) || INTERNAL_PROJECT_ID,
+    displayName: `${repository.owner}/${repository.name}`,
+    workspaceDir: repoDir,
+    repository,
+    tracker: {
+      adapter: trackerAdapter,
+      bindingId: trackerBindingId,
+      settings: trackerSettings
+    }
+  };
+  await mkdir(runtimeRoot, { recursive: true });
+  await saveProjectConfig(runtimeRoot, INTERNAL_PROJECT_ID, projectConfig);
+  await saveGlobalConfig(runtimeRoot, {
+    activeProject: INTERNAL_PROJECT_ID,
+    projects: [INTERNAL_PROJECT_ID]
+  });
+  const orchestratorConfig = {
+    projectId: INTERNAL_PROJECT_ID,
+    slug: projectConfig.slug,
+    workspaceDir: repoDir,
+    repository,
+    tracker: projectConfig.tracker
+  };
+  await writeJsonFile(join(runtimeRoot, "project.json"), orchestratorConfig);
+  return {
+    configDir: runtimeRoot,
+    projectId: INTERNAL_PROJECT_ID,
+    workflowPath,
+    repository
+  };
+}
+async function migrateLegacyRuntime(runtimeRoot) {
+  const projectsDir = join(runtimeRoot, "projects");
+  const projectIds = await readDirectoryNames(projectsDir);
+  if (projectIds.length === 0) {
+    return;
+  }
+  if (projectIds.length === 1 && projectIds[0] === INTERNAL_PROJECT_ID && await pathExists(join(runtimeRoot, "project.json"))) {
+    return;
+  }
+  if (projectIds.length > 1) {
+    throw new RepoRuntimeMigrationError(
+      [
+        "Multiple legacy project runtime directories were found under .runtime/orchestrator/projects.",
+        `Found: ${projectIds.join(", ")}`,
+        "Automatic migration is only supported when exactly one project directory exists.",
+        "Manually keep the project directory you want to promote, archive or remove the others, then re-run 'gh-symphony repo init'."
+      ].join("\n")
+    );
+  }
+  const sourceDir = join(projectsDir, projectIds[0]);
+  const entries = await readdir(sourceDir);
+  for (const entry of entries) {
+    const target = join(runtimeRoot, entry);
+    if (await pathExists(target)) {
+      throw new RepoRuntimeMigrationError(
+        `Cannot promote legacy runtime data because '${entry}' already exists in .runtime/orchestrator. Move or remove it, then re-run 'gh-symphony repo init'.`
+      );
+    }
+    await rename(join(sourceDir, entry), target);
+  }
+  await stripProjectIdFromRunRecords(join(runtimeRoot, "runs"));
+  await rm(projectsDir, { recursive: true, force: true });
+}
+async function stripProjectIdFromRunRecords(runsDir) {
+  for (const runId of await readDirectoryNames(runsDir)) {
+    const runPath = join(runsDir, runId, "run.json");
+    const run = await readJsonFile(runPath);
+    if (!run || !("projectId" in run)) {
+      continue;
+    }
+    delete run.projectId;
+    await writeJsonFile(runPath, run);
+  }
+}
+async function readDirectoryNames(path) {
+  try {
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch (error) {
+    if (isMissing(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function resolveRepository(repoDir) {
+  const remote = readGitOrigin(repoDir);
+  const cleanedRemote = remote.replace(/\.git$/, "");
+  const match = cleanedRemote.match(/github\.com[:/]([^/]+)\/([^/]+)$/) ?? cleanedRemote.match(/^([^/]+)\/([^/]+)$/);
+  if (!match) {
+    throw new Error(
+      "Unable to infer GitHub repository from git remote 'origin'. Run from a cloned GitHub repository or set origin to owner/name."
+    );
+  }
+  return {
+    owner: match[1],
+    name: match[2],
+    cloneUrl: remote.startsWith("http") ? remote : `https://github.com/${match[1]}/${match[2]}.git`,
+    path: repoDir
+  };
+}
+function readGitOrigin(repoDir) {
+  try {
+    return execFileSync(
+      "git",
+      ["-C", repoDir, "config", "--get", "remote.origin.url"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+  } catch {
+    throw new Error(
+      "Unable to read git remote 'origin'. Run 'gh-symphony repo init' inside a cloned repository."
+    );
+  }
+}
+async function readJsonFile(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (isMissing(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");
+  await rename(temporaryPath, path);
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (isMissing(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+function isMissing(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")
+  );
+}
+
+export {
+  parseRepoRuntimeFlags,
+  initRepoRuntime
+};