@gh-symphony/cli 0.0.22 → 0.1.3

package/dist/{chunk-36KYEDEO.js → chunk-MVRF7BES.js}

@@ -51,14 +51,6 @@ function showCursor() {
   return "\x1B[?25h";
 }
 
-// src/format/repository.ts
-function formatRepositoryDisplay(snapshot, fallback = "repository") {
-  if (snapshot.repository) {
-    return `${snapshot.repository.owner}/${snapshot.repository.name}`;
-  }
-  return snapshot.slug ?? fallback;
-}
-
 export {
   bold,
   dim,
@@ -72,6 +64,5 @@ export {
   setNoColor,
   clearScreen,
   hideCursor,
-  showCursor,
-  formatRepositoryDisplay
+  showCursor
 };

package/dist/{workflow-L3KT6HB7.js → chunk-NESHTYXQ.js}

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import {
-  init_default
-} from "./chunk-HMLBBZNY.js";
+  workflow_init_default
+} from "./chunk-2YF7PQUC.js";
 import {
-  fetchGithubProjectIssueByRepositoryAndNumber
-} from "./chunk-2TSM3INR.js";
+  fetchGithubProjectIssueByRepositoryAndNumber,
+  inspectManagedProjectSelection
+} from "./chunk-HQ7A3C7K.js";
 import {
   GitHubApiError,
   createClient,
@@ -12,16 +13,12 @@ import {
   getGhTokenWithSource,
   getProjectDetail,
   validateGitHubToken
-} from "./chunk-C67H3OUL.js";
+} from "./chunk-Z3NZOPLZ.js";
 import {
   buildPromptVariables,
   parseWorkflowMarkdown,
   renderPrompt
-} from "./chunk-EEQQWTXS.js";
-import {
-  inspectManagedProjectSelection
-} from "./chunk-DDL4BWSL.js";
-import "./chunk-QIRE2VXS.js";
+} from "./chunk-WCOIVNHH.js";
 
 // src/commands/workflow.ts
 import { readFile } from "fs/promises";
@@ -391,6 +388,14 @@ function readGitHubProjectBinding(projectConfig) {
   const settingsProjectId = projectConfig.tracker.settings?.projectId;
   return typeof settingsProjectId === "string" && settingsProjectId.trim().length > 0 ? settingsProjectId.trim() : null;
 }
+function renderIssueWorkflowPreview(input) {
+  const variables = buildPromptVariables(input.issue, {
+    attempt: input.attempt
+  });
+  return renderPrompt(input.workflow.promptTemplate, variables, {
+    strict: true
+  });
+}
 function formatAuthError(error) {
   return `GitHub authentication is required for live issue preview. ${error.message}`;
 }
@@ -406,7 +411,7 @@ async function loadLiveIssue(issueReference, projectId, options) {
   const githubProjectId = readGitHubProjectBinding(selection.projectConfig);
   if (!githubProjectId) {
     throw new Error(
-      `Managed project "${selection.projectId}" is not bound to a GitHub Project. Re-run 'gh-symphony project add' and select a valid GitHub Project binding.`
+      `Managed project "${selection.projectId}" is not bound to a GitHub Project. Run 'gh-symphony workflow init' to select a valid GitHub Project binding, then run 'gh-symphony repo init'.`
     );
   }
   let auth;
@@ -439,7 +444,7 @@ async function loadLiveIssue(issueReference, projectId, options) {
   }
   if (!findLinkedRepository(detail, issue.owner, issue.name)) {
     throw new Error(
-      `Repository ${issue.owner}/${issue.name} is not linked to the configured GitHub Project "${detail.title}". Run 'gh-symphony repo add ${issue.owner}/${issue.name}' or re-run 'gh-symphony project add' with the correct project binding.`
+      `Repository ${issue.owner}/${issue.name} is not linked to the configured GitHub Project "${detail.title}". Run 'gh-symphony setup' from inside the target repository, or run 'gh-symphony workflow init' followed by 'gh-symphony repo init'.`
     );
   }
   const trackedIssue = await workflowCommandDependencies.fetchLiveIssue(
@@ -587,12 +592,11 @@ async function runPreview(args, options) {
     );
   }
   const { issue, sampleSource } = flags.issue ? await loadLiveIssue(flags.issue, flags.projectId, options) : await loadSampleIssue(flags.sample);
-  const variables = buildPromptVariables(issue, {
+  const renderedPrompt = renderIssueWorkflowPreview({
+    workflow,
+    issue,
     attempt: flags.attempt
   });
-  const renderedPrompt = renderPrompt(workflow.promptTemplate, variables, {
-    strict: true
-  });
   if (options.json) {
     process.stdout.write(
       `${JSON.stringify(
@@ -639,7 +643,7 @@ var handler = async (args, options) => {
   try {
     switch (parsed.subcommand) {
       case "init":
-        await init_default(parsed.args, options);
+        await workflow_init_default(parsed.args, options);
         return;
       case "validate":
         await runValidate(parsed.args, options);
@@ -656,8 +660,12 @@ var handler = async (args, options) => {
   }
 };
 var workflow_default = handler;
+
 export {
-  workflow_default as default,
+  setWorkflowCommandDependenciesForTest,
   resetWorkflowCommandDependenciesForTest,
-  setWorkflowCommandDependenciesForTest
+  parseIssueReference,
+  readGitHubProjectBinding,
+  renderIssueWorkflowPreview,
+  workflow_default
 };

package/dist/{chunk-2UW7NQLX.js → chunk-PEZUBHWJ.js}

@@ -8,7 +8,7 @@ import {
   resolveGitHubGraphQLToken,
   shouldReuseAgentCredentialCache,
   writeAgentCredentialCache
-} from "./chunk-EEQQWTXS.js";
+} from "./chunk-WCOIVNHH.js";
 
 // ../runtime-codex/src/runtime.ts
 import { spawn } from "child_process";

package/dist/chunk-PG332ZS4.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+import {
+  resolveRepoRuntimeRoot
+} from "./chunk-6I753NYO.js";
+import {
+  parseWorkflowMarkdown
+} from "./chunk-WCOIVNHH.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 } : {},
+    ...workflow.tracker.projectSlug ? { projectSlug: workflow.tracker.projectSlug } : {},
+    ...trackerAdapter === "linear" ? { activeStates: workflow.tracker.activeStates.join("\n") } : {},
+    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,
+      ...workflow.tracker.endpoint ? { apiUrl: workflow.tracker.endpoint } : {},
+      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
+};