@harness-engineering/cli 1.8.2 → 1.10.0

package/dist/bin/harness.js

@@ -1,21 +1,55 @@
 #!/usr/bin/env node
 import {
-  CLI_VERSION,
-  createProgram,
+  createProgram
+} from "../chunk-PAHHT2IK.js";
+import "../chunk-VUCPTQ6G.js";
+import {
   findConfigFile,
   loadConfig
-} from "../chunk-Y7U5AYAL.js";
-import "../chunk-LB4GRDDV.js";
+} from "../chunk-7X7ZAYMY.js";
+import "../chunk-46YA6FI3.js";
+import "../chunk-Q6AB7W5Z.js";
+import "../chunk-TRAPF4IX.js";
+import "../chunk-F3YDAJFQ.js";
+import "../chunk-TEFCFC4H.js";
+import "../chunk-ECUJQS3B.js";
+import "../chunk-HIOXKZYF.js";
+import "../chunk-QPEH2QPG.js";
+import "../chunk-JSTQ3AWB.js";
+import "../chunk-KET4QQZB.js";
+import "../chunk-NKDM3FMH.js";
+import "../chunk-LXU5M77O.js";
+import "../chunk-CWZ4Y2PO.js";
+import "../chunk-FPIPT36X.js";
+import "../chunk-4PFMY3H7.js";
+import "../chunk-PSXF277V.js";
+import "../chunk-PMTFPOCT.js";
+import "../chunk-ZOAWBDWU.js";
+import "../chunk-FX7SQHGD.js";
+import "../chunk-OPXH4CQN.js";
+import "../chunk-MO4YQOMB.js";
+import "../chunk-K6XAPGML.js";
+import "../chunk-F4PTVZWA.js";
+import "../chunk-IDZNPTYD.js";
+import "../chunk-W6Y7ZW3Y.js";
+import "../chunk-EOLRW32Q.js";
+import {
+  handleError
+} from "../chunk-B7HFEHWP.js";
+import "../chunk-MDUK2J2O.js";
+import {
+  CLI_VERSION
+} from "../chunk-BM3PWGXQ.js";
+import "../chunk-72GHBOL2.js";
+import "../chunk-C2ERUR3L.js";
 import {
   getUpdateNotification,
   isUpdateCheckEnabled,
   readCheckState,
   shouldRunCheck,
   spawnBackgroundCheck
-} from "../chunk-SAB3VXOW.js";
-import {
-  handleError
-} from "../chunk-ULSRSP53.js";
+} from "../chunk-NX6DSZSM.js";
+import "../chunk-MHBMTPW7.js";
 
 // src/bin/update-check-hooks.ts
 var DEFAULT_INTERVAL_MS = 864e5;

package/dist/check-phase-gate-WOKIYGAM.js

@@ -0,0 +1,12 @@
+import {
+  createCheckPhaseGateCommand,
+  runCheckPhaseGate
+} from "./chunk-7X7ZAYMY.js";
+import "./chunk-HIOXKZYF.js";
+import "./chunk-B7HFEHWP.js";
+import "./chunk-NX6DSZSM.js";
+import "./chunk-MHBMTPW7.js";
+export {
+  createCheckPhaseGateCommand,
+  runCheckPhaseGate
+};

package/dist/chunk-46YA6FI3.js

@@ -0,0 +1,293 @@
+import {
+  listPersonas,
+  loadPersona
+} from "./chunk-Q6AB7W5Z.js";
+import {
+  toKebabCase
+} from "./chunk-KET4QQZB.js";
+import {
+  GENERATED_HEADER_AGENT,
+  VALID_PLATFORMS,
+  applySyncPlan,
+  computeSyncPlan
+} from "./chunk-ZOAWBDWU.js";
+import {
+  resolvePersonasDir,
+  resolveSkillsDir
+} from "./chunk-EOLRW32Q.js";
+import {
+  CLIError,
+  ExitCode,
+  handleError
+} from "./chunk-B7HFEHWP.js";
+
+// src/commands/generate-agent-definitions.ts
+import { Command } from "commander";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+// src/agent-definitions/generator.ts
+var AGENT_DESCRIPTIONS = {
+  "code-reviewer": "Perform code review and address review findings using harness methodology. Use when reviewing code, fixing review findings, responding to review feedback, or when a code review has produced issues that need to be addressed.",
+  "task-executor": "Execute implementation plans task-by-task with state tracking, TDD, and verification. Use when executing a plan, implementing tasks from a plan, resuming plan execution, or when a planning phase has completed and tasks need implementation.",
+  "parallel-coordinator": "Dispatch independent tasks across isolated agents for parallel execution. Use when multiple independent tasks need to run concurrently, splitting work across agents, or coordinating parallel implementation.",
+  "architecture-enforcer": "Validate architectural constraints and dependency rules. Use when checking layer boundaries, detecting circular dependencies, or verifying import direction compliance.",
+  "documentation-maintainer": "Keep documentation in sync with source code. Use when detecting documentation drift, validating doc coverage, or aligning docs with code changes.",
+  "entropy-cleaner": "Detect and fix codebase entropy including drift, dead code, and pattern violations. Use when running cleanup, detecting dead code, or fixing pattern violations.",
+  planner: "Create detailed implementation plans from specs with task breakdown, dependency ordering, and checkpoint placement. Use when planning a phase, breaking a spec into tasks, or creating an execution plan.",
+  verifier: "Verify implementation completeness against spec and plan at three tiers (EXISTS, SUBSTANTIVE, WIRED). Use when checking if built code matches what was planned, validating phase completion, or auditing implementation quality."
+};
+var DEFAULT_TOOLS = ["Bash", "Read", "Write", "Edit", "Glob", "Grep"];
+var GEMINI_TOOL_MAP = {
+  Bash: "run_shell_command",
+  Read: "read_file",
+  Write: "write_file",
+  Edit: "replace",
+  Glob: "glob",
+  Grep: "search_file_content"
+};
+function generateAgentDefinition(persona, skillContents) {
+  const kebabName = toKebabCase(persona.name);
+  const name = `harness-${kebabName}`;
+  const description = AGENT_DESCRIPTIONS[kebabName] ?? persona.description;
+  const methodologyParts = [];
+  for (const skillName of persona.skills) {
+    const content = skillContents.get(skillName);
+    if (content) {
+      methodologyParts.push(content);
+    }
+  }
+  return {
+    name,
+    description,
+    tools: [...DEFAULT_TOOLS],
+    role: persona.role,
+    skills: persona.skills,
+    steps: persona.steps,
+    methodology: methodologyParts.join("\n\n---\n\n")
+  };
+}
+
+// src/agent-definitions/render-claude-code.ts
+function formatStep(step, index) {
+  if ("command" in step && step.command) {
+    const cmd = step.command;
+    const when = step.when ?? "always";
+    return `${index + 1}. Run \`harness ${cmd}\` (${when})`;
+  }
+  if ("skill" in step && step.skill) {
+    const skill = step.skill;
+    const when = step.when ?? "always";
+    return `${index + 1}. Execute ${skill} skill (${when})`;
+  }
+  return `${index + 1}. Unknown step`;
+}
+function renderClaudeCodeAgent(def) {
+  const lines = ["---"];
+  lines.push(`name: ${def.name}`);
+  lines.push(`description: >`);
+  lines.push(`  ${def.description}`);
+  lines.push(`tools: ${def.tools.join(", ")}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(GENERATED_HEADER_AGENT);
+  lines.push("");
+  lines.push("## Role");
+  lines.push("");
+  lines.push(def.role);
+  lines.push("");
+  lines.push("## Skills");
+  lines.push("");
+  for (const skill of def.skills) {
+    lines.push(`- ${skill}`);
+  }
+  lines.push("");
+  lines.push("## Steps");
+  lines.push("");
+  def.steps.forEach((step, i) => {
+    lines.push(formatStep(step, i));
+  });
+  lines.push("");
+  if (def.methodology) {
+    lines.push("## Methodology");
+    lines.push("");
+    lines.push(def.methodology);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/agent-definitions/render-gemini-cli.ts
+function toGeminiToolName(tool) {
+  return GEMINI_TOOL_MAP[tool] ?? tool;
+}
+function formatStep2(step, index) {
+  if ("command" in step && step.command) {
+    const cmd = step.command;
+    const when = step.when ?? "always";
+    return `${index + 1}. Run \`harness ${cmd}\` (${when})`;
+  }
+  if ("skill" in step && step.skill) {
+    const skill = step.skill;
+    const when = step.when ?? "always";
+    return `${index + 1}. Execute ${skill} skill (${when})`;
+  }
+  return `${index + 1}. Unknown step`;
+}
+function renderGeminiAgent(def) {
+  const lines = ["---"];
+  lines.push(`name: ${def.name}`);
+  lines.push(`description: >`);
+  lines.push(`  ${def.description}`);
+  if (def.tools.length > 0) {
+    lines.push("tools:");
+    for (const tool of def.tools) {
+      lines.push(`  - ${toGeminiToolName(tool)}`);
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(GENERATED_HEADER_AGENT);
+  lines.push("");
+  lines.push("## Role");
+  lines.push("");
+  lines.push(def.role);
+  lines.push("");
+  lines.push("## Skills");
+  lines.push("");
+  for (const skill of def.skills) {
+    lines.push(`- ${skill}`);
+  }
+  lines.push("");
+  lines.push("## Steps");
+  lines.push("");
+  def.steps.forEach((step, i) => {
+    lines.push(formatStep2(step, i));
+  });
+  lines.push("");
+  if (def.methodology) {
+    lines.push("## Methodology");
+    lines.push("");
+    lines.push(def.methodology);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/commands/generate-agent-definitions.ts
+function resolveOutputDir(platform, opts) {
+  if (opts.output) {
+    return platform === "claude-code" ? path.join(opts.output, "claude-code") : path.join(opts.output, "gemini-cli");
+  }
+  if (opts.global) {
+    const home = os.homedir();
+    return platform === "claude-code" ? path.join(home, ".claude", "agents") : path.join(home, ".gemini", "agents");
+  }
+  return platform === "claude-code" ? path.join("agents", "agents", "claude-code") : path.join("agents", "agents", "gemini-cli");
+}
+function loadSkillContent(skillName) {
+  const skillsDir = resolveSkillsDir();
+  const skillMdPath = path.join(skillsDir, skillName, "SKILL.md");
+  if (!fs.existsSync(skillMdPath)) return null;
+  return fs.readFileSync(skillMdPath, "utf-8");
+}
+function getRenderer(platform) {
+  return platform === "claude-code" ? renderClaudeCodeAgent : renderGeminiAgent;
+}
+function generateAgentDefinitions(opts) {
+  const personasDir = resolvePersonasDir();
+  const personaList = listPersonas(personasDir);
+  if (!personaList.ok) return [];
+  const personas = personaList.value.map((meta) => loadPersona(meta.filePath)).filter((r) => r.ok).map((r) => r.value);
+  const allSkillNames = new Set(personas.flatMap((p) => p.skills));
+  const skillContents = /* @__PURE__ */ new Map();
+  for (const skillName of allSkillNames) {
+    const content = loadSkillContent(skillName);
+    if (content) {
+      skillContents.set(skillName, content);
+    }
+  }
+  const definitions = personas.map((p) => generateAgentDefinition(p, skillContents));
+  const results = [];
+  for (const platform of opts.platforms) {
+    const outputDir = resolveOutputDir(platform, opts);
+    const renderer = getRenderer(platform);
+    const rendered = /* @__PURE__ */ new Map();
+    for (const def of definitions) {
+      const filename = `${def.name}.md`;
+      rendered.set(filename, renderer(def));
+    }
+    const plan = computeSyncPlan(outputDir, rendered);
+    if (!opts.dryRun) {
+      applySyncPlan(outputDir, rendered, plan, false);
+    }
+    results.push({
+      platform,
+      added: plan.added,
+      updated: plan.updated,
+      removed: plan.removed,
+      unchanged: plan.unchanged,
+      outputDir
+    });
+  }
+  return results;
+}
+function createGenerateAgentDefinitionsCommand() {
+  return new Command("generate-agent-definitions").description("Generate agent definition files from personas for Claude Code and Gemini CLI").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global agent directories", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const platforms = opts.platforms.split(",").map((p) => p.trim());
+    for (const p of platforms) {
+      if (!VALID_PLATFORMS.includes(p)) {
+        throw new CLIError(
+          `Invalid platform "${p}". Valid platforms: ${VALID_PLATFORMS.join(", ")}`,
+          ExitCode.VALIDATION_FAILED
+        );
+      }
+    }
+    try {
+      const results = generateAgentDefinitions({
+        platforms,
+        global: opts.global,
+        output: opts.output,
+        dryRun: opts.dryRun
+      });
+      if (globalOpts.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+      }
+      for (const result of results) {
+        console.log(`
+${result.platform} \u2192 ${result.outputDir}`);
+        if (result.added.length > 0) {
+          console.log(`  + ${result.added.length} new: ${result.added.join(", ")}`);
+        }
+        if (result.updated.length > 0) {
+          console.log(`  ~ ${result.updated.length} updated: ${result.updated.join(", ")}`);
+        }
+        if (result.removed.length > 0) {
+          console.log(`  - ${result.removed.length} removed: ${result.removed.join(", ")}`);
+        }
+        if (result.unchanged.length > 0) {
+          console.log(`  = ${result.unchanged.length} unchanged`);
+        }
+        if (opts.dryRun) {
+          console.log("  (dry run \u2014 no files written)");
+        }
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+export {
+  AGENT_DESCRIPTIONS,
+  DEFAULT_TOOLS,
+  GEMINI_TOOL_MAP,
+  generateAgentDefinition,
+  renderClaudeCodeAgent,
+  renderGeminiAgent,
+  generateAgentDefinitions,
+  createGenerateAgentDefinitionsCommand
+};

package/dist/chunk-4PFMY3H7.js

@@ -0,0 +1,248 @@
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+
+// src/mcp/tools/feedback.ts
+var createSelfReviewDefinition = {
+  name: "create_self_review",
+  description: "Generate a checklist-based code review from a git diff, checking harness constraints, custom rules, and diff patterns",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      diff: { type: "string", description: "Git diff string to review" },
+      customRules: {
+        type: "array",
+        items: { type: "object" },
+        description: "Optional custom rules to apply during review"
+      },
+      maxFileSize: {
+        type: "number",
+        description: "Maximum number of lines changed per file before flagging"
+      },
+      maxFileCount: {
+        type: "number",
+        description: "Maximum number of changed files before flagging"
+      }
+    },
+    required: ["path", "diff"]
+  }
+};
+async function handleCreateSelfReview(input) {
+  try {
+    const { parseDiff, createSelfReview } = await import("./dist-PBTNVK6K.js");
+    const parseResult = parseDiff(input.diff);
+    if (!parseResult.ok) {
+      return resultToMcpResponse(parseResult);
+    }
+    const projectPath = sanitizePath(input.path);
+    const config = {
+      rootDir: projectPath,
+      harness: {
+        context: true,
+        constraints: true,
+        entropy: true
+      },
+      ...input.customRules ? { customRules: input.customRules } : {},
+      diffAnalysis: {
+        enabled: true,
+        ...input.maxFileSize !== void 0 ? { maxFileSize: input.maxFileSize } : {},
+        ...input.maxFileCount !== void 0 ? { maxChangedFiles: input.maxFileCount } : {}
+      }
+    };
+    const { loadGraphStore } = await import("./graph-loader-RLO3KRIX.js");
+    const store = await loadGraphStore(projectPath);
+    let graphData;
+    if (store) {
+      const { GraphFeedbackAdapter } = await import("./dist-I7DB5VKB.js");
+      const adapter = new GraphFeedbackAdapter(store);
+      const changedFiles = parseResult.value.files.map((f) => f.path);
+      const impact = adapter.computeImpactData(changedFiles);
+      const harness = adapter.computeHarnessCheckData();
+      graphData = {
+        impact: {
+          affectedTests: [...impact.affectedTests],
+          affectedDocs: [...impact.affectedDocs],
+          impactScope: impact.impactScope
+        },
+        harness: { ...harness }
+      };
+    }
+    const result = await createSelfReview(
+      parseResult.value,
+      config,
+      graphData
+    );
+    return resultToMcpResponse(result);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var analyzeDiffDefinition = {
+  name: "analyze_diff",
+  description: "Parse a git diff and check for forbidden patterns, oversized files, and missing test coverage",
+  inputSchema: {
+    type: "object",
+    properties: {
+      diff: { type: "string", description: "Git diff string to analyze" },
+      path: {
+        type: "string",
+        description: "Path to project root (enables graph-enhanced analysis)"
+      },
+      forbiddenPatterns: {
+        type: "array",
+        items: { type: "string" },
+        description: "List of regex patterns that are forbidden in the diff"
+      },
+      maxFileSize: {
+        type: "number",
+        description: "Maximum number of lines changed per file before flagging"
+      },
+      maxFileCount: {
+        type: "number",
+        description: "Maximum number of changed files before flagging"
+      }
+    },
+    required: ["diff"]
+  }
+};
+async function handleAnalyzeDiff(input) {
+  try {
+    const { parseDiff, analyzeDiff } = await import("./dist-PBTNVK6K.js");
+    const parseResult = parseDiff(input.diff);
+    if (!parseResult.ok) {
+      return resultToMcpResponse(parseResult);
+    }
+    const options = {
+      enabled: true,
+      ...input.forbiddenPatterns ? {
+        forbiddenPatterns: input.forbiddenPatterns.map((pattern) => ({
+          pattern,
+          message: `Forbidden pattern matched: ${pattern}`,
+          severity: "warning"
+        }))
+      } : {},
+      ...input.maxFileSize !== void 0 ? { maxFileSize: input.maxFileSize } : {},
+      ...input.maxFileCount !== void 0 ? { maxChangedFiles: input.maxFileCount } : {}
+    };
+    let graphImpactData;
+    if (input.path) {
+      try {
+        const { loadGraphStore } = await import("./graph-loader-RLO3KRIX.js");
+        const store = await loadGraphStore(sanitizePath(input.path));
+        if (store) {
+          const { GraphFeedbackAdapter } = await import("./dist-I7DB5VKB.js");
+          const adapter = new GraphFeedbackAdapter(store);
+          const changedFiles = parseResult.value.files.map((f) => f.path);
+          const impact = adapter.computeImpactData(changedFiles);
+          graphImpactData = {
+            affectedTests: [...impact.affectedTests],
+            affectedDocs: [...impact.affectedDocs],
+            impactScope: impact.impactScope
+          };
+        }
+      } catch {
+      }
+    }
+    const result = await analyzeDiff(parseResult.value, options, graphImpactData);
+    return resultToMcpResponse(result);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var requestPeerReviewDefinition = {
+  name: "request_peer_review",
+  description: "Spawn an agent subprocess to perform code review. Returns structured feedback with approval status. Timeout: 120 seconds.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      agentType: {
+        type: "string",
+        enum: [
+          "architecture-enforcer",
+          "documentation-maintainer",
+          "test-reviewer",
+          "entropy-cleaner",
+          "custom"
+        ],
+        description: "Type of agent to use for the peer review"
+      },
+      diff: { type: "string", description: "Git diff string to review" },
+      context: { type: "string", description: "Optional additional context for the reviewer" }
+    },
+    required: ["path", "agentType", "diff"]
+  }
+};
+async function handleRequestPeerReview(input) {
+  try {
+    const { parseDiff, requestPeerReview } = await import("./dist-PBTNVK6K.js");
+    const parseResult = parseDiff(input.diff);
+    if (!parseResult.ok) {
+      return resultToMcpResponse(parseResult);
+    }
+    const reviewContext = {
+      files: parseResult.value.files.map((f) => f.path),
+      diff: input.diff,
+      ...input.context ? { metadata: { context: input.context } } : {}
+    };
+    try {
+      const { loadGraphStore } = await import("./graph-loader-RLO3KRIX.js");
+      const store = await loadGraphStore(sanitizePath(input.path));
+      if (store) {
+        const { GraphFeedbackAdapter } = await import("./dist-I7DB5VKB.js");
+        const adapter = new GraphFeedbackAdapter(store);
+        const changedFiles = parseResult.value.files.map((f) => f.path);
+        const impactData = adapter.computeImpactData(changedFiles);
+        reviewContext.metadata = {
+          ...reviewContext.metadata,
+          graphContext: impactData
+        };
+      }
+    } catch {
+    }
+    const result = await requestPeerReview(input.agentType, reviewContext, {
+      timeout: 12e4,
+      wait: true
+    });
+    return resultToMcpResponse(result);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  createSelfReviewDefinition,
+  handleCreateSelfReview,
+  analyzeDiffDefinition,
+  handleAnalyzeDiff,
+  requestPeerReviewDefinition,
+  handleRequestPeerReview
+};

package/dist/{chunk-LB4GRDDV.js → chunk-72GHBOL2.js}

@@ -1,6 +1,6 @@
 import {
   Ok
-} from "./chunk-SAB3VXOW.js";
+} from "./chunk-MHBMTPW7.js";
 
 // src/commands/validate-cross-check.ts
 import * as fs from "fs";