@harness-engineering/cli 1.9.0 → 1.11.0

package/dist/chunk-GNGELAXY.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-HD4IBGLA.js";
+import {
+  CLIError,
+  ExitCode,
+  handleError
+} from "./chunk-3WGJMBKH.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-GSIVNYVJ.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-JVZ2MKBC.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-KO4GJ5N2.js");
+      const store = await loadGraphStore(projectPath);
+      if (store) {
+        const { GraphComplexityAdapter, GraphCouplingAdapter } = await import("./dist-M6BQODWC.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-JVZ2MKBC.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-JVZ2MKBC.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-JVZ2MKBC.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-HD4IBGLA.js

@@ -0,0 +1,80 @@
+// src/utils/paths.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function findUpFrom(startDir, targetName, marker, maxLevels) {
+  let dir = startDir;
+  for (let i = 0; i < maxLevels; i++) {
+    const candidate = path.join(dir, targetName);
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      if (fs.existsSync(path.join(candidate, marker))) {
+        return candidate;
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+function findUpDir(targetName, marker, maxLevels = 8) {
+  const fromModule = findUpFrom(__dirname, targetName, marker, maxLevels);
+  if (fromModule) return fromModule;
+  return findUpFrom(process.cwd(), targetName, marker, maxLevels);
+}
+function resolveTemplatesDir() {
+  return findUpDir("templates", "base") ?? path.join(__dirname, "templates");
+}
+function resolvePersonasDir() {
+  const agentsDir = findUpDir("agents", "personas");
+  if (agentsDir) {
+    return path.join(agentsDir, "personas");
+  }
+  return path.join(__dirname, "agents", "personas");
+}
+function resolveSkillsDir() {
+  const agentsDir = findUpDir("agents", "skills");
+  if (agentsDir) {
+    return path.join(agentsDir, "skills", "claude-code");
+  }
+  return path.join(__dirname, "agents", "skills", "claude-code");
+}
+function resolveProjectSkillsDir(cwd) {
+  let dir = cwd ?? process.cwd();
+  for (let i = 0; i < 8; i++) {
+    const candidate = path.join(dir, "agents", "skills", "claude-code");
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      const agentsDir = path.join(dir, "agents");
+      if (fs.existsSync(path.join(agentsDir, "skills"))) {
+        return candidate;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function resolveGlobalSkillsDir() {
+  const agentsDir = findUpDir("agents", "skills");
+  if (agentsDir) {
+    return path.join(agentsDir, "skills", "claude-code");
+  }
+  return path.join(__dirname, "agents", "skills", "claude-code");
+}
+function resolveCommunitySkillsDir(platform = "claude-code") {
+  const agentsDir = findUpDir("agents", "skills");
+  if (agentsDir) {
+    return path.join(agentsDir, "skills", "community", platform);
+  }
+  return path.join(__dirname, "agents", "skills", "community", platform);
+}
+
+export {
+  resolveTemplatesDir,
+  resolvePersonasDir,
+  resolveSkillsDir,
+  resolveProjectSkillsDir,
+  resolveGlobalSkillsDir,
+  resolveCommunitySkillsDir
+};