@caseyharalson/orrery 0.7.1

package/lib/orchestration/review-invoker.js

@@ -0,0 +1,305 @@
+const { invokeAgentWithFailover } = require("./agent-invoker");
+
+function formatStepContext(stepContext) {
+  if (stepContext === undefined || stepContext === null) {
+    return "(no step context provided)";
+  }
+
+  if (typeof stepContext === "string") {
+    const trimmed = stepContext.trim();
+    return trimmed.length > 0 ? trimmed : "(no step context provided)";
+  }
+
+  try {
+    return JSON.stringify(stepContext, null, 2);
+  } catch {
+    return String(stepContext);
+  }
+}
+
+function formatFiles(files) {
+  if (!files) {
+    return "(no files provided)";
+  }
+
+  if (Array.isArray(files)) {
+    if (files.length === 0) {
+      return "(no files provided)";
+    }
+    return files.map((file) => `- ${file}`).join("\n");
+  }
+
+  const trimmed = String(files).trim();
+  return trimmed.length > 0 ? trimmed : "(no files provided)";
+}
+
+function ensureFullFileInstruction(prompt) {
+  const fullFileRegex = /full file|full files|full contents/i;
+  if (fullFileRegex.test(prompt)) {
+    return prompt;
+  }
+
+  const instruction =
+    "Read the full contents of each modified file for context, not only the diff.";
+  return `${prompt}\n\n## Required Context\n${instruction}`;
+}
+
+function buildReviewPrompt(template, stepContext, files, diff) {
+  const basePrompt = String(template || "");
+  const promptWithContext = basePrompt
+    .replace("{stepContext}", formatStepContext(stepContext))
+    .replace("{files}", formatFiles(files))
+    .replace("{diff}", diff ? String(diff) : "(no diff provided)");
+
+  return ensureFullFileInstruction(promptWithContext);
+}
+
+function buildReviewConfig(config, prompt) {
+  const agents = {};
+
+  for (const [name, agentConfig] of Object.entries(config.agents || {})) {
+    const args = Array.isArray(agentConfig.args)
+      ? agentConfig.args.slice()
+      : [];
+    if (args.length > 0) {
+      args[args.length - 1] = prompt;
+    }
+    agents[name] = {
+      ...agentConfig,
+      args
+    };
+  }
+
+  return {
+    ...config,
+    agents
+  };
+}
+
+function extractBalancedJson(str, start, openChar = "{", closeChar = "}") {
+  if (str[start] !== openChar) return null;
+
+  let depth = 0;
+  let inString = false;
+  let escapeNext = false;
+
+  for (let i = start; i < str.length; i++) {
+    const char = str[i];
+
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+
+    if (char === "\\" && inString) {
+      escapeNext = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (!inString) {
+      if (char === openChar) {
+        depth++;
+      } else if (char === closeChar) {
+        depth--;
+        if (depth === 0) {
+          return str.slice(start, i + 1);
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function extractJsonPayload(stdout) {
+  if (!stdout) {
+    return null;
+  }
+
+  const codeBlockPattern = /```(?:json)?\s*([\s\S]*?)```/g;
+  let match;
+  while ((match = codeBlockPattern.exec(stdout)) !== null) {
+    const content = match[1].trim();
+    try {
+      return JSON.parse(content);
+    } catch {
+      continue;
+    }
+  }
+
+  for (let i = 0; i < stdout.length; i++) {
+    if (stdout[i] === "{") {
+      const jsonObj = extractBalancedJson(stdout, i, "{", "}");
+      if (jsonObj) {
+        try {
+          return JSON.parse(jsonObj);
+        } catch {
+          // continue scanning
+        }
+        i += jsonObj.length - 1;
+      }
+    } else if (stdout[i] === "[") {
+      const jsonArr = extractBalancedJson(stdout, i, "[", "]");
+      if (jsonArr) {
+        try {
+          return JSON.parse(jsonArr);
+        } catch {
+          // continue scanning
+        }
+        i += jsonArr.length - 1;
+      }
+    }
+  }
+
+  return null;
+}
+
+function normalizeStatus(status) {
+  if (!status || typeof status !== "string") {
+    return null;
+  }
+
+  const normalized = status.trim().toLowerCase();
+  if (normalized === "approved") {
+    return "approved";
+  }
+  if (normalized === "needs_changes" || normalized === "changes_requested") {
+    return "needs_changes";
+  }
+
+  return null;
+}
+
+function normalizeFeedbackEntry(entry) {
+  if (!entry) {
+    return null;
+  }
+
+  if (typeof entry === "string") {
+    return {
+      comment: entry,
+      severity: "suggestion"
+    };
+  }
+
+  if (typeof entry !== "object") {
+    return null;
+  }
+
+  const comment =
+    typeof entry.comment === "string"
+      ? entry.comment
+      : String(entry.comment || "");
+  if (!comment) {
+    return null;
+  }
+
+  const output = {
+    comment,
+    severity: entry.severity === "blocking" ? "blocking" : "suggestion"
+  };
+
+  if (typeof entry.file === "string" && entry.file.trim()) {
+    output.file = entry.file.trim();
+  }
+
+  if (Number.isFinite(entry.line)) {
+    output.line = entry.line;
+  }
+
+  return output;
+}
+
+function normalizeFeedback(feedback) {
+  if (!Array.isArray(feedback)) {
+    return [];
+  }
+
+  return feedback.map(normalizeFeedbackEntry).filter(Boolean);
+}
+
+function parseReviewResults(stdout) {
+  try {
+    const payload = extractJsonPayload(stdout);
+    if (!payload) {
+      return {
+        approved: true,
+        feedback: [],
+        error: "No JSON review output detected"
+      };
+    }
+
+    const data = Array.isArray(payload) ? payload[0] : payload;
+    if (!data || typeof data !== "object") {
+      return {
+        approved: true,
+        feedback: [],
+        error: "Review output was not a JSON object"
+      };
+    }
+
+    const status = normalizeStatus(data.status);
+    if (!status) {
+      return {
+        approved: true,
+        feedback: [],
+        error: `Unrecognized review status: ${data.status}`
+      };
+    }
+
+    const feedback = normalizeFeedback(data.feedback || data.comments);
+    return {
+      approved: status === "approved",
+      feedback
+    };
+  } catch (error) {
+    return {
+      approved: true,
+      feedback: [],
+      error: error.message || "Failed to parse review output"
+    };
+  }
+}
+
+async function invokeReviewAgent(
+  config,
+  stepContext,
+  files,
+  diff,
+  repoRoot,
+  options = {}
+) {
+  const promptTemplate =
+    (config && config.review && config.review.prompt) ||
+    config.REVIEW_PROMPT ||
+    "";
+  const prompt = buildReviewPrompt(promptTemplate, stepContext, files, diff);
+  const reviewConfig = buildReviewConfig(config, prompt);
+  const planFile = options.planFile || options.planPath || "review";
+  const stepIds = options.stepIds
+    ? options.stepIds
+    : options.stepId
+      ? [options.stepId]
+      : ["review"];
+
+  const handle = invokeAgentWithFailover(
+    reviewConfig,
+    planFile,
+    stepIds,
+    repoRoot,
+    options
+  );
+
+  const result = await handle.completion;
+  return parseReviewResults(result.stdout || "");
+}
+
+module.exports = {
+  invokeReviewAgent,
+  parseReviewResults
+};

package/lib/utils/agent-detector.js

@@ -0,0 +1,47 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const AGENT_DIRS = {
+  claude: ".claude",
+  codex: ".codex",
+  gemini: ".gemini"
+};
+
+function isDirectory(dirPath) {
+  try {
+    return fs.statSync(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function detectInstalledAgents() {
+  const homeDir = os.homedir();
+  if (!homeDir) {
+    return [];
+  }
+
+  return Object.entries(AGENT_DIRS)
+    .filter(([, dirName]) => isDirectory(path.join(homeDir, dirName)))
+    .map(([agentName]) => agentName);
+}
+
+function getAgentSkillsDir(agent) {
+  if (!agent) {
+    return null;
+  }
+
+  const agentKey = agent.toLowerCase();
+  const dirName = AGENT_DIRS[agentKey];
+  if (!dirName) {
+    return null;
+  }
+
+  return path.join(os.homedir(), dirName, "skills");
+}
+
+module.exports = {
+  detectInstalledAgents,
+  getAgentSkillsDir
+};

package/lib/utils/git.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+
+const { execSync } = require("child_process");
+
+/**
+ * Git helper functions for branch management and PR creation
+ */
+
+/**
+ * Execute a git command and return the output
+ * @param {string} command - Git command (without 'git' prefix)
+ * @param {string} cwd - Working directory
+ * @returns {string} - Command output (trimmed)
+ */
+function git(command, cwd) {
+  try {
+    return execSync(`git ${command}`, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch (error) {
+    // Return stderr if available, otherwise throw
+    if (error.stderr) {
+      throw new Error(`git ${command} failed: ${error.stderr.trim()}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Get the current branch name
+ * @param {string} cwd - Working directory
+ * @returns {string} - Current branch name
+ */
+function getCurrentBranch(cwd) {
+  return git("rev-parse --abbrev-ref HEAD", cwd);
+}
+
+/**
+ * Check if a branch exists (locally or remotely)
+ * @param {string} branchName - Branch name to check
+ * @param {string} cwd - Working directory
+ * @returns {boolean} - True if branch exists
+ */
+function branchExists(branchName, cwd) {
+  try {
+    git(`rev-parse --verify ${branchName}`, cwd);
+    return true;
+  } catch {
+    // Also check remote
+    try {
+      git(`rev-parse --verify origin/${branchName}`, cwd);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+/**
+ * Create a new branch from current HEAD
+ * @param {string} branchName - Name for the new branch
+ * @param {string} cwd - Working directory
+ */
+function createBranch(branchName, cwd) {
+  git(`checkout -b ${branchName}`, cwd);
+}
+
+/**
+ * Switch to an existing branch
+ * @param {string} branchName - Branch to switch to
+ * @param {string} cwd - Working directory
+ */
+function checkoutBranch(branchName, cwd) {
+  git(`checkout ${branchName}`, cwd);
+}
+
+/**
+ * Stage and commit changes
+ * @param {string} message - Commit message
+ * @param {string[]} files - Files to stage (empty array = all changes)
+ * @param {string} cwd - Working directory
+ * @returns {string} - Commit hash
+ */
+function commit(message, files, cwd) {
+  if (files && files.length > 0) {
+    git(`add ${files.map((f) => `"${f}"`).join(" ")}`, cwd);
+  } else {
+    git("add -A", cwd);
+  }
+
+  // Check if there are changes to commit
+  try {
+    git("diff --cached --quiet", cwd);
+    // No changes to commit
+    return null;
+  } catch {
+    // There are changes, proceed with commit
+  }
+
+  git(`commit -m "${message.replace(/"/g, '\\"')}"`, cwd);
+  return git("rev-parse HEAD", cwd);
+}
+
+/**
+ * Push current branch to origin
+ * @param {string} cwd - Working directory
+ * @param {boolean} setUpstream - Whether to set upstream tracking
+ */
+function push(cwd, setUpstream = true) {
+  const branch = getCurrentBranch(cwd);
+  if (setUpstream) {
+    git(`push -u origin ${branch}`, cwd);
+  } else {
+    git("push", cwd);
+  }
+}
+
+/**
+ * Get the GitHub repository URL from git remote
+ * @param {string} cwd - Working directory
+ * @returns {string|null} - GitHub HTTPS URL or null if not found
+ */
+function getGitHubRepoUrl(cwd) {
+  try {
+    const remoteUrl = git("remote get-url origin", cwd);
+    if (!remoteUrl) return null;
+
+    // Convert SSH or git URLs to HTTPS
+    let url = remoteUrl.trim();
+
+    // git@github.com:owner/repo.git -> https://github.com/owner/repo
+    if (url.startsWith("git@")) {
+      const match = url.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+      if (match) {
+        url = `https://${match[1]}/${match[2]}`;
+      }
+    }
+
+    // Remove .git suffix
+    url = url.replace(/\.git$/, "");
+
+    // Remove git+ prefix
+    url = url.replace(/^git\+/, "");
+
+    return url;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generate PR creation info (URL and details) without requiring gh CLI
+ * @param {string} title - PR title
+ * @param {string} body - PR body/description
+ * @param {string} baseBranch - Target branch for the PR
+ * @param {string} cwd - Working directory
+ * @returns {{url: string, title: string, body: string, headBranch: string, baseBranch: string, pushed: boolean}} - PR info
+ */
+function createPullRequest(title, body, baseBranch, cwd) {
+  const headBranch = getCurrentBranch(cwd);
+  let pushed = false;
+
+  // Try to push the branch
+  try {
+    push(cwd, true);
+    pushed = true;
+  } catch {
+    // May fail if no remote configured - continue anyway
+  }
+
+  const repoUrl = getGitHubRepoUrl(cwd);
+  let prUrl = "";
+
+  if (repoUrl) {
+    // GitHub PR creation URL format
+    const encodedTitle = encodeURIComponent(title);
+    const encodedBody = encodeURIComponent(body);
+    prUrl = `${repoUrl}/compare/${baseBranch}...${headBranch}?expand=1&title=${encodedTitle}&body=${encodedBody}`;
+  }
+
+  return {
+    url: prUrl,
+    title,
+    body,
+    headBranch,
+    baseBranch,
+    pushed
+  };
+}
+
+/**
+ * Check if there are uncommitted changes
+ * @param {string} cwd - Working directory
+ * @returns {boolean} - True if there are uncommitted changes
+ */
+function hasUncommittedChanges(cwd) {
+  try {
+    git("diff --quiet", cwd);
+    git("diff --cached --quiet", cwd);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+/**
+ * Get the diff for uncommitted changes (staged and unstaged)
+ * @param {string} cwd - Working directory
+ * @param {string[]} [files] - Optional file list to filter diff
+ * @returns {string} - Diff output or empty string if none
+ */
+function getUncommittedDiff(cwd, files) {
+  try {
+    if (!hasUncommittedChanges(cwd)) {
+      return "";
+    }
+
+    const fileArgs =
+      Array.isArray(files) && files.length > 0
+        ? ` -- ${files.map((file) => `"${file}"`).join(" ")}`
+        : "";
+
+    const workingTreeDiff = git(`diff${fileArgs}`, cwd);
+    const stagedDiff = git(`diff --cached${fileArgs}`, cwd);
+    const combined = [workingTreeDiff, stagedDiff].filter(Boolean).join("\n");
+
+    return combined.trim();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Derive a branch name from a plan filename
+ * @param {string} planFileName - Plan filename (e.g., "2026-01-11-add-dummy-script.yaml")
+ * @returns {string} - Branch name (e.g., "plan/add-dummy-script")
+ */
+function deriveBranchName(planFileName) {
+  // Remove .yaml/.yml extension
+  let name = planFileName.replace(/\.ya?ml$/, "");
+
+  // Remove date prefix if present (YYYY-MM-DD-)
+  name = name.replace(/^\d{4}-\d{2}-\d{2}-/, "");
+
+  // Sanitize for git branch name
+  name = name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+
+  return `plan/${name}`;
+}
+
+/**
+ * Stash any uncommitted changes
+ * @param {string} cwd - Working directory
+ * @returns {boolean} - True if changes were stashed
+ */
+function stash(cwd) {
+  if (!hasUncommittedChanges(cwd)) {
+    return false;
+  }
+  git("stash push -m 'orchestrator-auto-stash'", cwd);
+  return true;
+}
+
+/**
+ * Pop the most recent stash
+ * @param {string} cwd - Working directory
+ */
+function stashPop(cwd) {
+  try {
+    git("stash pop", cwd);
+  } catch {
+    // No stash to pop or conflict - ignore
+  }
+}
+
+module.exports = {
+  git,
+  getCurrentBranch,
+  branchExists,
+  createBranch,
+  checkoutBranch,
+  commit,
+  push,
+  createPullRequest,
+  getGitHubRepoUrl,
+  hasUncommittedChanges,
+  getUncommittedDiff,
+  deriveBranchName,
+  stash,
+  stashPop
+};

package/lib/utils/paths.js

@@ -0,0 +1,43 @@
+const fs = require("fs");
+const path = require("path");
+
+const WORK_DIR_ENV = "ORRERY_WORK_DIR";
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  return dirPath;
+}
+
+function getWorkDir() {
+  const envDir = process.env[WORK_DIR_ENV];
+  if (envDir && envDir.trim()) {
+    return ensureDir(envDir.trim());
+  }
+  return ensureDir(path.join(process.cwd(), ".agent-work"));
+}
+
+function getPlansDir() {
+  return ensureDir(path.join(getWorkDir(), "plans"));
+}
+
+function getCompletedDir() {
+  return ensureDir(path.join(getWorkDir(), "completed"));
+}
+
+function getReportsDir() {
+  return ensureDir(path.join(getWorkDir(), "reports"));
+}
+
+function getTempDir() {
+  return ensureDir(path.join(getWorkDir(), "temp"));
+}
+
+module.exports = {
+  getWorkDir,
+  getPlansDir,
+  getCompletedDir,
+  getReportsDir,
+  getTempDir
+};

package/lib/utils/plan-detect.js

@@ -0,0 +1,24 @@
+const { getCurrentBranch } = require("./git");
+const { getPlanFiles, loadPlan } = require("../orchestration/plan-loader");
+const { getPlansDir } = require("./paths");
+
+/**
+ * Find a plan that matches the current branch's work_branch metadata.
+ * Used for auto-detection when on a work branch.
+ * @returns {{planFile: string, plan: Object}|null} - The matching plan or null
+ */
+function findPlanForCurrentBranch() {
+  const currentBranch = getCurrentBranch(process.cwd());
+  const plansDir = getPlansDir();
+  const planFiles = getPlanFiles(plansDir);
+
+  for (const planFile of planFiles) {
+    const plan = loadPlan(planFile);
+    if (plan.metadata.work_branch === currentBranch) {
+      return { planFile, plan };
+    }
+  }
+  return null;
+}
+
+module.exports = { findPlanForCurrentBranch };