@gh-symphony/cli 0.0.18 → 0.0.19

package/dist/workflow-TBIFY5MO.js

@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+import {
+  init_default
+} from "./chunk-RN2PACNV.js";
+import {
+  buildPromptVariables,
+  parseWorkflowMarkdown,
+  renderPrompt
+} from "./chunk-M3IFVLQS.js";
+import "./chunk-TILHWBP6.js";
+import "./chunk-ROGRTUFI.js";
+
+// src/commands/workflow.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+var SAMPLE_ISSUE = {
+  id: "issue-157-sample",
+  identifier: "octo/hello-world#157",
+  number: 157,
+  title: "Add workflow validate and preview commands",
+  description: "Expose strict WORKFLOW.md validation and prompt preview flows in the CLI.",
+  priority: 1,
+  state: "In progress",
+  branchName: "feat/workflow-cli-preview",
+  url: "https://github.com/octo/hello-world/issues/157",
+  labels: ["enhancement", "cli"],
+  blockedBy: [
+    {
+      id: "issue-120",
+      identifier: "octo/hello-world#120",
+      state: "Done"
+    }
+  ],
+  createdAt: "2026-03-31T02:06:39Z",
+  updatedAt: "2026-04-03T02:28:21Z",
+  repository: {
+    owner: "octo",
+    name: "hello-world",
+    cloneUrl: "https://github.com/octo/hello-world.git",
+    url: "https://github.com/octo/hello-world"
+  },
+  tracker: {
+    adapter: "github-project",
+    bindingId: "sample-binding",
+    itemId: "sample-item"
+  },
+  metadata: {}
+};
+var SAMPLE_CONTINUATION_VARIABLES = {
+  lastTurnSummary: "Validated the prompt template and updated the CLI routing.",
+  cumulativeTurnCount: 3
+};
+function parseWorkflowArgs(args) {
+  const [subcommand, ...rest] = args;
+  if (!subcommand) {
+    return { args: [] };
+  }
+  if (subcommand === "init" || subcommand === "validate" || subcommand === "preview") {
+    return { subcommand, args: rest };
+  }
+  if (subcommand === "--help" || subcommand === "-h") {
+    return { args: ["--help"] };
+  }
+  return {
+    args: rest,
+    error: `Unknown workflow subcommand '${subcommand}'`
+  };
+}
+function parseValidateFlags(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--file") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("Option '--file' argument missing");
+      }
+      flags.file = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("-")) {
+      throw new Error(`Unknown option '${arg}'`);
+    }
+  }
+  return flags;
+}
+function parsePreviewFlags(args) {
+  const flags = {
+    attempt: null
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const value = args[i + 1];
+    switch (arg) {
+      case "--file":
+        if (!value || value.startsWith("-")) {
+          throw new Error("Option '--file' argument missing");
+        }
+        flags.file = value;
+        i += 1;
+        break;
+      case "--sample":
+        if (!value || value.startsWith("-")) {
+          throw new Error("Option '--sample' argument missing");
+        }
+        flags.sample = value;
+        i += 1;
+        break;
+      case "--attempt":
+        if (!value || value.startsWith("-")) {
+          throw new Error("Option '--attempt' argument missing");
+        }
+        flags.attempt = parseAttempt(value);
+        i += 1;
+        break;
+      default:
+        if (arg?.startsWith("-")) {
+          throw new Error(`Unknown option '${arg}'`);
+        }
+        break;
+    }
+  }
+  return flags;
+}
+function parseAttempt(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new Error("Option '--attempt' must be a positive integer");
+  }
+  return parsed;
+}
+function printWorkflowUsage() {
+  process.stdout.write(`Usage: gh-symphony workflow <command> [options]
+
+Commands:
+  init       Generate WORKFLOW.md and workflow support files
+  validate   Parse and strictly validate a WORKFLOW.md file
+  preview    Render the final worker prompt from a sample issue
+
+Options:
+  workflow init [--non-interactive] [--project <id>] [--output <path>] [--skip-skills] [--skip-context] [--dry-run]
+  workflow validate [--file <path>]
+  workflow preview [--file <path>] [--sample <json>] [--attempt <n>]
+`);
+}
+async function loadWorkflowMarkdown(workflowPath) {
+  const resolvedPath = resolve(workflowPath ?? "WORKFLOW.md");
+  const markdown = await readFile(resolvedPath, "utf8");
+  return {
+    workflowPath: resolvedPath,
+    markdown
+  };
+}
+function normalizeIssue(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Sample JSON must be an object.");
+  }
+  const record = value;
+  const repositoryRecord = asRecord(record.repository, "repository");
+  const repositoryOwner = readRequiredString(
+    repositoryRecord.owner,
+    "repository.owner"
+  );
+  const repositoryName = readRequiredString(
+    repositoryRecord.name,
+    "repository.name"
+  );
+  const repositoryUrl = readOptionalString(repositoryRecord.url, "repository.url");
+  return {
+    id: readRequiredString(record.id, "id"),
+    identifier: readRequiredString(record.identifier, "identifier"),
+    number: readRequiredNumber(record.number, "number"),
+    title: readRequiredString(record.title, "title"),
+    description: readOptionalString(record.description, "description"),
+    priority: readOptionalNumber(record.priority, "priority"),
+    state: readRequiredString(record.state, "state"),
+    branchName: readOptionalString(
+      record.branchName ?? record.branch_name,
+      "branchName/branch_name"
+    ),
+    url: readOptionalString(record.url, "url"),
+    labels: readStringArray(record.labels, "labels"),
+    blockedBy: readBlockers(record.blockedBy ?? record.blocked_by),
+    createdAt: readOptionalString(
+      record.createdAt ?? record.created_at,
+      "createdAt/created_at"
+    ),
+    updatedAt: readOptionalString(
+      record.updatedAt ?? record.updated_at,
+      "updatedAt/updated_at"
+    ),
+    repository: {
+      owner: repositoryOwner,
+      name: repositoryName,
+      cloneUrl: readOptionalString(repositoryRecord.cloneUrl, "repository.cloneUrl") ?? `https://github.com/${repositoryOwner}/${repositoryName}.git`,
+      ...repositoryUrl ? { url: repositoryUrl } : {}
+    },
+    tracker: {
+      adapter: "github-project",
+      bindingId: "preview-sample",
+      itemId: readOptionalString(record.itemId, "itemId") ?? "preview-sample"
+    },
+    metadata: {}
+  };
+}
+function asRecord(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Sample JSON field '${field}' must be an object.`);
+  }
+  return value;
+}
+function readRequiredString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Sample JSON field '${field}' must be a non-empty string.`);
+  }
+  return value;
+}
+function readOptionalString(value, field) {
+  if (value === null || value === void 0 || value === "") {
+    return null;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Sample JSON field '${field}' must be a string.`);
+  }
+  return value;
+}
+function readRequiredNumber(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Sample JSON field '${field}' must be a number.`);
+  }
+  return value;
+}
+function readOptionalNumber(value, field) {
+  if (value === null || value === void 0 || value === "") {
+    return null;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Sample JSON field '${field}' must be a number.`);
+  }
+  return value;
+}
+function readStringArray(value, field) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(`Sample JSON field '${field}' must be an array of strings.`);
+  }
+  return value;
+}
+function readBlockers(value) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("Sample JSON field 'blockedBy/blocked_by' must be an array.");
+  }
+  return value.map((entry, index) => {
+    const record = asRecord(entry, `blockedBy/blocked_by[${index}]`);
+    return {
+      id: readOptionalString(record.id, `blockedBy/blocked_by[${index}].id`),
+      identifier: readOptionalString(
+        record.identifier,
+        `blockedBy/blocked_by[${index}].identifier`
+      ),
+      state: readOptionalString(
+        record.state,
+        `blockedBy/blocked_by[${index}].state`
+      )
+    };
+  });
+}
+function validateContinuationGuidance(template) {
+  if (template.includes("{%") || template.includes("%}")) {
+    throw new Error(
+      "template_parse_error: continuation guidance does not support Liquid tags."
+    );
+  }
+  const pattern = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_.]*)\s*\}\}/g;
+  let rendered = "";
+  let lastIndex = 0;
+  for (const match of template.matchAll(pattern)) {
+    const expression = match[1];
+    const index = match.index ?? 0;
+    rendered += template.slice(lastIndex, index);
+    if (!(expression in SAMPLE_CONTINUATION_VARIABLES)) {
+      throw new Error(
+        `template_render_error: unsupported continuation guidance variable '${expression}'.`
+      );
+    }
+    rendered += String(
+      SAMPLE_CONTINUATION_VARIABLES[expression]
+    );
+    lastIndex = index + match[0].length;
+  }
+  rendered += template.slice(lastIndex);
+  const strayLiquidExpression = rendered.match(/\{\{[^}]*\}\}/);
+  if (strayLiquidExpression) {
+    throw new Error(
+      `template_parse_error: invalid continuation guidance expression '${strayLiquidExpression[0]}'.`
+    );
+  }
+}
+async function loadSampleIssue(samplePath) {
+  if (!samplePath) {
+    return { issue: SAMPLE_ISSUE, sampleSource: "built-in" };
+  }
+  const resolvedPath = resolve(samplePath);
+  const raw = await readFile(resolvedPath, "utf8");
+  return {
+    issue: normalizeIssue(JSON.parse(raw)),
+    sampleSource: resolvedPath
+  };
+}
+function validateWorkflow(workflowPath, markdown) {
+  const workflow = parseWorkflowMarkdown(markdown);
+  const promptFreshVariables = buildPromptVariables(SAMPLE_ISSUE, {
+    attempt: null
+  });
+  const promptRetryVariables = buildPromptVariables(SAMPLE_ISSUE, {
+    attempt: 2
+  });
+  renderPrompt(workflow.promptTemplate, promptFreshVariables, { strict: true });
+  renderPrompt(workflow.promptTemplate, promptRetryVariables, { strict: true });
+  const continuationGuidanceStatus = workflow.continuationGuidance ? (() => {
+    validateContinuationGuidance(workflow.continuationGuidance);
+    return "pass";
+  })() : "skip";
+  return {
+    ok: true,
+    workflowPath,
+    format: workflow.format,
+    checks: {
+      promptFresh: "pass",
+      promptRetry: "pass",
+      continuationGuidance: continuationGuidanceStatus
+    },
+    summary: {
+      trackerKind: workflow.tracker.kind,
+      githubProjectId: workflow.githubProjectId,
+      stateFieldName: workflow.lifecycle.stateFieldName,
+      activeStates: workflow.lifecycle.activeStates,
+      terminalStates: workflow.lifecycle.terminalStates,
+      blockerCheckStates: workflow.lifecycle.blockerCheckStates,
+      pollingIntervalMs: workflow.polling.intervalMs,
+      workspaceRoot: workflow.workspace.root,
+      agentCommand: workflow.agentCommand,
+      maxConcurrentAgents: workflow.agent.maxConcurrentAgents,
+      maxFailureRetries: workflow.agent.maxFailureRetries,
+      maxTurns: workflow.agent.maxTurns,
+      retryBaseDelayMs: workflow.agent.retryBaseDelayMs,
+      maxRetryBackoffMs: workflow.agent.maxRetryBackoffMs,
+      codex: {
+        approvalPolicy: workflow.codex.approvalPolicy,
+        threadSandbox: workflow.codex.threadSandbox,
+        turnSandboxPolicy: workflow.codex.turnSandboxPolicy,
+        readTimeoutMs: workflow.codex.readTimeoutMs,
+        stallTimeoutMs: workflow.codex.stallTimeoutMs,
+        turnTimeoutMs: workflow.codex.turnTimeoutMs
+      },
+      hooks: {
+        afterCreate: workflow.hooks.afterCreate,
+        beforeRun: workflow.hooks.beforeRun,
+        afterRun: workflow.hooks.afterRun,
+        beforeRemove: workflow.hooks.beforeRemove,
+        timeoutMs: workflow.hooks.timeoutMs
+      }
+    }
+  };
+}
+function printValidationReport(report) {
+  process.stdout.write(`WORKFLOW.md validation passed
+Path: ${report.workflowPath}
+Format: ${report.format}
+Prompt checks: fresh=pass, retry=pass, continuation_guidance=${report.checks.continuationGuidance}
+
+Lifecycle
+  tracker.kind=${report.summary.trackerKind ?? "unset"}
+  tracker.project_id=${report.summary.githubProjectId ?? "unset"}
+  tracker.state_field=${report.summary.stateFieldName}
+  active_states=${report.summary.activeStates.join(", ") || "(none)"}
+  terminal_states=${report.summary.terminalStates.join(", ") || "(none)"}
+  blocker_check_states=${report.summary.blockerCheckStates.join(", ") || "(none)"}
+
+Runtime
+  polling.interval_ms=${report.summary.pollingIntervalMs}
+  workspace.root=${report.summary.workspaceRoot ?? "unset"}
+  codex.command=${report.summary.agentCommand}
+  agent.max_concurrent_agents=${report.summary.maxConcurrentAgents}
+  agent.max_failure_retries=${report.summary.maxFailureRetries}
+  agent.max_turns=${report.summary.maxTurns}
+  agent.retry_base_delay_ms=${report.summary.retryBaseDelayMs}
+  agent.max_retry_backoff_ms=${report.summary.maxRetryBackoffMs}
+  codex.approval_policy=${report.summary.codex.approvalPolicy ?? "unset"}
+  codex.thread_sandbox=${report.summary.codex.threadSandbox ?? "unset"}
+  codex.turn_sandbox_policy=${report.summary.codex.turnSandboxPolicy ?? "unset"}
+  codex.read_timeout_ms=${report.summary.codex.readTimeoutMs}
+  codex.stall_timeout_ms=${report.summary.codex.stallTimeoutMs}
+  codex.turn_timeout_ms=${report.summary.codex.turnTimeoutMs}
+
+Hooks
+  after_create=${report.summary.hooks.afterCreate ?? "unset"}
+  before_run=${report.summary.hooks.beforeRun ?? "unset"}
+  after_run=${report.summary.hooks.afterRun ?? "unset"}
+  before_remove=${report.summary.hooks.beforeRemove ?? "unset"}
+  hooks.timeout_ms=${report.summary.hooks.timeoutMs}
+`);
+}
+async function runValidate(args, options) {
+  const flags = parseValidateFlags(args);
+  const { workflowPath, markdown } = await loadWorkflowMarkdown(flags.file);
+  const report = validateWorkflow(workflowPath, markdown);
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  printValidationReport(report);
+}
+async function runPreview(args, options) {
+  const flags = parsePreviewFlags(args);
+  const { workflowPath, markdown } = await loadWorkflowMarkdown(flags.file);
+  const workflow = parseWorkflowMarkdown(markdown);
+  const { issue, sampleSource } = await loadSampleIssue(flags.sample);
+  const variables = buildPromptVariables(issue, {
+    attempt: flags.attempt
+  });
+  const renderedPrompt = renderPrompt(workflow.promptTemplate, variables, {
+    strict: true
+  });
+  if (options.json) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          workflowPath,
+          sampleSource,
+          attempt: flags.attempt,
+          renderedPrompt
+        },
+        null,
+        2
+      )}
+`
+    );
+    return;
+  }
+  process.stdout.write(`WORKFLOW.md prompt preview
+Path: ${workflowPath}
+Sample: ${sampleSource}
+Attempt: ${flags.attempt ?? "fresh"}
+
+${renderedPrompt}
+`);
+}
+var handler = async (args, options) => {
+  const parsed = parseWorkflowArgs(args);
+  if (parsed.error) {
+    process.stderr.write(`${parsed.error}
+`);
+    printWorkflowUsage();
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.args[0] === "--help" || parsed.args[0] === "-h") {
+    printWorkflowUsage();
+    return;
+  }
+  if (!parsed.subcommand) {
+    process.stderr.write("Missing workflow subcommand.\n");
+    printWorkflowUsage();
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    switch (parsed.subcommand) {
+      case "init":
+        await init_default(parsed.args, options);
+        return;
+      case "validate":
+        await runValidate(parsed.args, options);
+        return;
+      case "preview":
+        await runPreview(parsed.args, options);
+        return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Workflow command failed: ${message}
+`);
+    process.exitCode = 1;
+  }
+};
+var workflow_default = handler;
+export {
+  workflow_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -42,10 +42,10 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "@gh-symphony/core": "0.0.14",
-    "@gh-symphony/dashboard": "0.0.14",
-    "@gh-symphony/tracker-github": "0.0.14",
     "@gh-symphony/orchestrator": "0.0.14",
-    "@gh-symphony/worker": "0.0.14"
+    "@gh-symphony/dashboard": "0.0.14",
+    "@gh-symphony/worker": "0.0.14",
+    "@gh-symphony/tracker-github": "0.0.14"
   },
   "scripts": {
     "build": "tsup",

package/dist/chunk-7UBUBSMH.js

@@ -1,134 +0,0 @@
-#!/usr/bin/env node
-
-// src/github/gh-auth.ts
-import { execFileSync, spawnSync } from "child_process";
-var REQUIRED_GH_SCOPES = ["repo", "read:org", "project"];
-var GhAuthError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "GhAuthError";
-  }
-};
-function checkGhInstalled(opts) {
-  const execImpl = opts?.execImpl ?? execFileSync;
-  try {
-    execImpl("gh", ["--version"], { stdio: "pipe" });
-    return true;
-  } catch (error) {
-    const execError = error;
-    if (execError.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-function checkGhAuthenticated(opts) {
-  const spawnImpl = opts?.spawnImpl ?? spawnSync;
-  const result = spawnImpl("gh", ["auth", "status"], {
-    encoding: "utf8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if ((result.status ?? 1) !== 0) {
-    return { authenticated: false };
-  }
-  const login = parseLogin((result.stdout ?? "").toString());
-  return { authenticated: true, login };
-}
-function checkGhScopes(opts) {
-  const spawnImpl = opts?.spawnImpl ?? spawnSync;
-  const result = spawnImpl("gh", ["auth", "status"], {
-    encoding: "utf8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  const output = (result.stdout ?? "").toString();
-  const scopes = parseScopes(output);
-  if (scopes.length === 0) {
-    return { valid: true, missing: [], scopes: [] };
-  }
-  const normalized = scopes.map((scope) => scope.toLowerCase());
-  const missing = REQUIRED_GH_SCOPES.filter(
-    (scope) => !normalized.includes(scope)
-  );
-  return {
-    valid: missing.length === 0,
-    missing: [...missing],
-    scopes
-  };
-}
-function getGhToken(opts) {
-  if (process.env.GITHUB_GRAPHQL_TOKEN) {
-    return process.env.GITHUB_GRAPHQL_TOKEN;
-  }
-  const execImpl = opts?.execImpl ?? execFileSync;
-  try {
-    const token = execImpl("gh", ["auth", "token"], {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).toString().trim();
-    if (!token) {
-      throw new GhAuthError(
-        "token_failed",
-        "gh auth token \uC2E4\uD328. gh auth status \uB97C \uD655\uC778\uD558\uC138\uC694."
-      );
-    }
-    return token;
-  } catch (error) {
-    if (error instanceof GhAuthError) {
-      throw error;
-    }
-    throw new GhAuthError(
-      "token_failed",
-      "gh auth token \uC2E4\uD328. gh auth status \uB97C \uD655\uC778\uD558\uC138\uC694."
-    );
-  }
-}
-function ensureGhAuth(opts) {
-  const execImpl = opts?.execImpl ?? execFileSync;
-  const spawnImpl = opts?.spawnImpl ?? spawnSync;
-  if (!checkGhInstalled({ execImpl })) {
-    throw new GhAuthError(
-      "not_installed",
-      "gh CLI\uAC00 \uC124\uCE58\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. https://cli.github.com \uC5D0\uC11C \uC124\uCE58\uD558\uC138\uC694."
-    );
-  }
-  const auth = checkGhAuthenticated({ spawnImpl });
-  if (!auth.authenticated) {
-    throw new GhAuthError(
-      "not_authenticated",
-      "gh auth login --scopes repo,read:org,project \uB97C \uC2E4\uD589\uD558\uC138\uC694."
-    );
-  }
-  const scopeCheck = checkGhScopes({ spawnImpl });
-  if (!scopeCheck.valid) {
-    throw new GhAuthError(
-      "missing_scopes",
-      `gh auth refresh --scopes repo,read:org,project \uB97C \uC2E4\uD589\uD558\uC138\uC694. (missing: ${scopeCheck.missing.join(", ")})`
-    );
-  }
-  const token = getGhToken({ execImpl });
-  return { login: auth.login ?? "unknown", token };
-}
-function parseLogin(output) {
-  const matched = output.match(
-    /Logged in to github\.com account\s+\*?\*?([A-Za-z0-9_-]+)\*?\*?/i
-  );
-  return matched?.[1];
-}
-function parseScopes(output) {
-  const matched = output.match(/Token scopes:\s*(.+)/i);
-  if (!matched) {
-    return [];
-  }
-  return matched[1].split(",").map((scope) => scope.trim().replace(/^'+|'+$/g, "")).filter((scope) => scope.length > 0);
-}
-
-export {
-  REQUIRED_GH_SCOPES,
-  GhAuthError,
-  checkGhInstalled,
-  checkGhAuthenticated,
-  checkGhScopes,
-  getGhToken,
-  ensureGhAuth
-};