@harness-engineering/cli 1.8.2 → 1.10.0

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