@harness-engineering/cli 1.23.2 → 1.24.1

package/dist/chunk-TDLOFNNQ.js

@@ -0,0 +1,62 @@
+// src/mcp/utils/graph-loader.ts
+import * as path from "path";
+import { stat } from "fs/promises";
+var MAX_CACHE_ENTRIES = 8;
+var cache = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Map();
+function clearGraphStoreCache() {
+  cache.clear();
+  pending.clear();
+}
+function evictIfNeeded() {
+  if (cache.size > MAX_CACHE_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+}
+async function doLoadGraphStore(projectRoot) {
+  const { GraphStore } = await import("./dist-QW5G3GX3.js");
+  const graphDir = path.join(projectRoot, ".harness", "graph");
+  const store = new GraphStore();
+  const loaded = await store.load(graphDir);
+  if (!loaded) return null;
+  return store;
+}
+async function loadGraphStore(projectRoot) {
+  const graphDir = path.join(projectRoot, ".harness", "graph");
+  const graphPath = path.join(graphDir, "graph.json");
+  let mtimeMs;
+  try {
+    const stats = await stat(graphPath);
+    mtimeMs = stats.mtimeMs;
+  } catch {
+    return null;
+  }
+  const cached = cache.get(projectRoot);
+  if (cached && cached.mtimeMs === mtimeMs) {
+    return cached.store;
+  }
+  const pendingLoad = pending.get(projectRoot);
+  let promise;
+  if (pendingLoad && pendingLoad.mtimeMs === mtimeMs) {
+    promise = pendingLoad.promise;
+  } else {
+    promise = doLoadGraphStore(projectRoot);
+    pending.set(projectRoot, { promise, mtimeMs });
+  }
+  const store = await promise;
+  const currentPending = pending.get(projectRoot);
+  if (currentPending && currentPending.promise === promise) {
+    pending.delete(projectRoot);
+  }
+  if (store !== null) {
+    cache.set(projectRoot, { store, mtimeMs });
+    evictIfNeeded();
+  }
+  return store;
+}
+
+export {
+  clearGraphStoreCache,
+  loadGraphStore
+};

package/dist/chunk-TUJAHI22.js

@@ -0,0 +1,130 @@
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+import {
+  findConfigFile,
+  loadConfig
+} from "./chunk-AVVJ5EUU.js";
+import {
+  Ok
+} from "./chunk-5LMZA5LZ.js";
+
+// src/mcp/tools/docs.ts
+import * as path from "path";
+function resolveDocsDir(projectPath) {
+  const configResult = findConfigFile(projectPath);
+  if (configResult.ok) {
+    const config = loadConfig(configResult.value);
+    if (config.ok) {
+      return path.resolve(projectPath, config.value.docsDir);
+    }
+  }
+  return path.resolve(projectPath, "docs");
+}
+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-TZQUURSP.js");
+      const result2 = await validateKnowledgeMap(projectPath);
+      return resultToMcpResponse(result2);
+    }
+    if (scope === "all") {
+      const { checkDocCoverage: checkDocCoverage2, validateKnowledgeMap } = await import("./dist-TZQUURSP.js");
+      const domain2 = input.domain ?? "src";
+      const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-M6FXJAKK.js");
+      const store2 = await loadGraphStore2(projectPath);
+      let graphCoverage2;
+      if (store2) {
+        const { Assembler } = await import("./dist-QW5G3GX3.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: resolveDocsDir(projectPath),
+          ...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-TZQUURSP.js");
+    const domain = input.domain ?? "src";
+    const { loadGraphStore } = await import("./graph-loader-M6FXJAKK.js");
+    const store = await loadGraphStore(projectPath);
+    let graphCoverage;
+    if (store) {
+      const { Assembler } = await import("./dist-QW5G3GX3.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: resolveDocsDir(projectPath),
+      ...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
+};

package/dist/chunk-UQEUYRBP.js

@@ -0,0 +1,125 @@
+import {
+  resolveSkillsDir
+} from "./chunk-6B6UN6SG.js";
+import {
+  SkillMetadataSchema
+} from "./chunk-ZOVATVQC.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-W2OZK3KC.js

@@ -0,0 +1,250 @@
+import {
+  resolveConfig
+} from "./chunk-AVVJ5EUU.js";
+import {
+  Ok
+} from "./chunk-5LMZA5LZ.js";
+import {
+  logger
+} from "./chunk-EBJQ6N4M.js";
+import {
+  ExitCode
+} from "./chunk-3WGJMBKH.js";
+
+// src/commands/check-phase-gate.ts
+import { Command } from "commander";
+import * as path from "path";
+import * as fs from "fs";
+
+// src/utils/files.ts
+import { glob } from "glob";
+async function findFiles(pattern, cwd = process.cwd()) {
+  return glob(pattern, { cwd, absolute: true });
+}
+
+// src/output/formatter.ts
+import chalk from "chalk";
+var OutputMode = {
+  /** Output as formatted JSON */
+  JSON: "json",
+  /** Output as human-readable text */
+  TEXT: "text",
+  /** Minimal output, only errors and successes */
+  QUIET: "quiet",
+  /** Full output with detailed context and suggestions */
+  VERBOSE: "verbose"
+};
+function appendIssueLines(lines, issue, mode) {
+  const location = issue.file ? issue.line ? `${issue.file}:${issue.line}` : issue.file : "unknown";
+  lines.push(`  ${chalk.yellow("*")} ${chalk.dim(location)}`);
+  lines.push(`    ${issue.message}`);
+  if (issue.suggestion && mode === OutputMode.VERBOSE) {
+    lines.push(`    ${chalk.dim("->")} ${issue.suggestion}`);
+  }
+}
+var OutputFormatter = class {
+  /**
+   * Creates a new OutputFormatter.
+   *
+   * @param mode - The output mode to use. Defaults to TEXT.
+   */
+  constructor(mode = OutputMode.TEXT) {
+    this.mode = mode;
+  }
+  mode;
+  /**
+   * Formats raw data for output.
+   *
+   * @param data - The data to format.
+   * @returns A string representation of the data based on the current mode.
+   */
+  format(data) {
+    if (this.mode === OutputMode.JSON) {
+      return JSON.stringify(data, null, 2);
+    }
+    return String(data);
+  }
+  /**
+   * Formats a validation result into a user-friendly string.
+   *
+   * @param result - The validation result to format.
+   * @returns A formatted string containing the validation status and any issues.
+   */
+  formatValidation(result) {
+    if (this.mode === OutputMode.JSON) {
+      return JSON.stringify(result, null, 2);
+    }
+    if (this.mode === OutputMode.QUIET) {
+      if (result.valid) return "";
+      return result.issues.map((i) => `${i.file ?? ""}: ${i.message}`).join("\n");
+    }
+    const lines = [];
+    if (result.valid) {
+      lines.push(chalk.green("v validation passed"));
+    } else {
+      lines.push(chalk.red(`x Validation failed (${result.issues.length} issues)`));
+      lines.push("");
+      for (const issue of result.issues) {
+        appendIssueLines(lines, issue, this.mode);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Formats a summary line with a success/failure icon and label.
+   *
+   * @param label - The name of the field to summarize.
+   * @param value - The value to display.
+   * @param success - Whether the summary represents a success or failure state.
+   * @returns A formatted summary string, or an empty string in JSON or QUIET modes.
+   */
+  formatSummary(label, value, success) {
+    if (this.mode === OutputMode.JSON || this.mode === OutputMode.QUIET) {
+      return "";
+    }
+    const icon = success ? chalk.green("v") : chalk.red("x");
+    return `${icon} ${label}: ${value}`;
+  }
+};
+
+// src/commands/check-phase-gate.ts
+function resolveSpecPath(implFile, implPattern, specPattern, cwd) {
+  const relImpl = path.relative(cwd, implFile).replace(/\\/g, "/");
+  const implBase = (implPattern.split("*")[0] ?? "").replace(/\/+$/, "");
+  const afterBase = relImpl.startsWith(implBase + "/") ? relImpl.slice(implBase.length + 1) : relImpl;
+  const segments = afterBase.split("/");
+  const firstSegment = segments[0] ?? "";
+  const feature = segments.length > 1 ? firstSegment : path.basename(firstSegment, path.extname(firstSegment));
+  const specRelative = specPattern.replace("{feature}", feature);
+  return path.resolve(cwd, specRelative);
+}
+function checkSpecContent(specPath, relImpl, relSpec, missingSpecs) {
+  const content = fs.readFileSync(specPath, "utf-8");
+  const sectionPattern = /^#+\s*(Observable Truths|Success Criteria|Acceptance Criteria)/im;
+  const sectionMatch = sectionPattern.exec(content);
+  if (!sectionMatch) {
+    missingSpecs.push({
+      implFile: relImpl,
+      expectedSpec: `${relSpec} (missing requirements section: expected Observable Truths, Success Criteria, or Acceptance Criteria heading)`
+    });
+    return;
+  }
+  const sectionStart = sectionMatch.index + sectionMatch[0].length;
+  const nextHeadingMatch = /^#+\s/m.exec(content.slice(sectionStart));
+  const sectionContent = nextHeadingMatch ? content.slice(sectionStart, sectionStart + nextHeadingMatch.index) : content.slice(sectionStart);
+  if (!/^\s*\d+\.\s+/m.test(sectionContent)) {
+    missingSpecs.push({
+      implFile: relImpl,
+      expectedSpec: `${relSpec} (requirements section "${sectionMatch[1]}" has no numbered items)`
+    });
+  }
+}
+async function runCheckPhaseGate(options) {
+  const configResult = resolveConfig(options.configPath);
+  if (!configResult.ok) {
+    return configResult;
+  }
+  const config = configResult.value;
+  const cwd = options.cwd ?? (options.configPath ? path.dirname(path.resolve(options.configPath)) : process.cwd());
+  if (!config.phaseGates?.enabled) {
+    return Ok({
+      pass: true,
+      skipped: true,
+      missingSpecs: [],
+      checkedFiles: 0
+    });
+  }
+  const phaseGates = config.phaseGates;
+  const missingSpecs = [];
+  let checkedFiles = 0;
+  for (const mapping of phaseGates.mappings) {
+    const implFiles = await findFiles(mapping.implPattern, cwd);
+    for (const implFile of implFiles) {
+      checkedFiles++;
+      const expectedSpec = resolveSpecPath(implFile, mapping.implPattern, mapping.specPattern, cwd);
+      const relImpl = path.relative(cwd, implFile).replace(/\\/g, "/");
+      const relSpec = path.relative(cwd, expectedSpec).replace(/\\/g, "/");
+      if (!fs.existsSync(expectedSpec)) {
+        missingSpecs.push({ implFile: relImpl, expectedSpec: relSpec });
+      } else if (mapping.contentValidation) {
+        checkSpecContent(expectedSpec, relImpl, relSpec, missingSpecs);
+      }
+    }
+  }
+  const pass = missingSpecs.length === 0;
+  return Ok({
+    pass,
+    skipped: false,
+    severity: phaseGates.severity,
+    missingSpecs,
+    checkedFiles
+  });
+}
+function resolvePhaseGateOutputMode(globalOpts) {
+  if (globalOpts.json) return OutputMode.JSON;
+  if (globalOpts.quiet) return OutputMode.QUIET;
+  if (globalOpts.verbose) return OutputMode.VERBOSE;
+  return OutputMode.TEXT;
+}
+function handlePhaseGateError(error, mode) {
+  if (mode === OutputMode.JSON) {
+    console.log(JSON.stringify({ error: error.message }));
+  } else {
+    logger.error(error.message);
+  }
+  process.exit(error.exitCode);
+}
+function handlePhaseGateSkipped(value, mode, formatter) {
+  if (mode === OutputMode.JSON) {
+    console.log(formatter.format(value));
+  } else if (mode !== OutputMode.QUIET) {
+    logger.dim("Phase gates not enabled, skipping.");
+  }
+  process.exit(ExitCode.SUCCESS);
+}
+function printPhaseGateResult(value, formatter) {
+  const output = formatter.formatValidation({
+    valid: value.pass,
+    issues: value.missingSpecs.map((m) => ({
+      file: m.implFile,
+      message: `Missing spec: ${m.expectedSpec}`
+    }))
+  });
+  if (output) console.log(output);
+  const summary = formatter.formatSummary(
+    "Phase gate check",
+    `${value.checkedFiles} files checked, ${value.missingSpecs.length} missing specs`,
+    value.pass
+  );
+  if (summary) console.log(summary);
+}
+function createCheckPhaseGateCommand() {
+  const command = new Command("check-phase-gate").description("Verify that implementation files have matching spec documents").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const mode = resolvePhaseGateOutputMode(globalOpts);
+    const formatter = new OutputFormatter(mode);
+    const result = await runCheckPhaseGate({
+      configPath: globalOpts.config,
+      json: globalOpts.json,
+      verbose: globalOpts.verbose,
+      quiet: globalOpts.quiet
+    });
+    if (!result.ok) handlePhaseGateError(result.error, mode);
+    const value = result.value;
+    if (value.skipped) handlePhaseGateSkipped(value, mode, formatter);
+    printPhaseGateResult(value, formatter);
+    if (!value.pass && value.severity === "error") {
+      process.exit(ExitCode.VALIDATION_FAILED);
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+  return command;
+}
+
+export {
+  OutputMode,
+  OutputFormatter,
+  findFiles,
+  runCheckPhaseGate,
+  createCheckPhaseGateCommand
+};