@harness-engineering/cli 1.23.2 → 1.24.0

package/dist/chunk-2DHX6TAP.js

@@ -1,85 +0,0 @@
-import {
-  resolveProjectConfig
-} from "./chunk-Q3XYV5UC.js";
-import {
-  resultToMcpResponse
-} from "./chunk-IDZNPTYD.js";
-import {
-  sanitizePath
-} from "./chunk-W6Y7ZW3Y.js";
-
-// src/mcp/tools/architecture.ts
-var checkDependenciesDefinition = {
-  name: "check_dependencies",
-  description: "Validate layer boundaries and detect circular dependencies",
-  inputSchema: {
-    type: "object",
-    properties: {
-      path: { type: "string", description: "Path to project root" }
-    },
-    required: ["path"]
-  }
-};
-async function handleCheckDependencies(input) {
-  let projectPath;
-  try {
-    projectPath = sanitizePath(input.path);
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ],
-      isError: true
-    };
-  }
-  const configResult = resolveProjectConfig(projectPath);
-  if (!configResult.ok) return resultToMcpResponse(configResult);
-  try {
-    const { validateDependencies, TypeScriptParser } = await import("./dist-MKWF5CXR.js");
-    const config = configResult.value;
-    const rawLayers = Array.isArray(config.layers) ? config.layers : [];
-    const layers = rawLayers.map((l) => ({
-      name: l.name,
-      patterns: [l.pattern],
-      allowedDependencies: l.allowedDependencies
-    }));
-    const parser = new TypeScriptParser();
-    const { loadGraphStore } = await import("./graph-loader-BJULJYGG.js");
-    const store = await loadGraphStore(projectPath);
-    let graphDependencyData;
-    if (store) {
-      const { GraphConstraintAdapter } = await import("./dist-WU3TVNNG.js");
-      const adapter = new GraphConstraintAdapter(store);
-      const graphData = adapter.computeDependencyGraph();
-      graphDependencyData = {
-        nodes: [...graphData.nodes],
-        edges: graphData.edges.map((e) => ({ ...e }))
-      };
-    }
-    const result = await validateDependencies({
-      layers,
-      rootDir: projectPath,
-      parser,
-      ...graphDependencyData !== void 0 && { graphDependencyData }
-    });
-    return resultToMcpResponse(result);
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ],
-      isError: true
-    };
-  }
-}
-
-export {
-  checkDependenciesDefinition,
-  handleCheckDependencies
-};

package/dist/chunk-2GT3HO2T.js

@@ -1,103 +0,0 @@
-import {
-  resolveProjectConfig
-} from "./chunk-Q3XYV5UC.js";
-import {
-  sanitizePath
-} from "./chunk-W6Y7ZW3Y.js";
-
-// src/mcp/tools/validate.ts
-import * as path from "path";
-var validateToolDefinition = {
-  name: "validate_project",
-  description: "Run all validation checks on a harness engineering project",
-  inputSchema: {
-    type: "object",
-    properties: {
-      path: { type: "string", description: "Path to project root directory" }
-    },
-    required: ["path"]
-  }
-};
-async function handleValidateProject(input) {
-  let projectPath;
-  try {
-    projectPath = sanitizePath(input.path);
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ],
-      isError: true
-    };
-  }
-  const errors = [];
-  const checks = {
-    config: "fail",
-    structure: "skipped",
-    agentsMap: "skipped"
-  };
-  const configResult = resolveProjectConfig(projectPath);
-  if (!configResult.ok) {
-    errors.push(`Config: ${configResult.error.message}`);
-    return {
-      content: [{ type: "text", text: JSON.stringify({ valid: false, checks, errors }) }]
-    };
-  }
-  checks.config = "pass";
-  const config = configResult.value;
-  try {
-    const core = await import("./dist-MKWF5CXR.js");
-    if (typeof core.validateFileStructure === "function" && Array.isArray(config.conventions)) {
-      const conventions = config.conventions;
-      const structureResult = await core.validateFileStructure(projectPath, conventions);
-      if (structureResult.ok) {
-        checks.structure = structureResult.value.valid ? "pass" : "fail";
-        if (!structureResult.value.valid) {
-          for (const missing of structureResult.value.missing) {
-            errors.push(`Missing required file: ${missing}`);
-          }
-        }
-      } else {
-        checks.structure = "fail";
-        errors.push(`Structure validation error: ${structureResult.error.message}`);
-      }
-    }
-  } catch {
-  }
-  try {
-    const core = await import("./dist-MKWF5CXR.js");
-    if (typeof core.validateAgentsMap === "function") {
-      const agentsMapPath = path.join(projectPath, "AGENTS.md");
-      const agentsResult = await core.validateAgentsMap(agentsMapPath);
-      if (agentsResult.ok) {
-        checks.agentsMap = agentsResult.value.valid ? "pass" : "fail";
-        if (!agentsResult.value.valid) {
-          if (agentsResult.value.missingSections.length > 0) {
-            errors.push(
-              `AGENTS.md missing sections: ${agentsResult.value.missingSections.join(", ")}`
-            );
-          }
-          if (agentsResult.value.brokenLinks.length > 0) {
-            errors.push(`AGENTS.md has ${agentsResult.value.brokenLinks.length} broken link(s)`);
-          }
-        }
-      } else {
-        checks.agentsMap = "fail";
-        errors.push(`AGENTS.md validation error: ${agentsResult.error.message}`);
-      }
-    }
-  } catch {
-  }
-  const valid = errors.length === 0;
-  return {
-    content: [{ type: "text", text: JSON.stringify({ valid, checks, errors }) }]
-  };
-}
-
-export {
-  validateToolDefinition,
-  handleValidateProject
-};

package/dist/chunk-2PAPHA77.js

@@ -1,125 +0,0 @@
-import {
-  resolveSkillsDir
-} from "./chunk-N5G5QMS3.js";
-import {
-  SkillMetadataSchema
-} from "./chunk-SE4YPMLH.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-2YA4XRI3.js

@@ -1,187 +0,0 @@
-import {
-  resultToMcpResponse
-} from "./chunk-IDZNPTYD.js";
-import {
-  sanitizePath
-} from "./chunk-W6Y7ZW3Y.js";
-import {
-  Ok
-} from "./chunk-5LMZA5LZ.js";
-
-// src/mcp/tools/entropy.ts
-async function loadEntropyGraphOptions(projectPath) {
-  const { loadGraphStore } = await import("./graph-loader-BJULJYGG.js");
-  const store = await loadGraphStore(projectPath);
-  if (!store) return void 0;
-  const { GraphEntropyAdapter } = await import("./dist-WU3TVNNG.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"]
-  }
-};
-function summarizeDrift(drift) {
-  const driftIssues = (drift.drifts ?? []).map(
-    (d) => `Drift: ${d.type}${d.file ? ` in ${d.file}` : ""}`
-  );
-  return { issueCount: driftIssues.length, topIssues: driftIssues.slice(0, 3) };
-}
-function summarizeDeadCode(deadCode) {
-  const deadIssues = [
-    ...(deadCode.unusedImports ?? []).map(
-      (i) => `Unused import: ${i.specifiers.join(", ")} from ${i.source}`
-    ),
-    ...(deadCode.deadExports ?? []).map(
-      (e) => `Dead export: ${e.name} in ${e.file}`
-    ),
-    ...(deadCode.deadFiles ?? []).map((f) => `Dead file: ${f.path}`)
-  ];
-  return { issueCount: deadIssues.length, topIssues: deadIssues.slice(0, 3) };
-}
-function summarizePatterns(patterns) {
-  const patternIssues = (patterns.violations ?? []).map(
-    (v) => `${v.pattern}: ${v.file}`
-  );
-  return { issueCount: patternIssues.length, topIssues: patternIssues.slice(0, 3) };
-}
-function buildSummaryResponse(report) {
-  const summary = {};
-  if (report.drift) summary["drift"] = summarizeDrift(report.drift);
-  if (report.deadCode) summary["deadCode"] = summarizeDeadCode(report.deadCode);
-  if (report.patterns) summary["patterns"] = summarizePatterns(report.patterns);
-  const totalIssues = Object.values(summary).reduce((s, c) => s + c.issueCount, 0);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({ mode: "summary", totalIssues, categories: summary })
-      }
-    ]
-  };
-}
-async function handleDetectEntropy(input) {
-  try {
-    const { EntropyAnalyzer } = await import("./dist-MKWF5CXR.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) {
-      return buildSummaryResponse(result.value);
-    }
-    if (!input.autoFix) {
-      return resultToMcpResponse(result);
-    }
-    if (!result.ok) return resultToMcpResponse(result);
-    const { createFixes, applyFixes, generateSuggestions } = await import("./dist-MKWF5CXR.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-35EQ5UEI.js

@@ -1,73 +0,0 @@
-import {
-  Ok
-} from "./chunk-5LMZA5LZ.js";
-
-// src/commands/validate-cross-check.ts
-import * as fs from "fs";
-import * as path from "path";
-import { execFileSync } from "child_process";
-function findFiles(dir, ext) {
-  if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir).filter((f) => f.endsWith(ext)).map((f) => path.join(dir, f));
-}
-function extractPlannedFiles(planContent) {
-  const files = [];
-  const regex = /- (?:Create|Modify):\s*`([^`]+)`/g;
-  let match;
-  while ((match = regex.exec(planContent)) !== null) {
-    if (match[1]) files.push(match[1]);
-  }
-  return files;
-}
-function getFileModTime(filePath, projectPath) {
-  try {
-    const output = execFileSync("git", ["log", "-1", "--format=%aI", "--", filePath], {
-      cwd: projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return output ? new Date(output) : null;
-  } catch {
-    return null;
-  }
-}
-async function runCrossCheck(options) {
-  const result = {
-    specToPlan: [],
-    planToImpl: [],
-    staleness: [],
-    warnings: 0
-  };
-  const planFiles = findFiles(options.plansDir, ".md");
-  for (const planFile of planFiles) {
-    const content = fs.readFileSync(planFile, "utf-8");
-    const plannedFiles = extractPlannedFiles(content);
-    const planName = path.basename(planFile);
-    for (const file of plannedFiles) {
-      const fullPath = path.join(options.projectPath, file);
-      if (!fs.existsSync(fullPath)) {
-        result.planToImpl.push(`${planName}: planned file not found: ${file}`);
-        result.warnings++;
-      }
-    }
-    const planModTime = getFileModTime(planFile, options.projectPath);
-    if (planModTime) {
-      for (const file of plannedFiles) {
-        const fullPath = path.join(options.projectPath, file);
-        if (fs.existsSync(fullPath)) {
-          const implModTime = getFileModTime(fullPath, options.projectPath);
-          if (implModTime && implModTime > planModTime) {
-            result.staleness.push(`${planName}: implementation newer than plan (${file})`);
-            result.warnings++;
-            break;
-          }
-        }
-      }
-    }
-  }
-  return Ok(result);
-}
-
-export {
-  runCrossCheck
-};