@harness-engineering/cli 1.8.2 → 1.10.0

package/dist/chunk-CWZ4Y2PO.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-RLO3KRIX.js");
+  const store = await loadGraphStore(projectPath);
+  if (!store) return void 0;
+  const { GraphEntropyAdapter } = await import("./dist-I7DB5VKB.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-PBTNVK6K.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-PBTNVK6K.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-ULSRSP53.js → chunk-ECUJQS3B.js}

@@ -1,115 +1,19 @@
+import {
+  logger
+} from "./chunk-HIOXKZYF.js";
+import {
+  CLIError,
+  ExitCode
+} from "./chunk-B7HFEHWP.js";
+import {
+  ALLOWED_COGNITIVE_MODES
+} from "./chunk-MDUK2J2O.js";
+
 // src/commands/create-skill.ts
 import { Command } from "commander";
 import * as path from "path";
 import * as fs from "fs";
 import YAML from "yaml";
-
-// src/skill/schema.ts
-import { z } from "zod";
-var SkillPhaseSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  required: z.boolean().default(true)
-});
-var SkillCliSchema = z.object({
-  command: z.string(),
-  args: z.array(
-    z.object({
-      name: z.string(),
-      description: z.string(),
-      required: z.boolean().default(false)
-    })
-  ).default([])
-});
-var SkillMcpSchema = z.object({
-  tool: z.string(),
-  input: z.record(z.string())
-});
-var SkillStateSchema = z.object({
-  persistent: z.boolean().default(false),
-  files: z.array(z.string()).default([])
-});
-var ALLOWED_TRIGGERS = [
-  "manual",
-  "on_pr",
-  "on_commit",
-  "on_new_feature",
-  "on_bug_fix",
-  "on_refactor",
-  "on_project_init",
-  "on_review",
-  "on_milestone",
-  "on_task_complete",
-  "on_doc_check"
-];
-var ALLOWED_PLATFORMS = ["claude-code", "gemini-cli"];
-var ALLOWED_COGNITIVE_MODES = [
-  "adversarial-reviewer",
-  "constructive-architect",
-  "meticulous-implementer",
-  "diagnostic-investigator",
-  "advisory-guide",
-  "meticulous-verifier"
-];
-var SkillMetadataSchema = z.object({
-  name: z.string().regex(/^[a-z][a-z0-9-]*$/, "Name must be lowercase with hyphens"),
-  version: z.string().regex(/^\d+\.\d+\.\d+$/, "Version must be semver format"),
-  description: z.string(),
-  cognitive_mode: z.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "Cognitive mode must be kebab-case").optional(),
-  triggers: z.array(z.enum(ALLOWED_TRIGGERS)),
-  platforms: z.array(z.enum(ALLOWED_PLATFORMS)),
-  tools: z.array(z.string()),
-  cli: SkillCliSchema.optional(),
-  mcp: SkillMcpSchema.optional(),
-  type: z.enum(["rigid", "flexible"]),
-  phases: z.array(SkillPhaseSchema).optional(),
-  state: SkillStateSchema.default({}),
-  depends_on: z.array(z.string()).default([])
-});
-
-// 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))
-};
-
-// src/utils/errors.ts
-var ExitCode = {
-  SUCCESS: 0,
-  VALIDATION_FAILED: 1,
-  ERROR: 2
-};
-var CLIError = class extends Error {
-  exitCode;
-  constructor(message, exitCode = ExitCode.ERROR) {
-    super(message);
-    this.name = "CLIError";
-    this.exitCode = exitCode;
-  }
-};
-function formatError(error) {
-  if (error instanceof CLIError) {
-    return `Error: ${error.message}`;
-  }
-  if (error instanceof Error) {
-    return `Error: ${error.message}`;
-  }
-  return `Error: ${String(error)}`;
-}
-function handleError(error) {
-  const message = formatError(error);
-  console.error(message);
-  const exitCode = error instanceof CLIError ? error.exitCode : ExitCode.ERROR;
-  process.exit(exitCode);
-}
-
-// src/commands/create-skill.ts
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function buildSkillYaml(opts) {
   const doc = {
@@ -258,11 +162,6 @@ function createCreateSkillCommand() {
 }
 
 export {
-  ExitCode,
-  CLIError,
-  handleError,
-  logger,
-  SkillMetadataSchema,
   generateSkillFiles,
   createCreateSkillCommand
 };

package/dist/chunk-EOLRW32Q.js

@@ -0,0 +1,72 @@
+// 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");
+}
+
+export {
+  resolveTemplatesDir,
+  resolvePersonasDir,
+  resolveSkillsDir,
+  resolveProjectSkillsDir,
+  resolveGlobalSkillsDir
+};

package/dist/chunk-F3YDAJFQ.js

@@ -0,0 +1,125 @@
+import {
+  resolveSkillsDir
+} from "./chunk-EOLRW32Q.js";
+import {
+  SkillMetadataSchema
+} from "./chunk-MDUK2J2O.js";
+
+// src/persona/skill-executor.ts
+import * as fs from "fs";
+import * as path from "path";
+import { parse } from "yaml";
+function resolveOutputMode(mode, trigger) {
+  if (mode !== "auto") return mode;
+  return trigger === "manual" ? "inline" : "artifact";
+}
+function buildArtifactPath(projectPath, headSha) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const sha = headSha?.slice(0, 7) ?? "unknown";
+  return path.join(projectPath, ".harness", "reviews", `${date}-${sha}.md`);
+}
+function buildArtifactContent(skillName, trigger, headSha) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return [
+    "---",
+    `skill: ${skillName}`,
+    `trigger: ${trigger}`,
+    `sha: ${headSha?.slice(0, 7) ?? "unknown"}`,
+    `date: ${date}`,
+    `assessment: pending`,
+    "---",
+    "",
+    `# Review by ${skillName}`,
+    "",
+    "## Strengths",
+    "",
+    "- (review pending)",
+    "",
+    "## Issues",
+    "",
+    "### Critical",
+    "",
+    "- None identified",
+    "",
+    "### Important",
+    "",
+    "- None identified",
+    "",
+    "### Suggestions",
+    "",
+    "- None identified",
+    "",
+    "## Assessment",
+    "",
+    "Pending \u2014 skill execution scaffolded.",
+    "",
+    "## Harness Checks",
+    "",
+    "- (run harness validate, check-deps, check-docs to populate)",
+    ""
+  ].join("\n");
+}
+async function executeSkill(skillName, context) {
+  const startTime = Date.now();
+  const skillsDir = resolveSkillsDir();
+  const skillDir = path.join(skillsDir, skillName);
+  if (!fs.existsSync(skillDir)) {
+    return {
+      status: "fail",
+      output: `Skill not found: ${skillName}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const yamlPath = path.join(skillDir, "skill.yaml");
+  if (!fs.existsSync(yamlPath)) {
+    return {
+      status: "fail",
+      output: `skill.yaml not found for ${skillName}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const raw = fs.readFileSync(yamlPath, "utf-8");
+  const parsed = parse(raw);
+  const metadataResult = SkillMetadataSchema.safeParse(parsed);
+  if (!metadataResult.success) {
+    return {
+      status: "fail",
+      output: `Invalid skill metadata: ${metadataResult.error.message}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const skillMdPath = path.join(skillDir, "SKILL.md");
+  if (!fs.existsSync(skillMdPath)) {
+    return {
+      status: "fail",
+      output: `SKILL.md not found for ${skillName}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const skillContent = fs.readFileSync(skillMdPath, "utf-8");
+  const metadata = metadataResult.data;
+  const resolvedMode = resolveOutputMode(context.outputMode, context.trigger);
+  const output = `Skill ${metadata.name} (${metadata.type}) loaded.
+Cognitive mode: ${metadata.cognitive_mode ?? "default"}
+Content length: ${skillContent.length} chars
+Trigger: ${context.trigger}
+`;
+  let artifactPath;
+  if (resolvedMode === "artifact") {
+    artifactPath = buildArtifactPath(context.projectPath, context.headSha);
+    const artifactContent = buildArtifactContent(skillName, context.trigger, context.headSha);
+    const dir = path.dirname(artifactPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(artifactPath, artifactContent, "utf-8");
+  }
+  return {
+    status: "pass",
+    output,
+    ...artifactPath ? { artifactPath } : {},
+    durationMs: Date.now() - startTime
+  };
+}
+
+export {
+  executeSkill
+};

package/dist/chunk-F4PTVZWA.js

@@ -0,0 +1,116 @@
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+import {
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/mcp/tools/docs.ts
+import * as path from "path";
+var checkDocsDefinition = {
+  name: "check_docs",
+  description: "Analyze documentation coverage and/or validate knowledge map integrity",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      domain: { type: "string", description: "Domain/module to check" },
+      scope: {
+        type: "string",
+        enum: ["coverage", "integrity", "all"],
+        description: "Scope of check: 'coverage' (doc coverage), 'integrity' (knowledge map validation), 'all' (both). Default: 'coverage'"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleCheckDocs(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const scope = input.scope ?? "coverage";
+    if (scope === "integrity") {
+      const { validateKnowledgeMap } = await import("./dist-PBTNVK6K.js");
+      const result2 = await validateKnowledgeMap(projectPath);
+      return resultToMcpResponse(result2);
+    }
+    if (scope === "all") {
+      const { checkDocCoverage: checkDocCoverage2, validateKnowledgeMap } = await import("./dist-PBTNVK6K.js");
+      const domain2 = input.domain ?? "src";
+      const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-RLO3KRIX.js");
+      const store2 = await loadGraphStore2(projectPath);
+      let graphCoverage2;
+      if (store2) {
+        const { Assembler } = await import("./dist-I7DB5VKB.js");
+        const assembler = new Assembler(store2);
+        const report = assembler.checkCoverage();
+        graphCoverage2 = {
+          documented: [...report.documented],
+          undocumented: [...report.undocumented],
+          coveragePercentage: report.coveragePercentage
+        };
+      }
+      const [coverageResult, integrityResult] = await Promise.allSettled([
+        checkDocCoverage2(domain2, {
+          sourceDir: path.resolve(projectPath, "src"),
+          docsDir: path.resolve(projectPath, "docs"),
+          ...graphCoverage2 !== void 0 && { graphCoverage: graphCoverage2 }
+        }),
+        validateKnowledgeMap(projectPath)
+      ]);
+      let coverage;
+      if (coverageResult.status === "fulfilled") {
+        const r = coverageResult.value;
+        coverage = r.ok ? r.value : { error: r.error };
+      } else {
+        coverage = { error: String(coverageResult.reason) };
+      }
+      let integrity;
+      if (integrityResult.status === "fulfilled") {
+        const r = integrityResult.value;
+        integrity = r.ok ? r.value : { error: r.error };
+      } else {
+        integrity = { error: String(integrityResult.reason) };
+      }
+      return resultToMcpResponse(Ok({ coverage, integrity }));
+    }
+    const { checkDocCoverage } = await import("./dist-PBTNVK6K.js");
+    const domain = input.domain ?? "src";
+    const { loadGraphStore } = await import("./graph-loader-RLO3KRIX.js");
+    const store = await loadGraphStore(projectPath);
+    let graphCoverage;
+    if (store) {
+      const { Assembler } = await import("./dist-I7DB5VKB.js");
+      const assembler = new Assembler(store);
+      const report = assembler.checkCoverage();
+      graphCoverage = {
+        documented: [...report.documented],
+        undocumented: [...report.undocumented],
+        coveragePercentage: report.coveragePercentage
+      };
+    }
+    const result = await checkDocCoverage(domain, {
+      sourceDir: path.resolve(projectPath, "src"),
+      docsDir: path.resolve(projectPath, "docs"),
+      ...graphCoverage !== void 0 && { graphCoverage }
+    });
+    return resultToMcpResponse(result);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  checkDocsDefinition,
+  handleCheckDocs
+};