@harness-engineering/cli 1.9.0 → 1.11.0

package/dist/chunk-Z75JC6I2.js

@@ -0,0 +1,189 @@
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+import {
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/mcp/tools/entropy.ts
+async function loadEntropyGraphOptions(projectPath) {
+  const { loadGraphStore } = await import("./graph-loader-KO4GJ5N2.js");
+  const store = await loadGraphStore(projectPath);
+  if (!store) return void 0;
+  const { GraphEntropyAdapter } = await import("./dist-M6BQODWC.js");
+  const adapter = new GraphEntropyAdapter(store);
+  const driftData = adapter.computeDriftData();
+  const deadCodeData = adapter.computeDeadCodeData();
+  return {
+    graphDriftData: {
+      staleEdges: driftData.staleEdges.map((e) => ({
+        docNodeId: e.docNodeId,
+        codeNodeId: e.codeNodeId,
+        edgeType: e.edgeType
+      })),
+      missingTargets: [...driftData.missingTargets]
+    },
+    graphDeadCodeData: {
+      reachableNodeIds: new Set(deadCodeData.reachableNodeIds),
+      unreachableNodes: deadCodeData.unreachableNodes.map((n) => ({
+        id: n.id,
+        type: n.type,
+        name: n.name,
+        ...n.path !== void 0 && { path: n.path }
+      }))
+    }
+  };
+}
+var detectEntropyDefinition = {
+  name: "detect_entropy",
+  description: "Detect documentation drift, dead code, and pattern violations. Optionally auto-fix detected issues.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      type: {
+        type: "string",
+        enum: ["drift", "dead-code", "patterns", "all"],
+        description: "Type of entropy to detect (default: all)"
+      },
+      autoFix: {
+        type: "boolean",
+        description: "When true, apply fixes after analysis. Default: false (analysis only)"
+      },
+      dryRun: {
+        type: "boolean",
+        description: "Preview fixes without applying (only used when autoFix is true)"
+      },
+      fixTypes: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: [
+            "unused-imports",
+            "dead-files",
+            "dead-exports",
+            "commented-code",
+            "orphaned-deps",
+            "forbidden-import-replacement",
+            "import-ordering"
+          ]
+        },
+        description: "Specific fix types to apply (default: all safe types). Only used when autoFix is true."
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density: summary returns issue counts and top issues per category, detailed returns full findings. Default: detailed"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleDetectEntropy(input) {
+  try {
+    const { EntropyAnalyzer } = await import("./dist-JVZ2MKBC.js");
+    const typeFilter = input.type ?? "all";
+    const analyzer = new EntropyAnalyzer({
+      rootDir: sanitizePath(input.path),
+      analyze: {
+        drift: typeFilter === "all" || typeFilter === "drift",
+        deadCode: typeFilter === "all" || typeFilter === "dead-code",
+        patterns: typeFilter === "all" || typeFilter === "patterns"
+      }
+    });
+    const graphOptions = await loadEntropyGraphOptions(sanitizePath(input.path));
+    const result = await analyzer.analyze(graphOptions);
+    if (input.mode === "summary" && result.ok && !input.autoFix) {
+      const report2 = result.value;
+      const summary = {};
+      if (report2.drift) {
+        const driftIssues = (report2.drift.drifts ?? []).map(
+          (d) => `Drift: ${d.type}${d.file ? ` in ${d.file}` : ""}`
+        );
+        summary["drift"] = {
+          issueCount: driftIssues.length,
+          topIssues: driftIssues.slice(0, 3)
+        };
+      }
+      if (report2.deadCode) {
+        const deadIssues = [
+          ...(report2.deadCode.unusedImports ?? []).map(
+            (i) => `Unused import: ${i.specifiers.join(", ")} from ${i.source}`
+          ),
+          ...(report2.deadCode.deadExports ?? []).map((e) => `Dead export: ${e.name} in ${e.file}`),
+          ...(report2.deadCode.deadFiles ?? []).map((f) => `Dead file: ${f.path}`)
+        ];
+        summary["deadCode"] = {
+          issueCount: deadIssues.length,
+          topIssues: deadIssues.slice(0, 3)
+        };
+      }
+      if (report2.patterns) {
+        const patternIssues = (report2.patterns.violations ?? []).map(
+          (v) => `${v.pattern}: ${v.file}`
+        );
+        summary["patterns"] = {
+          issueCount: patternIssues.length,
+          topIssues: patternIssues.slice(0, 3)
+        };
+      }
+      const totalIssues = Object.values(summary).reduce((s, c) => s + c.issueCount, 0);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ mode: "summary", totalIssues, categories: summary })
+          }
+        ]
+      };
+    }
+    if (!input.autoFix) {
+      return resultToMcpResponse(result);
+    }
+    if (!result.ok) return resultToMcpResponse(result);
+    const { createFixes, applyFixes, generateSuggestions } = await import("./dist-JVZ2MKBC.js");
+    const report = result.value;
+    const deadCode = report.deadCode;
+    const fixTypesConfig = input.fixTypes ? { fixTypes: input.fixTypes } : void 0;
+    const fixes = deadCode ? createFixes(deadCode, fixTypesConfig) : [];
+    const suggestions = generateSuggestions(report.deadCode, report.drift, report.patterns);
+    if (input.dryRun) {
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ analysis: report, fixes, suggestions }) }
+        ]
+      };
+    }
+    if (fixes.length > 0) {
+      const applied = await applyFixes(fixes, {});
+      if (!applied.ok) return resultToMcpResponse(applied);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ analysis: report, ...applied.value, suggestions })
+          }
+        ]
+      };
+    }
+    return resultToMcpResponse(Ok({ analysis: report, fixes: [], applied: 0, suggestions }));
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  detectEntropyDefinition,
+  handleDetectEntropy
+};

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