@harness-engineering/cli 1.9.0 → 1.10.0

package/dist/chunk-TRAPF4IX.js

@@ -0,0 +1,185 @@
+// src/persona/trigger-detector.ts
+import * as fs from "fs";
+import * as path from "path";
+function detectTrigger(projectPath) {
+  const handoffPath = path.join(projectPath, ".harness", "handoff.json");
+  if (!fs.existsSync(handoffPath)) {
+    return { trigger: "manual" };
+  }
+  try {
+    const raw = fs.readFileSync(handoffPath, "utf-8");
+    const handoff = JSON.parse(raw);
+    if (handoff.fromSkill === "harness-planning" && Array.isArray(handoff.pending) && handoff.pending.length > 0) {
+      return {
+        trigger: "on_plan_approved",
+        handoff: {
+          fromSkill: handoff.fromSkill,
+          summary: handoff.summary ?? "",
+          pending: handoff.pending,
+          planPath: handoff.planPath
+        }
+      };
+    }
+    return { trigger: "manual" };
+  } catch {
+    return { trigger: "manual" };
+  }
+}
+
+// src/persona/runner.ts
+var TIMEOUT_ERROR_MESSAGE = "__PERSONA_RUNNER_TIMEOUT__";
+function stepName(step) {
+  return "command" in step ? step.command : step.skill;
+}
+function stepType(step) {
+  return "command" in step ? "command" : "skill";
+}
+function matchesTrigger(step, trigger) {
+  const when = step.when ?? "always";
+  return when === "always" || when === trigger;
+}
+function skipRemaining(activeSteps, fromIndex, report) {
+  for (let j = fromIndex; j < activeSteps.length; j++) {
+    const remaining = activeSteps[j];
+    report.steps.push({
+      name: stepName(remaining),
+      type: stepType(remaining),
+      status: "skipped",
+      durationMs: 0
+    });
+  }
+}
+async function runPersona(persona, context) {
+  const startTime = Date.now();
+  const timeout = persona.config.timeout;
+  const report = {
+    persona: persona.name.toLowerCase().replace(/\s+/g, "-"),
+    status: "pass",
+    steps: [],
+    totalDurationMs: 0
+  };
+  let resolvedTrigger;
+  let handoff = context.handoff;
+  if (context.trigger === "auto") {
+    const detection = detectTrigger(context.projectPath);
+    resolvedTrigger = detection.trigger;
+    handoff = detection.handoff ?? handoff;
+  } else {
+    resolvedTrigger = context.trigger;
+  }
+  const activeSteps = persona.steps.filter((s) => matchesTrigger(s, resolvedTrigger));
+  for (let i = 0; i < activeSteps.length; i++) {
+    const step = activeSteps[i];
+    if (Date.now() - startTime >= timeout) {
+      skipRemaining(activeSteps, i, report);
+      report.status = "partial";
+      break;
+    }
+    const stepStart = Date.now();
+    const remainingTime = timeout - (Date.now() - startTime);
+    if ("command" in step) {
+      const result = await Promise.race([
+        context.commandExecutor(step.command),
+        new Promise(
+          (resolve) => setTimeout(
+            () => resolve({
+              ok: false,
+              error: new Error(TIMEOUT_ERROR_MESSAGE)
+            }),
+            remainingTime
+          )
+        )
+      ]);
+      const durationMs = Date.now() - stepStart;
+      if (result.ok) {
+        report.steps.push({
+          name: step.command,
+          type: "command",
+          status: "pass",
+          result: result.value,
+          durationMs
+        });
+      } else if (result.error.message === TIMEOUT_ERROR_MESSAGE) {
+        report.steps.push({
+          name: step.command,
+          type: "command",
+          status: "skipped",
+          error: "timed out",
+          durationMs
+        });
+        report.status = "partial";
+        skipRemaining(activeSteps, i + 1, report);
+        break;
+      } else {
+        report.steps.push({
+          name: step.command,
+          type: "command",
+          status: "fail",
+          error: result.error.message,
+          durationMs
+        });
+        report.status = "fail";
+        skipRemaining(activeSteps, i + 1, report);
+        break;
+      }
+    } else {
+      const skillContext = {
+        trigger: resolvedTrigger,
+        projectPath: context.projectPath,
+        outputMode: step.output ?? "auto",
+        ...handoff ? { handoff } : {}
+      };
+      const SKILL_TIMEOUT_RESULT = {
+        status: "fail",
+        output: "timed out",
+        durationMs: 0
+      };
+      const result = await Promise.race([
+        context.skillExecutor(step.skill, skillContext),
+        new Promise(
+          (resolve) => setTimeout(() => resolve(SKILL_TIMEOUT_RESULT), remainingTime)
+        )
+      ]);
+      const durationMs = Date.now() - stepStart;
+      if (result === SKILL_TIMEOUT_RESULT) {
+        report.steps.push({
+          name: step.skill,
+          type: "skill",
+          status: "skipped",
+          error: "timed out",
+          durationMs
+        });
+        report.status = "partial";
+        skipRemaining(activeSteps, i + 1, report);
+        break;
+      } else if (result.status === "pass") {
+        report.steps.push({
+          name: step.skill,
+          type: "skill",
+          status: "pass",
+          result: result.output,
+          ...result.artifactPath ? { artifactPath: result.artifactPath } : {},
+          durationMs
+        });
+      } else {
+        report.steps.push({
+          name: step.skill,
+          type: "skill",
+          status: "fail",
+          error: result.output,
+          durationMs
+        });
+        report.status = "fail";
+        skipRemaining(activeSteps, i + 1, report);
+        break;
+      }
+    }
+  }
+  report.totalDurationMs = Date.now() - startTime;
+  return report;
+}
+
+export {
+  detectTrigger,
+  runPersona
+};

package/dist/chunk-VUCPTQ6G.js

@@ -0,0 +1,67 @@
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/persona/generators/ci-workflow.ts
+import YAML from "yaml";
+function buildGitHubTriggers(triggers) {
+  const on = {};
+  for (const trigger of triggers) {
+    switch (trigger.event) {
+      case "on_pr": {
+        const prConfig = {};
+        if (trigger.conditions?.paths) prConfig.paths = trigger.conditions.paths;
+        on.pull_request = prConfig;
+        break;
+      }
+      case "on_commit": {
+        const pushConfig = {};
+        if (trigger.conditions?.branches) pushConfig.branches = trigger.conditions.branches;
+        on.push = pushConfig;
+        break;
+      }
+      case "scheduled":
+        on.schedule = [{ cron: trigger.cron }];
+        break;
+    }
+  }
+  return on;
+}
+function generateCIWorkflow(persona, platform) {
+  try {
+    if (platform === "gitlab") return Err(new Error("GitLab CI generation is not yet supported"));
+    const severity = persona.config.severity;
+    const steps = [
+      { uses: "actions/checkout@v4" },
+      { uses: "actions/setup-node@v4", with: { "node-version": "20" } },
+      { uses: "pnpm/action-setup@v4", with: { run_install: "frozen" } }
+    ];
+    const commandSteps = persona.steps.filter((s) => "command" in s);
+    for (const step of commandSteps) {
+      const severityFlag = severity ? ` --severity ${severity}` : "";
+      steps.push({ run: `npx harness ${step.command}${severityFlag}` });
+    }
+    const workflow = {
+      name: persona.name,
+      on: buildGitHubTriggers(persona.triggers),
+      jobs: {
+        enforce: {
+          "runs-on": "ubuntu-latest",
+          steps
+        }
+      }
+    };
+    return Ok(YAML.stringify(workflow, { lineWidth: 0 }));
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to generate CI workflow: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+export {
+  generateCIWorkflow
+};

package/dist/chunk-W6Y7ZW3Y.js

@@ -0,0 +1,13 @@
+// src/mcp/utils/sanitize-path.ts
+import * as path from "path";
+function sanitizePath(inputPath) {
+  const resolved = path.resolve(inputPath);
+  if (resolved === "/" || resolved === path.parse(resolved).root) {
+    throw new Error("Invalid project path: cannot use filesystem root");
+  }
+  return resolved;
+}
+
+export {
+  sanitizePath
+};

package/dist/chunk-ZOAWBDWU.js

@@ -0,0 +1,72 @@
+// src/slash-commands/types.ts
+var VALID_PLATFORMS = ["claude-code", "gemini-cli"];
+var GENERATED_HEADER_CLAUDE = "<!-- Generated by harness generate-slash-commands. Do not edit. -->";
+var GENERATED_HEADER_GEMINI = "# Generated by harness generate-slash-commands. Do not edit.";
+
+// src/slash-commands/sync.ts
+import fs from "fs";
+import path from "path";
+
+// src/agent-definitions/constants.ts
+var GENERATED_HEADER_AGENT = "<!-- Generated by harness generate-agent-definitions. Do not edit. -->";
+
+// src/slash-commands/sync.ts
+function computeSyncPlan(outputDir, rendered) {
+  const added = [];
+  const updated = [];
+  const removed = [];
+  const unchanged = [];
+  for (const [filename, content] of rendered) {
+    const filePath = path.join(outputDir, filename);
+    if (!fs.existsSync(filePath)) {
+      added.push(filename);
+    } else {
+      const existing = fs.readFileSync(filePath, "utf-8");
+      if (existing === content) {
+        unchanged.push(filename);
+      } else {
+        updated.push(filename);
+      }
+    }
+  }
+  if (fs.existsSync(outputDir)) {
+    const existing = fs.readdirSync(outputDir).filter((f) => {
+      const stat = fs.statSync(path.join(outputDir, f));
+      return stat.isFile();
+    });
+    for (const filename of existing) {
+      if (rendered.has(filename)) continue;
+      const content = fs.readFileSync(path.join(outputDir, filename), "utf-8");
+      if (content.includes(GENERATED_HEADER_CLAUDE) || content.includes(GENERATED_HEADER_GEMINI) || content.includes(GENERATED_HEADER_AGENT)) {
+        removed.push(filename);
+      }
+    }
+  }
+  return { added, updated, removed, unchanged };
+}
+function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
+  fs.mkdirSync(outputDir, { recursive: true });
+  for (const filename of [...plan.added, ...plan.updated]) {
+    const content = rendered.get(filename);
+    if (content !== void 0) {
+      fs.writeFileSync(path.join(outputDir, filename), content);
+    }
+  }
+  if (deleteOrphans) {
+    for (const filename of plan.removed) {
+      const filePath = path.join(outputDir, filename);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    }
+  }
+}
+
+export {
+  VALID_PLATFORMS,
+  GENERATED_HEADER_CLAUDE,
+  GENERATED_HEADER_GEMINI,
+  GENERATED_HEADER_AGENT,
+  computeSyncPlan,
+  applySyncPlan
+};

package/dist/ci-workflow-ZBBUNTHQ.js

@@ -0,0 +1,8 @@
+import {
+  generateCIWorkflow
+} from "./chunk-VUCPTQ6G.js";
+import "./chunk-NX6DSZSM.js";
+import "./chunk-MHBMTPW7.js";
+export {
+  generateCIWorkflow
+};

package/dist/constants-5JGUXPEK.js

@@ -0,0 +1,6 @@
+import {
+  ALLOWED_PERSONA_COMMANDS
+} from "./chunk-TEFCFC4H.js";
+export {
+  ALLOWED_PERSONA_COMMANDS
+};

package/dist/create-skill-LUWO46WF.js

@@ -0,0 +1,11 @@
+import {
+  createCreateSkillCommand,
+  generateSkillFiles
+} from "./chunk-ECUJQS3B.js";
+import "./chunk-HIOXKZYF.js";
+import "./chunk-B7HFEHWP.js";
+import "./chunk-MDUK2J2O.js";
+export {
+  createCreateSkillCommand,
+  generateSkillFiles
+};

package/dist/dist-D4RYGUZE.js

@@ -0,0 +1,14 @@
+import {
+  Err,
+  Ok,
+  STANDARD_COGNITIVE_MODES,
+  isErr,
+  isOk
+} from "./chunk-MHBMTPW7.js";
+export {
+  Err,
+  Ok,
+  STANDARD_COGNITIVE_MODES,
+  isErr,
+  isOk
+};

package/dist/dist-L7LAAQAS.js

@@ -0,0 +1,18 @@
+import {
+  LinterConfigSchema,
+  ParseError,
+  RuleConfigSchema,
+  TemplateError,
+  TemplateLoadError,
+  generate,
+  validate
+} from "./chunk-QPEH2QPG.js";
+export {
+  LinterConfigSchema,
+  ParseError,
+  RuleConfigSchema,
+  TemplateError,
+  TemplateLoadError,
+  generate,
+  validate
+};

package/dist/{dist-C5PYIQPF.js → dist-PBTNVK6K.js}

@@ -17,7 +17,6 @@ import {
   EmitInteractionInputSchema,
   EntropyAnalyzer,
   EntropyConfigSchema,
-  Err,
   ExclusionSet,
   FailureEntrySchema,
   FileSink,
@@ -29,14 +28,12 @@ import {
   NoOpExecutor,
   NoOpSink,
   NoOpTelemetryAdapter,
-  Ok,
   PatternConfigSchema,
   QuestionSchema,
   REQUIRED_SECTIONS,
   RegressionDetector,
   RuleRegistry,
   SECURITY_DESCRIPTOR,
-  STANDARD_COGNITIVE_MODES,
   SecurityConfigSchema,
   SecurityScanner,
   StreamIndexSchema,
@@ -104,8 +101,6 @@ import {
   getUpdateNotification,
   goRules,
   injectionRules,
-  isErr,
-  isOk,
   isSmallSuggestion,
   isUpdateCheckEnabled,
   listStreams,
@@ -165,7 +160,14 @@ import {
   validateKnowledgeMap,
   validatePatternConfig,
   xssRules
-} from "./chunk-CGSHUJES.js";
+} from "./chunk-NX6DSZSM.js";
+import {
+  Err,
+  Ok,
+  STANDARD_COGNITIVE_MODES,
+  isErr,
+  isOk
+} from "./chunk-MHBMTPW7.js";
 export {
   AGENT_DESCRIPTORS,
   ARCHITECTURE_DESCRIPTOR,

package/dist/docs-PTJGD6XI.js

@@ -0,0 +1,12 @@
+import {
+  checkDocsDefinition,
+  handleCheckDocs
+} from "./chunk-F4PTVZWA.js";
+import "./chunk-IDZNPTYD.js";
+import "./chunk-W6Y7ZW3Y.js";
+import "./chunk-NX6DSZSM.js";
+import "./chunk-MHBMTPW7.js";
+export {
+  checkDocsDefinition,
+  handleCheckDocs
+};

package/dist/engine-SCMZ3G3E.js

@@ -0,0 +1,8 @@
+import {
+  TemplateEngine
+} from "./chunk-C2ERUR3L.js";
+import "./chunk-NX6DSZSM.js";
+import "./chunk-MHBMTPW7.js";
+export {
+  TemplateEngine
+};

package/dist/entropy-YIUBGKY7.js

@@ -0,0 +1,12 @@
+import {
+  detectEntropyDefinition,
+  handleDetectEntropy
+} from "./chunk-CWZ4Y2PO.js";
+import "./chunk-IDZNPTYD.js";
+import "./chunk-W6Y7ZW3Y.js";
+import "./chunk-NX6DSZSM.js";
+import "./chunk-MHBMTPW7.js";
+export {
+  detectEntropyDefinition,
+  handleDetectEntropy
+};

package/dist/feedback-WEVQSLAA.js

@@ -0,0 +1,18 @@
+import {
+  analyzeDiffDefinition,
+  createSelfReviewDefinition,
+  handleAnalyzeDiff,
+  handleCreateSelfReview,
+  handleRequestPeerReview,
+  requestPeerReviewDefinition
+} from "./chunk-4PFMY3H7.js";
+import "./chunk-IDZNPTYD.js";
+import "./chunk-W6Y7ZW3Y.js";
+export {
+  analyzeDiffDefinition,
+  createSelfReviewDefinition,
+  handleAnalyzeDiff,
+  handleCreateSelfReview,
+  handleRequestPeerReview,
+  requestPeerReviewDefinition
+};

package/dist/generate-agent-definitions-BU5LOJTI.js

@@ -0,0 +1,15 @@
+import {
+  createGenerateAgentDefinitionsCommand,
+  generateAgentDefinitions
+} from "./chunk-46YA6FI3.js";
+import "./chunk-Q6AB7W5Z.js";
+import "./chunk-KET4QQZB.js";
+import "./chunk-ZOAWBDWU.js";
+import "./chunk-EOLRW32Q.js";
+import "./chunk-B7HFEHWP.js";
+import "./chunk-NX6DSZSM.js";
+import "./chunk-MHBMTPW7.js";
+export {
+  createGenerateAgentDefinitionsCommand,
+  generateAgentDefinitions
+};

package/dist/glob-helper-5OHBUQAI.js

@@ -0,0 +1,52 @@
+// src/mcp/utils/glob-helper.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".go", ".py"]);
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\xA7\xA7").replace(/\*/g, "[^/]*").replace(/§§/g, ".*");
+  return new RegExp(escaped);
+}
+function isExcluded(relativePath, excludeRegexes) {
+  for (const regex of excludeRegexes) {
+    if (regex.test(relativePath)) return true;
+  }
+  return false;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next", ".nuxt", "__pycache__"]);
+async function globFiles(rootDir, exclude) {
+  const patterns = exclude ?? [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/*.test.ts",
+    "**/fixtures/**"
+  ];
+  const excludeRegexes = patterns.map(globToRegex);
+  const files = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(rootDir, fullPath);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (isExcluded(relativePath + "/", excludeRegexes)) continue;
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (!SOURCE_EXTENSIONS.has(ext)) continue;
+        if (isExcluded(relativePath, excludeRegexes)) continue;
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(rootDir);
+  return files;
+}
+export {
+  globFiles
+};

package/dist/graph-loader-RLO3KRIX.js

@@ -0,0 +1,8 @@
+import {
+  clearGraphStoreCache,
+  loadGraphStore
+} from "./chunk-OPXH4CQN.js";
+export {
+  clearGraphStoreCache,
+  loadGraphStore
+};

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import { ContextQLResult, IngestResult } from '@harness-engineering/graph';
 import { Result } from '@harness-engineering/core';
 import { z } from 'zod';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 
 interface Phase {
     name: string;
@@ -987,6 +988,15 @@ declare function renderClaudeCodeAgent(def: AgentDefinition): string;
 
 declare function renderGeminiAgent(def: AgentDefinition): string;
 
+type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+};
+declare function getToolDefinitions(): ToolDefinition[];
+declare function createHarnessServer(projectRoot?: string): Server;
+declare function startServer(): Promise<void>;
+
 declare function createProgram(): Command;
 
-export { AGENT_DESCRIPTIONS, ALLOWED_PERSONA_COMMANDS, type AgentDefinition, CLIError, type CommandExecutor, type CommandStep, type CreateSkillOptions, DEFAULT_TOOLS, ExitCode, GEMINI_TOOL_MAP, type GenerateAgentDefsOptions, type GenerateAgentDefsResult, type GenerateResult, type HandoffContext, type HarnessConfig, OutputFormatter, OutputMode, type Persona, type PersonaMetadata, type PersonaRunReport, type RenderedFiles, type SkillExecutionContext, type SkillExecutionResult, type SkillExecutor, type SkillSource, type SkillStep, type Step, type StepExecutionContext, type StepReport, type TemplateContext, TemplateEngine, type TriggerContext, type TriggerDetectionResult, buildPreamble, createProgram, detectTrigger, executeSkill, findConfigFile, generateAgentDefinition, generateAgentDefinitions, generateAgentsMd, generateCIWorkflow, generateRuntime, generateSkillFiles, generateSlashCommands, handleError, listPersonas, loadConfig, loadPersona, logger, renderClaudeCodeAgent, renderGeminiAgent, resolveConfig, runCheckPhaseGate, runCrossCheck, runGraphExport, runGraphStatus, runIngest, runPersona, runQuery, runScan };
+export { AGENT_DESCRIPTIONS, ALLOWED_PERSONA_COMMANDS, type AgentDefinition, CLIError, type CommandExecutor, type CommandStep, type CreateSkillOptions, DEFAULT_TOOLS, ExitCode, GEMINI_TOOL_MAP, type GenerateAgentDefsOptions, type GenerateAgentDefsResult, type GenerateResult, type HandoffContext, type HarnessConfig, OutputFormatter, OutputMode, type Persona, type PersonaMetadata, type PersonaRunReport, type RenderedFiles, type SkillExecutionContext, type SkillExecutionResult, type SkillExecutor, type SkillSource, type SkillStep, type Step, type StepExecutionContext, type StepReport, type TemplateContext, TemplateEngine, type TriggerContext, type TriggerDetectionResult, buildPreamble, createHarnessServer, createProgram, detectTrigger, executeSkill, findConfigFile, generateAgentDefinition, generateAgentDefinitions, generateAgentsMd, generateCIWorkflow, generateRuntime, generateSkillFiles, generateSlashCommands, getToolDefinitions, handleError, listPersonas, loadConfig, loadPersona, logger, renderClaudeCodeAgent, renderGeminiAgent, resolveConfig, runCheckPhaseGate, runCrossCheck, runGraphExport, runGraphStatus, runIngest, runPersona, runQuery, runScan, startServer };