@harness-engineering/cli 1.9.0 → 1.11.0

package/dist/chunk-IDZNPTYD.js

@@ -0,0 +1,16 @@
+// src/mcp/utils/result-adapter.ts
+function resultToMcpResponse(result) {
+  if (result.ok) {
+    return {
+      content: [{ type: "text", text: JSON.stringify(result.value) }]
+    };
+  }
+  return {
+    content: [{ type: "text", text: result.error.message }],
+    isError: true
+  };
+}
+
+export {
+  resultToMcpResponse
+};

package/dist/chunk-JSTQ3AWB.js

@@ -0,0 +1,31 @@
+import {
+  toKebabCase
+} from "./chunk-KET4QQZB.js";
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/persona/generators/runtime.ts
+function generateRuntime(persona) {
+  try {
+    const config = {
+      name: toKebabCase(persona.name),
+      skills: persona.skills,
+      steps: persona.steps,
+      timeout: persona.config.timeout,
+      severity: persona.config.severity
+    };
+    return Ok(JSON.stringify(config, null, 2));
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to generate runtime config: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+export {
+  generateRuntime
+};

package/dist/chunk-K6XAPGML.js

@@ -0,0 +1,27 @@
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/mcp/utils/config-resolver.ts
+import * as fs from "fs";
+import * as path from "path";
+function resolveProjectConfig(projectPath) {
+  const configPath = path.join(projectPath, "harness.config.json");
+  if (!fs.existsSync(configPath)) {
+    return Err(new Error(`No harness.config.json found in ${projectPath}`));
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    return Ok(config);
+  } catch (error) {
+    return Err(
+      new Error(`Failed to parse config: ${error instanceof Error ? error.message : String(error)}`)
+    );
+  }
+}
+
+export {
+  resolveProjectConfig
+};

package/dist/chunk-KET4QQZB.js

@@ -0,0 +1,8 @@
+// src/utils/string.ts
+function toKebabCase(name) {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+
+export {
+  toKebabCase
+};

package/dist/chunk-L2KLU56K.js

@@ -0,0 +1,125 @@
+import {
+  resolveSkillsDir
+} from "./chunk-HD4IBGLA.js";
+import {
+  SkillMetadataSchema
+} from "./chunk-VRFZWGMS.js";
+
+// src/persona/skill-executor.ts
+import * as fs from "fs";
+import * as path from "path";
+import { parse } from "yaml";
+function resolveOutputMode(mode, trigger) {
+  if (mode !== "auto") return mode;
+  return trigger === "manual" ? "inline" : "artifact";
+}
+function buildArtifactPath(projectPath, headSha) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const sha = headSha?.slice(0, 7) ?? "unknown";
+  return path.join(projectPath, ".harness", "reviews", `${date}-${sha}.md`);
+}
+function buildArtifactContent(skillName, trigger, headSha) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return [
+    "---",
+    `skill: ${skillName}`,
+    `trigger: ${trigger}`,
+    `sha: ${headSha?.slice(0, 7) ?? "unknown"}`,
+    `date: ${date}`,
+    `assessment: pending`,
+    "---",
+    "",
+    `# Review by ${skillName}`,
+    "",
+    "## Strengths",
+    "",
+    "- (review pending)",
+    "",
+    "## Issues",
+    "",
+    "### Critical",
+    "",
+    "- None identified",
+    "",
+    "### Important",
+    "",
+    "- None identified",
+    "",
+    "### Suggestions",
+    "",
+    "- None identified",
+    "",
+    "## Assessment",
+    "",
+    "Pending \u2014 skill execution scaffolded.",
+    "",
+    "## Harness Checks",
+    "",
+    "- (run harness validate, check-deps, check-docs to populate)",
+    ""
+  ].join("\n");
+}
+async function executeSkill(skillName, context) {
+  const startTime = Date.now();
+  const skillsDir = resolveSkillsDir();
+  const skillDir = path.join(skillsDir, skillName);
+  if (!fs.existsSync(skillDir)) {
+    return {
+      status: "fail",
+      output: `Skill not found: ${skillName}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const yamlPath = path.join(skillDir, "skill.yaml");
+  if (!fs.existsSync(yamlPath)) {
+    return {
+      status: "fail",
+      output: `skill.yaml not found for ${skillName}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const raw = fs.readFileSync(yamlPath, "utf-8");
+  const parsed = parse(raw);
+  const metadataResult = SkillMetadataSchema.safeParse(parsed);
+  if (!metadataResult.success) {
+    return {
+      status: "fail",
+      output: `Invalid skill metadata: ${metadataResult.error.message}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const skillMdPath = path.join(skillDir, "SKILL.md");
+  if (!fs.existsSync(skillMdPath)) {
+    return {
+      status: "fail",
+      output: `SKILL.md not found for ${skillName}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const skillContent = fs.readFileSync(skillMdPath, "utf-8");
+  const metadata = metadataResult.data;
+  const resolvedMode = resolveOutputMode(context.outputMode, context.trigger);
+  const output = `Skill ${metadata.name} (${metadata.type}) loaded.
+Cognitive mode: ${metadata.cognitive_mode ?? "default"}
+Content length: ${skillContent.length} chars
+Trigger: ${context.trigger}
+`;
+  let artifactPath;
+  if (resolvedMode === "artifact") {
+    artifactPath = buildArtifactPath(context.projectPath, context.headSha);
+    const artifactContent = buildArtifactContent(skillName, context.trigger, context.headSha);
+    const dir = path.dirname(artifactPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(artifactPath, artifactContent, "utf-8");
+  }
+  return {
+    status: "pass",
+    output,
+    ...artifactPath ? { artifactPath } : {},
+    durationMs: Date.now() - startTime
+  };
+}
+
+export {
+  executeSkill
+};

package/dist/chunk-MHBMTPW7.js

@@ -0,0 +1,29 @@
+// ../types/dist/index.mjs
+function Ok(value) {
+  return { ok: true, value };
+}
+function Err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+var STANDARD_COGNITIVE_MODES = [
+  "adversarial-reviewer",
+  "constructive-architect",
+  "meticulous-implementer",
+  "diagnostic-investigator",
+  "advisory-guide",
+  "meticulous-verifier"
+];
+
+export {
+  Ok,
+  Err,
+  isOk,
+  isErr,
+  STANDARD_COGNITIVE_MODES
+};

package/dist/chunk-NC6PXVWT.js

@@ -0,0 +1,116 @@
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+import {
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/mcp/tools/docs.ts
+import * as path from "path";
+var checkDocsDefinition = {
+  name: "check_docs",
+  description: "Analyze documentation coverage and/or validate knowledge map integrity",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      domain: { type: "string", description: "Domain/module to check" },
+      scope: {
+        type: "string",
+        enum: ["coverage", "integrity", "all"],
+        description: "Scope of check: 'coverage' (doc coverage), 'integrity' (knowledge map validation), 'all' (both). Default: 'coverage'"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleCheckDocs(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const scope = input.scope ?? "coverage";
+    if (scope === "integrity") {
+      const { validateKnowledgeMap } = await import("./dist-JVZ2MKBC.js");
+      const result2 = await validateKnowledgeMap(projectPath);
+      return resultToMcpResponse(result2);
+    }
+    if (scope === "all") {
+      const { checkDocCoverage: checkDocCoverage2, validateKnowledgeMap } = await import("./dist-JVZ2MKBC.js");
+      const domain2 = input.domain ?? "src";
+      const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-KO4GJ5N2.js");
+      const store2 = await loadGraphStore2(projectPath);
+      let graphCoverage2;
+      if (store2) {
+        const { Assembler } = await import("./dist-M6BQODWC.js");
+        const assembler = new Assembler(store2);
+        const report = assembler.checkCoverage();
+        graphCoverage2 = {
+          documented: [...report.documented],
+          undocumented: [...report.undocumented],
+          coveragePercentage: report.coveragePercentage
+        };
+      }
+      const [coverageResult, integrityResult] = await Promise.allSettled([
+        checkDocCoverage2(domain2, {
+          sourceDir: path.resolve(projectPath, "src"),
+          docsDir: path.resolve(projectPath, "docs"),
+          ...graphCoverage2 !== void 0 && { graphCoverage: graphCoverage2 }
+        }),
+        validateKnowledgeMap(projectPath)
+      ]);
+      let coverage;
+      if (coverageResult.status === "fulfilled") {
+        const r = coverageResult.value;
+        coverage = r.ok ? r.value : { error: r.error };
+      } else {
+        coverage = { error: String(coverageResult.reason) };
+      }
+      let integrity;
+      if (integrityResult.status === "fulfilled") {
+        const r = integrityResult.value;
+        integrity = r.ok ? r.value : { error: r.error };
+      } else {
+        integrity = { error: String(integrityResult.reason) };
+      }
+      return resultToMcpResponse(Ok({ coverage, integrity }));
+    }
+    const { checkDocCoverage } = await import("./dist-JVZ2MKBC.js");
+    const domain = input.domain ?? "src";
+    const { loadGraphStore } = await import("./graph-loader-KO4GJ5N2.js");
+    const store = await loadGraphStore(projectPath);
+    let graphCoverage;
+    if (store) {
+      const { Assembler } = await import("./dist-M6BQODWC.js");
+      const assembler = new Assembler(store);
+      const report = assembler.checkCoverage();
+      graphCoverage = {
+        documented: [...report.documented],
+        undocumented: [...report.undocumented],
+        coveragePercentage: report.coveragePercentage
+      };
+    }
+    const result = await checkDocCoverage(domain, {
+      sourceDir: path.resolve(projectPath, "src"),
+      docsDir: path.resolve(projectPath, "docs"),
+      ...graphCoverage !== void 0 && { graphCoverage }
+    });
+    return resultToMcpResponse(result);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  checkDocsDefinition,
+  handleCheckDocs
+};

package/dist/chunk-NKDM3FMH.js

@@ -0,0 +1,52 @@
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/persona/generators/agents-md.ts
+function formatTrigger(trigger) {
+  switch (trigger.event) {
+    case "on_pr": {
+      const paths = trigger.conditions?.paths?.join(", ") ?? "all files";
+      return `On PR (${paths})`;
+    }
+    case "on_commit": {
+      const branches = trigger.conditions?.branches?.join(", ") ?? "all branches";
+      return `On commit (${branches})`;
+    }
+    case "scheduled":
+      return `Scheduled (cron: ${trigger.cron})`;
+    case "manual":
+      return "Manual";
+  }
+}
+function generateAgentsMd(persona) {
+  try {
+    const triggers = persona.triggers.map(formatTrigger).join(", ");
+    const skills = persona.skills.join(", ");
+    const commands = persona.steps.filter((s) => "command" in s).map((s) => `\`harness ${s.command}\``).join(", ");
+    const stepSkills = persona.steps.filter((s) => "skill" in s).map((s) => `\`harness skill run ${s.skill}\``).join(", ");
+    const allCommands = [commands, stepSkills].filter(Boolean).join(", ");
+    const fragment = `## ${persona.name} Agent
+
+**Role:** ${persona.role}
+
+**Triggers:** ${triggers}
+
+**Skills:** ${skills}
+
+**When this agent flags an issue:** Fix violations before merging. Run ${allCommands} locally to validate.
+`;
+    return Ok(fragment);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to generate AGENTS.md fragment: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+export {
+  generateAgentsMd
+};

package/dist/chunk-PA2XHK75.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-JVZ2MKBC.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-KO4GJ5N2.js");
+    const store = await loadGraphStore(projectPath);
+    let graphData;
+    if (store) {
+      const { GraphFeedbackAdapter } = await import("./dist-M6BQODWC.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-JVZ2MKBC.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-KO4GJ5N2.js");
+        const store = await loadGraphStore(sanitizePath(input.path));
+        if (store) {
+          const { GraphFeedbackAdapter } = await import("./dist-M6BQODWC.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-JVZ2MKBC.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-KO4GJ5N2.js");
+      const store = await loadGraphStore(sanitizePath(input.path));
+      if (store) {
+        const { GraphFeedbackAdapter } = await import("./dist-M6BQODWC.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
+};