@gh-symphony/cli 0.0.22 → 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
+};

package/dist/{chunk-EEQQWTXS.js → chunk-GPRCOJDJ.js}

@@ -583,73 +583,6 @@ function matchOptionalSection(markdown, heading) {
   return match?.[1]?.trim() ?? null;
 }
 
-// ../core/src/workflow/loader.ts
-import { createHash } from "crypto";
-import { access, readFile, stat } from "fs/promises";
-import { constants } from "fs";
-var WorkflowConfigStore = class {
-  cache = /* @__PURE__ */ new Map();
-  async load(workflowPath, env = process.env) {
-    await access(workflowPath, constants.R_OK);
-    const fileStat = await stat(workflowPath);
-    const cached = this.cache.get(workflowPath);
-    const markdown = await readFile(workflowPath, "utf8");
-    const fingerprint = `${fileStat.mtimeMs}:${fileStat.size}:${createHash("sha256").update(markdown).digest("hex")}`;
-    if (cached && cached.fingerprint === fingerprint) {
-      return toWorkflowResolution(workflowPath, cached.workflow, {
-        isValid: true,
-        usedLastKnownGood: false,
-        validationError: null
-      });
-    }
-    try {
-      const workflow = parseWorkflowMarkdown(markdown, env);
-      this.cache.set(workflowPath, {
-        fingerprint,
-        workflow,
-        loadedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return toWorkflowResolution(workflowPath, workflow, {
-        isValid: true,
-        usedLastKnownGood: false,
-        validationError: null
-      });
-    } catch (error) {
-      if (cached) {
-        return toWorkflowResolution(workflowPath, cached.workflow, {
-          isValid: false,
-          usedLastKnownGood: true,
-          validationError: error instanceof Error ? error.message : "Invalid workflow definition."
-        });
-      }
-      throw error;
-    }
-  }
-};
-function createDefaultWorkflowResolution() {
-  return createInvalidWorkflowResolution(null, "missing_workflow_file");
-}
-function createInvalidWorkflowResolution(workflowPath, validationError) {
-  return toWorkflowResolution(workflowPath, DEFAULT_WORKFLOW_DEFINITION, {
-    isValid: false,
-    usedLastKnownGood: false,
-    validationError
-  });
-}
-function toWorkflowResolution(workflowPath, workflow, metadata) {
-  return {
-    workflowPath,
-    workflow,
-    lifecycle: workflow.lifecycle,
-    promptTemplate: workflow.promptTemplate,
-    agentCommand: workflow.agentCommand,
-    hookPath: workflow.hookPath ?? "",
-    isValid: metadata.isValid,
-    usedLastKnownGood: metadata.usedLastKnownGood,
-    validationError: metadata.validationError
-  };
-}
-
 // ../core/src/workflow/render.ts
 import {
   Liquid,
@@ -659,6 +592,17 @@ import {
   UndefinedVariableError
 } from "liquidjs";
 function buildPromptVariables(issue, options) {
+  const contentType = issue.metadata.contentType ?? "Issue";
+  const linkedPullRequests = Array.isArray(issue.metadata.linkedPullRequests) ? issue.metadata.linkedPullRequests.map(normalizePullRequestContext) : [];
+  const primaryPullRequest = contentType === "PullRequest" ? normalizePullRequestContext(
+    issue.metadata.pullRequest ?? linkedPullRequests[0] ?? buildPullRequestContextFromIssue(issue)
+  ) : linkedPullRequests[0] ?? null;
+  const pullRequestContext = buildPullRequestVariables({
+    contentType,
+    linkedPullRequests,
+    primaryPullRequest,
+    issueBranchName: issue.branchName
+  });
   return {
     issue: {
       id: issue.id,
@@ -672,13 +616,61 @@ function buildPromptVariables(issue, options) {
       labels: issue.labels,
       blocked_by: issue.blockedBy,
       branch_name: issue.branchName,
+      content_type: contentType,
+      linked_pull_requests: linkedPullRequests,
+      primary_pull_request: primaryPullRequest,
+      has_linked_pr: linkedPullRequests.length > 0,
       created_at: issue.createdAt,
       updated_at: issue.updatedAt,
       repository: `${issue.repository.owner}/${issue.repository.name}`
     },
+    pull_request_context: pullRequestContext,
     attempt: options.attempt
   };
 }
+function normalizePullRequestContext(pullRequest) {
+  return {
+    ...pullRequest,
+    state: pullRequest.state ?? null,
+    projectState: pullRequest.projectState ?? null,
+    isDraft: pullRequest.isDraft ?? null,
+    merged: pullRequest.merged ?? null,
+    headRefName: pullRequest.headRefName ?? null,
+    baseRefName: pullRequest.baseRefName ?? null
+  };
+}
+function buildPullRequestVariables(options) {
+  const checkoutBranch = options.primaryPullRequest?.headRefName ?? (options.contentType === "PullRequest" ? options.issueBranchName : null);
+  const hasPrimaryPr = options.primaryPullRequest !== null;
+  return {
+    subject_type: options.contentType,
+    linked_pull_requests: options.linkedPullRequests,
+    primary_pull_request: options.primaryPullRequest,
+    has_linked_pr: options.linkedPullRequests.length > 0,
+    has_primary_pr: hasPrimaryPr,
+    checkout_branch: checkoutBranch,
+    // Policy flag for prompt templates: any primary PR means the worker must
+    // inspect review threads and checks before editing code.
+    review_first: hasPrimaryPr
+  };
+}
+function buildPullRequestContextFromIssue(issue) {
+  return {
+    id: issue.id,
+    number: issue.number,
+    identifier: issue.identifier,
+    url: issue.url,
+    state: null,
+    projectState: issue.state,
+    headRefName: issue.branchName,
+    repository: {
+      owner: issue.repository.owner,
+      name: issue.repository.name,
+      url: issue.repository.url ?? "",
+      cloneUrl: issue.repository.cloneUrl
+    }
+  };
+}
 var STRICT_LIQUID_ENGINE = new Liquid({
   strictVariables: true,
   strictFilters: true,
@@ -873,6 +865,73 @@ function isOrchestratorChannelEvent(value) {
   return false;
 }
 
+// ../core/src/workflow/loader.ts
+import { createHash } from "crypto";
+import { access, readFile, stat } from "fs/promises";
+import { constants } from "fs";
+var WorkflowConfigStore = class {
+  cache = /* @__PURE__ */ new Map();
+  async load(workflowPath, env = process.env) {
+    await access(workflowPath, constants.R_OK);
+    const fileStat = await stat(workflowPath);
+    const cached = this.cache.get(workflowPath);
+    const markdown = await readFile(workflowPath, "utf8");
+    const fingerprint = `${fileStat.mtimeMs}:${fileStat.size}:${createHash("sha256").update(markdown).digest("hex")}`;
+    if (cached && cached.fingerprint === fingerprint) {
+      return toWorkflowResolution(workflowPath, cached.workflow, {
+        isValid: true,
+        usedLastKnownGood: false,
+        validationError: null
+      });
+    }
+    try {
+      const workflow = parseWorkflowMarkdown(markdown, env);
+      this.cache.set(workflowPath, {
+        fingerprint,
+        workflow,
+        loadedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return toWorkflowResolution(workflowPath, workflow, {
+        isValid: true,
+        usedLastKnownGood: false,
+        validationError: null
+      });
+    } catch (error) {
+      if (cached) {
+        return toWorkflowResolution(workflowPath, cached.workflow, {
+          isValid: false,
+          usedLastKnownGood: true,
+          validationError: error instanceof Error ? error.message : "Invalid workflow definition."
+        });
+      }
+      throw error;
+    }
+  }
+};
+function createDefaultWorkflowResolution() {
+  return createInvalidWorkflowResolution(null, "missing_workflow_file");
+}
+function createInvalidWorkflowResolution(workflowPath, validationError) {
+  return toWorkflowResolution(workflowPath, DEFAULT_WORKFLOW_DEFINITION, {
+    isValid: false,
+    usedLastKnownGood: false,
+    validationError
+  });
+}
+function toWorkflowResolution(workflowPath, workflow, metadata) {
+  return {
+    workflowPath,
+    workflow,
+    lifecycle: workflow.lifecycle,
+    promptTemplate: workflow.promptTemplate,
+    agentCommand: workflow.agentCommand,
+    hookPath: workflow.hookPath ?? "",
+    isValid: metadata.isValid,
+    usedLastKnownGood: metadata.usedLastKnownGood,
+    validationError: metadata.validationError
+  };
+}
+
 // ../core/src/workflow/exit-classification.ts
 function classifySessionExit(params) {
   if (params.userInputRequired) {
@@ -1471,7 +1530,7 @@ async function runClaudePreflight(options, dependencies = {}) {
   const command = resolveRuntimeCommandBinary(options.command) ?? "claude";
   const checks = [];
   checks.push(checkClaudeBinary(command, options.cwd, deps));
-  checks.push(await checkAnthropicApiKey(env, options, deps));
+  checks.push(await checkClaudeAuthentication(env, options, deps));
   checks.push(await checkWorkspaceMcpConfig(options.cwd, deps));
   if (options.includeGhAuth) {
     checks.push(checkGhAuthentication(options.cwd, deps));
@@ -1573,11 +1632,12 @@ function checkGhAuthentication(cwd, deps) {
     );
   }
 }
-async function checkAnthropicApiKey(env, options, deps) {
+async function checkClaudeAuthentication(env, options, deps) {
+  const authMode = options.authMode ?? "api-key-required";
   if (env.ANTHROPIC_API_KEY?.trim()) {
     return pass(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       "ANTHROPIC_API_KEY is configured in the environment.",
       { source: "env" }
     );
@@ -1585,9 +1645,32 @@ async function checkAnthropicApiKey(env, options, deps) {
   const brokerUrl = env.AGENT_CREDENTIAL_BROKER_URL?.trim();
   const brokerSecret = env.AGENT_CREDENTIAL_BROKER_SECRET?.trim();
   if (!brokerUrl || !brokerSecret) {
+    if (authMode === "local-or-api-key" && !brokerUrl && !brokerSecret) {
+      return warn(
+        "anthropic_api_key",
+        "Claude authentication",
+        "ANTHROPIC_API_KEY and agent credential broker are not configured; Claude Code local login may be used for this non-bare runtime.",
+        "If this runtime will run headlessly or with runtime.isolation.bare: true, set ANTHROPIC_API_KEY or configure AGENT_CREDENTIAL_BROKER_URL and AGENT_CREDENTIAL_BROKER_SECRET.",
+        { source: "local" }
+      );
+    }
+    if (brokerUrl || brokerSecret) {
+      const missingName = brokerUrl ? "AGENT_CREDENTIAL_BROKER_SECRET" : "AGENT_CREDENTIAL_BROKER_URL";
+      return fail(
+        "anthropic_api_key",
+        "Claude authentication",
+        `Agent credential broker configuration is incomplete: ${missingName} is not configured.`,
+        `Set ${missingName} or remove the partial broker configuration and use ANTHROPIC_API_KEY instead.`,
+        {
+          source: "broker",
+          brokerUrl: brokerUrl ?? null,
+          missing: missingName
+        }
+      );
+    }
     return fail(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       "Neither ANTHROPIC_API_KEY nor an agent credential broker is configured.",
       "Set ANTHROPIC_API_KEY or configure AGENT_CREDENTIAL_BROKER_URL and AGENT_CREDENTIAL_BROKER_SECRET.",
       { source: "missing" }
@@ -1596,7 +1679,7 @@ async function checkAnthropicApiKey(env, options, deps) {
   if (options.probeCredentialBroker === false) {
     return pass(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       "Agent credential broker configuration is present.",
       { source: "broker", brokerUrl }
     );
@@ -1614,14 +1697,14 @@ async function checkAnthropicApiKey(env, options, deps) {
     if (response.ok && payload.env?.ANTHROPIC_API_KEY?.trim()) {
       return pass(
         "anthropic_api_key",
-        "Anthropic API key",
+        "Claude authentication",
         "Agent credential broker is reachable and returned ANTHROPIC_API_KEY.",
         { source: "broker", brokerUrl }
       );
     }
     return fail(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       payload.error ? `Agent credential broker did not return ANTHROPIC_API_KEY: ${payload.error}.` : "Agent credential broker did not return ANTHROPIC_API_KEY.",
       "Set ANTHROPIC_API_KEY or configure the credential broker to return ANTHROPIC_API_KEY.",
       { source: "broker", brokerUrl, status: response.status }
@@ -1629,7 +1712,7 @@ async function checkAnthropicApiKey(env, options, deps) {
   } catch (error) {
     return fail(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       "Agent credential broker could not be reached.",
       "Set ANTHROPIC_API_KEY or fix AGENT_CREDENTIAL_BROKER_URL and AGENT_CREDENTIAL_BROKER_SECRET.",
       {

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/{chunk-2UW7NQLX.js → chunk-VFHMHHZW.js}

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