@harness-engineering/cli 1.8.2 → 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-K6KTTN3I.js → dist-I7DB5VKB.js}

@@ -2164,6 +2164,242 @@ var GraphCouplingAdapter = class {
     return maxDepth;
   }
 };
+var DEFAULT_THRESHOLD = 2;
+var DEFAULT_METRICS = [
+  "cyclomaticComplexity",
+  "fanIn",
+  "fanOut",
+  "hotspotScore",
+  "transitiveDepth"
+];
+var RECOGNIZED_METRICS = new Set(DEFAULT_METRICS);
+var GraphAnomalyAdapter = class {
+  constructor(store) {
+    this.store = store;
+  }
+  detect(options) {
+    const threshold = options?.threshold != null && options.threshold > 0 ? options.threshold : DEFAULT_THRESHOLD;
+    const requestedMetrics = options?.metrics ?? [...DEFAULT_METRICS];
+    const warnings = [];
+    const metricsToAnalyze = [];
+    for (const m of requestedMetrics) {
+      if (RECOGNIZED_METRICS.has(m)) {
+        metricsToAnalyze.push(m);
+      } else {
+        warnings.push(m);
+      }
+    }
+    const allOutliers = [];
+    const analyzedNodeIds = /* @__PURE__ */ new Set();
+    const couplingMetrics = ["fanIn", "fanOut", "transitiveDepth"];
+    const needsCoupling = metricsToAnalyze.some((m) => couplingMetrics.includes(m));
+    const needsComplexity = metricsToAnalyze.includes("hotspotScore");
+    const cachedCouplingData = needsCoupling ? new GraphCouplingAdapter(this.store).computeCouplingData() : void 0;
+    const cachedHotspotData = needsComplexity ? new GraphComplexityAdapter(this.store).computeComplexityHotspots() : void 0;
+    for (const metric of metricsToAnalyze) {
+      const entries = this.collectMetricValues(metric, cachedCouplingData, cachedHotspotData);
+      for (const e of entries) {
+        analyzedNodeIds.add(e.nodeId);
+      }
+      const outliers = this.computeZScoreOutliers(entries, metric, threshold);
+      allOutliers.push(...outliers);
+    }
+    allOutliers.sort((a, b) => b.zScore - a.zScore);
+    const articulationPoints = this.findArticulationPoints();
+    const outlierNodeIds = new Set(allOutliers.map((o) => o.nodeId));
+    const apNodeIds = new Set(articulationPoints.map((ap) => ap.nodeId));
+    const overlapping = [...outlierNodeIds].filter((id) => apNodeIds.has(id));
+    return {
+      statisticalOutliers: allOutliers,
+      articulationPoints,
+      overlapping,
+      summary: {
+        totalNodesAnalyzed: analyzedNodeIds.size,
+        outlierCount: allOutliers.length,
+        articulationPointCount: articulationPoints.length,
+        overlapCount: overlapping.length,
+        metricsAnalyzed: metricsToAnalyze,
+        warnings,
+        threshold
+      }
+    };
+  }
+  collectMetricValues(metric, cachedCouplingData, cachedHotspotData) {
+    const entries = [];
+    if (metric === "cyclomaticComplexity") {
+      const functionNodes = [
+        ...this.store.findNodes({ type: "function" }),
+        ...this.store.findNodes({ type: "method" })
+      ];
+      for (const node of functionNodes) {
+        const cc = node.metadata?.cyclomaticComplexity;
+        if (typeof cc === "number") {
+          entries.push({
+            nodeId: node.id,
+            nodeName: node.name,
+            nodePath: node.path,
+            nodeType: node.type,
+            value: cc
+          });
+        }
+      }
+    } else if (metric === "fanIn" || metric === "fanOut" || metric === "transitiveDepth") {
+      const couplingData = cachedCouplingData ?? new GraphCouplingAdapter(this.store).computeCouplingData();
+      const fileNodes = this.store.findNodes({ type: "file" });
+      for (const fileData of couplingData.files) {
+        const fileNode = fileNodes.find((n) => (n.path ?? n.name) === fileData.file);
+        if (!fileNode) continue;
+        entries.push({
+          nodeId: fileNode.id,
+          nodeName: fileNode.name,
+          nodePath: fileNode.path,
+          nodeType: "file",
+          value: fileData[metric]
+        });
+      }
+    } else if (metric === "hotspotScore") {
+      const hotspots = cachedHotspotData ?? new GraphComplexityAdapter(this.store).computeComplexityHotspots();
+      const functionNodes = [
+        ...this.store.findNodes({ type: "function" }),
+        ...this.store.findNodes({ type: "method" })
+      ];
+      for (const h of hotspots.hotspots) {
+        const fnNode = functionNodes.find(
+          (n) => n.name === h.function && (n.path ?? "") === (h.file ?? "")
+        );
+        if (!fnNode) continue;
+        entries.push({
+          nodeId: fnNode.id,
+          nodeName: fnNode.name,
+          nodePath: fnNode.path,
+          nodeType: fnNode.type,
+          value: h.hotspotScore
+        });
+      }
+    }
+    return entries;
+  }
+  computeZScoreOutliers(entries, metric, threshold) {
+    if (entries.length === 0) return [];
+    const values = entries.map((e) => e.value);
+    const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+    const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+    const stdDev = Math.sqrt(variance);
+    if (stdDev === 0) return [];
+    const outliers = [];
+    for (const entry of entries) {
+      const zScore = Math.abs(entry.value - mean) / stdDev;
+      if (zScore > threshold) {
+        outliers.push({
+          nodeId: entry.nodeId,
+          nodeName: entry.nodeName,
+          nodePath: entry.nodePath,
+          nodeType: entry.nodeType,
+          metric,
+          value: entry.value,
+          zScore,
+          mean,
+          stdDev
+        });
+      }
+    }
+    return outliers;
+  }
+  findArticulationPoints() {
+    const fileNodes = this.store.findNodes({ type: "file" });
+    if (fileNodes.length === 0) return [];
+    const nodeMap = /* @__PURE__ */ new Map();
+    const adj = /* @__PURE__ */ new Map();
+    for (const node of fileNodes) {
+      nodeMap.set(node.id, { name: node.name, path: node.path });
+      adj.set(node.id, /* @__PURE__ */ new Set());
+    }
+    const importEdges = this.store.getEdges({ type: "imports" });
+    for (const edge of importEdges) {
+      if (adj.has(edge.from) && adj.has(edge.to)) {
+        adj.get(edge.from).add(edge.to);
+        adj.get(edge.to).add(edge.from);
+      }
+    }
+    const disc = /* @__PURE__ */ new Map();
+    const low = /* @__PURE__ */ new Map();
+    const parent = /* @__PURE__ */ new Map();
+    const apSet = /* @__PURE__ */ new Set();
+    let timer = 0;
+    const dfs = (u) => {
+      disc.set(u, timer);
+      low.set(u, timer);
+      timer++;
+      let children = 0;
+      for (const v of adj.get(u)) {
+        if (!disc.has(v)) {
+          children++;
+          parent.set(v, u);
+          dfs(v);
+          low.set(u, Math.min(low.get(u), low.get(v)));
+          if (parent.get(u) === null && children > 1) {
+            apSet.add(u);
+          }
+          if (parent.get(u) !== null && low.get(v) >= disc.get(u)) {
+            apSet.add(u);
+          }
+        } else if (v !== parent.get(u)) {
+          low.set(u, Math.min(low.get(u), disc.get(v)));
+        }
+      }
+    };
+    for (const nodeId of adj.keys()) {
+      if (!disc.has(nodeId)) {
+        parent.set(nodeId, null);
+        dfs(nodeId);
+      }
+    }
+    const results = [];
+    for (const apId of apSet) {
+      const { components, dependentCount } = this.computeRemovalImpact(apId, adj);
+      const info = nodeMap.get(apId);
+      results.push({
+        nodeId: apId,
+        nodeName: info.name,
+        nodePath: info.path,
+        componentsIfRemoved: components,
+        dependentCount
+      });
+    }
+    results.sort((a, b) => b.dependentCount - a.dependentCount);
+    return results;
+  }
+  computeRemovalImpact(removedId, adj) {
+    const visited = /* @__PURE__ */ new Set();
+    visited.add(removedId);
+    const componentSizes = [];
+    for (const nodeId of adj.keys()) {
+      if (visited.has(nodeId)) continue;
+      const queue = [nodeId];
+      visited.add(nodeId);
+      let size = 0;
+      let head = 0;
+      while (head < queue.length) {
+        const current = queue[head++];
+        size++;
+        for (const neighbor of adj.get(current)) {
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+      componentSizes.push(size);
+    }
+    const components = componentSizes.length;
+    if (componentSizes.length <= 1) {
+      return { components, dependentCount: 0 };
+    }
+    const maxSize = Math.max(...componentSizes);
+    const dependentCount = componentSizes.reduce((sum, s) => sum + s, 0) - maxSize;
+    return { components, dependentCount };
+  }
+};
 var PHASE_NODE_TYPES = {
   implement: ["file", "function", "class", "method", "interface", "variable"],
   review: ["adr", "document", "learning", "commit"],
@@ -2785,6 +3021,7 @@ export {
   EDGE_TYPES,
   FusionLayer,
   GitIngestor,
+  GraphAnomalyAdapter,
   GraphComplexityAdapter,
   GraphConstraintAdapter,
   GraphCouplingAdapter,

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-ZODQVGC4.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-SAB3VXOW.js";
+} from "./chunk-NX6DSZSM.js";
+import {
+  Err,
+  Ok,
+  STANDARD_COGNITIVE_MODES,
+  isErr,
+  isOk
+} from "./chunk-MHBMTPW7.js";
 export {
   AGENT_DESCRIPTORS,
   ARCHITECTURE_DESCRIPTOR,