@harness-engineering/cli 1.9.0 → 1.10.0

package/dist/chunk-F3YDAJFQ.js

@@ -0,0 +1,125 @@
+import {
+  resolveSkillsDir
+} from "./chunk-EOLRW32Q.js";
+import {
+  SkillMetadataSchema
+} from "./chunk-MDUK2J2O.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-F4PTVZWA.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-PBTNVK6K.js");
+      const result2 = await validateKnowledgeMap(projectPath);
+      return resultToMcpResponse(result2);
+    }
+    if (scope === "all") {
+      const { checkDocCoverage: checkDocCoverage2, validateKnowledgeMap } = await import("./dist-PBTNVK6K.js");
+      const domain2 = input.domain ?? "src";
+      const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-RLO3KRIX.js");
+      const store2 = await loadGraphStore2(projectPath);
+      let graphCoverage2;
+      if (store2) {
+        const { Assembler } = await import("./dist-I7DB5VKB.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-PBTNVK6K.js");
+    const domain = input.domain ?? "src";
+    const { loadGraphStore } = await import("./graph-loader-RLO3KRIX.js");
+    const store = await loadGraphStore(projectPath);
+    let graphCoverage;
+    if (store) {
+      const { Assembler } = await import("./dist-I7DB5VKB.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-FPIPT36X.js

@@ -0,0 +1,187 @@
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+import {
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/mcp/tools/performance.ts
+var checkPerformanceDefinition = {
+  name: "check_performance",
+  description: "Run performance checks: structural complexity, coupling metrics, and size budgets",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      type: {
+        type: "string",
+        enum: ["structural", "coupling", "size", "all"],
+        description: "Type of performance check (default: all)"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleCheckPerformance(input) {
+  try {
+    const { EntropyAnalyzer } = await import("./dist-PBTNVK6K.js");
+    const typeFilter = input.type ?? "all";
+    const projectPath = sanitizePath(input.path);
+    const analyzer = new EntropyAnalyzer({
+      rootDir: projectPath,
+      analyze: {
+        complexity: typeFilter === "all" || typeFilter === "structural",
+        coupling: typeFilter === "all" || typeFilter === "coupling",
+        sizeBudget: typeFilter === "all" || typeFilter === "size"
+      }
+    });
+    let graphOptions;
+    try {
+      const { loadGraphStore } = await import("./graph-loader-RLO3KRIX.js");
+      const store = await loadGraphStore(projectPath);
+      if (store) {
+        const { GraphComplexityAdapter, GraphCouplingAdapter } = await import("./dist-I7DB5VKB.js");
+        const complexityAdapter = new GraphComplexityAdapter(store);
+        const couplingAdapter = new GraphCouplingAdapter(store);
+        graphOptions = {
+          graphComplexityData: complexityAdapter.computeComplexityHotspots(),
+          graphCouplingData: couplingAdapter.computeCouplingData()
+        };
+      }
+    } catch {
+    }
+    const result = await analyzer.analyze(graphOptions);
+    return resultToMcpResponse(result);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var getPerfBaselinesDefinition = {
+  name: "get_perf_baselines",
+  description: "Read current performance baselines from .harness/perf/baselines.json",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" }
+    },
+    required: ["path"]
+  }
+};
+async function handleGetPerfBaselines(input) {
+  try {
+    const { BaselineManager } = await import("./dist-PBTNVK6K.js");
+    const manager = new BaselineManager(sanitizePath(input.path));
+    const baselines = manager.load();
+    return resultToMcpResponse(
+      Ok(baselines ?? { version: 1, updatedAt: "", updatedFrom: "", benchmarks: {} })
+    );
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var updatePerfBaselinesDefinition = {
+  name: "update_perf_baselines",
+  description: "Update performance baselines from benchmark results. Run benchmarks first via CLI.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      commitHash: { type: "string", description: "Current commit hash for baseline tracking" },
+      results: {
+        type: "array",
+        description: "Array of benchmark results to save as baselines",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            file: { type: "string" },
+            opsPerSec: { type: "number" },
+            meanMs: { type: "number" },
+            p99Ms: { type: "number" },
+            marginOfError: { type: "number" }
+          },
+          required: ["name", "file", "opsPerSec", "meanMs", "p99Ms", "marginOfError"]
+        }
+      }
+    },
+    required: ["path", "commitHash", "results"]
+  }
+};
+async function handleUpdatePerfBaselines(input) {
+  try {
+    const { BaselineManager } = await import("./dist-PBTNVK6K.js");
+    const manager = new BaselineManager(sanitizePath(input.path));
+    manager.save(input.results, input.commitHash);
+    const updated = manager.load();
+    return resultToMcpResponse(Ok(updated));
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var getCriticalPathsDefinition = {
+  name: "get_critical_paths",
+  description: "List performance-critical functions from @perf-critical annotations and graph inference",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" }
+    },
+    required: ["path"]
+  }
+};
+async function handleGetCriticalPaths(input) {
+  try {
+    const { CriticalPathResolver } = await import("./dist-PBTNVK6K.js");
+    const resolver = new CriticalPathResolver(sanitizePath(input.path));
+    const result = await resolver.resolve();
+    return resultToMcpResponse(Ok(result));
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  checkPerformanceDefinition,
+  handleCheckPerformance,
+  getPerfBaselinesDefinition,
+  handleGetPerfBaselines,
+  updatePerfBaselinesDefinition,
+  handleUpdatePerfBaselines,
+  getCriticalPathsDefinition,
+  handleGetCriticalPaths
+};

package/dist/chunk-FX7SQHGD.js

@@ -0,0 +1,103 @@
+import {
+  resolveProjectConfig
+} from "./chunk-K6XAPGML.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+
+// src/mcp/tools/validate.ts
+import * as path from "path";
+var validateToolDefinition = {
+  name: "validate_project",
+  description: "Run all validation checks on a harness engineering project",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root directory" }
+    },
+    required: ["path"]
+  }
+};
+async function handleValidateProject(input) {
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const errors = [];
+  const checks = {
+    config: "fail",
+    structure: "skipped",
+    agentsMap: "skipped"
+  };
+  const configResult = resolveProjectConfig(projectPath);
+  if (!configResult.ok) {
+    errors.push(`Config: ${configResult.error.message}`);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ valid: false, checks, errors }) }]
+    };
+  }
+  checks.config = "pass";
+  const config = configResult.value;
+  try {
+    const core = await import("./dist-PBTNVK6K.js");
+    if (typeof core.validateFileStructure === "function" && Array.isArray(config.conventions)) {
+      const conventions = config.conventions;
+      const structureResult = await core.validateFileStructure(projectPath, conventions);
+      if (structureResult.ok) {
+        checks.structure = structureResult.value.valid ? "pass" : "fail";
+        if (!structureResult.value.valid) {
+          for (const missing of structureResult.value.missing) {
+            errors.push(`Missing required file: ${missing}`);
+          }
+        }
+      } else {
+        checks.structure = "fail";
+        errors.push(`Structure validation error: ${structureResult.error.message}`);
+      }
+    }
+  } catch {
+  }
+  try {
+    const core = await import("./dist-PBTNVK6K.js");
+    if (typeof core.validateAgentsMap === "function") {
+      const agentsMapPath = path.join(projectPath, "AGENTS.md");
+      const agentsResult = await core.validateAgentsMap(agentsMapPath);
+      if (agentsResult.ok) {
+        checks.agentsMap = agentsResult.value.valid ? "pass" : "fail";
+        if (!agentsResult.value.valid) {
+          if (agentsResult.value.missingSections.length > 0) {
+            errors.push(
+              `AGENTS.md missing sections: ${agentsResult.value.missingSections.join(", ")}`
+            );
+          }
+          if (agentsResult.value.brokenLinks.length > 0) {
+            errors.push(`AGENTS.md has ${agentsResult.value.brokenLinks.length} broken link(s)`);
+          }
+        }
+      } else {
+        checks.agentsMap = "fail";
+        errors.push(`AGENTS.md validation error: ${agentsResult.error.message}`);
+      }
+    }
+  } catch {
+  }
+  const valid = errors.length === 0;
+  return {
+    content: [{ type: "text", text: JSON.stringify({ valid, checks, errors }) }]
+  };
+}
+
+export {
+  validateToolDefinition,
+  handleValidateProject
+};

package/dist/chunk-HIOXKZYF.js

@@ -0,0 +1,15 @@
+// src/output/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (message) => console.log(chalk.blue("i"), message),
+  success: (message) => console.log(chalk.green("v"), message),
+  warn: (message) => console.log(chalk.yellow("!"), message),
+  error: (message) => console.error(chalk.red("x"), message),
+  dim: (message) => console.log(chalk.dim(message)),
+  // For JSON output mode
+  raw: (data) => console.log(JSON.stringify(data, null, 2))
+};
+
+export {
+  logger
+};

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
+};