@harness-engineering/core 0.13.0 → 0.13.1

package/dist/index.mjs

@@ -36,11 +36,12 @@ import {
   fileExists,
   findFiles,
   readFileContent,
+  relativePosix,
   resolveFileToLayer,
   runAll,
   validateDependencies,
   violationId
-} from "./chunk-ZHGBWFYD.mjs";
+} from "./chunk-D6VFA6AS.mjs";
 
 // src/index.ts
 export * from "@harness-engineering/types";
@@ -365,7 +366,7 @@ async function validateAgentsMap(path20 = "./AGENTS.md") {
 
 // src/context/doc-coverage.ts
 import { minimatch } from "minimatch";
-import { basename, relative } from "path";
+import { basename } from "path";
 function determineImportance(filePath) {
   const name = basename(filePath).toLowerCase();
   if (name === "index.ts" || name === "index.js" || name === "main.ts") {
@@ -405,7 +406,7 @@ async function checkDocCoverage(domain, options = {}) {
   try {
     const sourceFiles = await findFiles("**/*.{ts,js,tsx,jsx}", sourceDir);
     const filteredSourceFiles = sourceFiles.filter((file) => {
-      const relativePath = relative(sourceDir, file);
+      const relativePath = relativePosix(sourceDir, file);
       return !excludePatterns.some((pattern) => {
         return minimatch(relativePath, pattern, { dot: true }) || minimatch(file, pattern, { dot: true });
       });
@@ -428,7 +429,7 @@ async function checkDocCoverage(domain, options = {}) {
     const undocumented = [];
     const gaps = [];
     for (const sourceFile of filteredSourceFiles) {
-      const relativePath = relative(sourceDir, sourceFile);
+      const relativePath = relativePosix(sourceDir, sourceFile);
       const fileName = basename(sourceFile);
       const isDocumented = documentedPaths.has(relativePath) || documentedPaths.has(fileName) || documentedPaths.has(`src/${relativePath}`);
       if (isDocumented) {
@@ -464,7 +465,7 @@ async function checkDocCoverage(domain, options = {}) {
 }
 
 // src/context/knowledge-map.ts
-import { join as join2, basename as basename2, relative as relative2 } from "path";
+import { join as join2, basename as basename2 } from "path";
 function suggestFix(path20, existingFiles) {
   const targetName = basename2(path20).toLowerCase();
   const similar = existingFiles.find((file) => {
@@ -488,7 +489,7 @@ async function validateKnowledgeMap(rootDir = process.cwd()) {
     totalLinks: agentsTotalLinks
   } = agentsResult.value;
   const existingFiles = await findFiles("**/*", rootDir);
-  const relativeExistingFiles = existingFiles.map((f) => relative2(rootDir, f));
+  const relativeExistingFiles = existingFiles.map((f) => relativePosix(rootDir, f));
   const brokenLinks = agentsBrokenLinks.map((link) => {
     const section = sections.find(
       (s) => s.links.some((l) => l.path === link.path && l.line === link.line)
@@ -513,7 +514,7 @@ async function validateKnowledgeMap(rootDir = process.cwd()) {
 }
 
 // src/context/generate.ts
-import { relative as relative3, basename as basename3, dirname as dirname2 } from "path";
+import { basename as basename3, dirname as dirname2 } from "path";
 var DEFAULT_SECTIONS = [
   {
     name: "Documentation",
@@ -529,7 +530,7 @@ var DEFAULT_SECTIONS = [
 function groupByDirectory(files, rootDir) {
   const groups = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const relativePath = relative3(rootDir, file);
+    const relativePath = relativePosix(rootDir, file);
     const dir = dirname2(relativePath);
     if (!groups.has(dir)) {
       groups.set(dir, []);
@@ -585,7 +586,7 @@ async function generateAgentsMap(config, graphSections) {
         allFiles.push(...files);
       }
       const filteredFiles = allFiles.filter((file) => {
-        const relativePath = relative3(rootDir, file);
+        const relativePath = relativePosix(rootDir, file);
         return !matchesExcludePattern(relativePath, excludePaths);
       });
       lines.push("## Repository Structure");
@@ -613,11 +614,11 @@ async function generateAgentsMap(config, graphSections) {
         }
         const sectionFiles = await findFiles(section.pattern, rootDir);
         const filteredSectionFiles = sectionFiles.filter((file) => {
-          const relativePath = relative3(rootDir, file);
+          const relativePath = relativePosix(rootDir, file);
           return !matchesExcludePattern(relativePath, excludePaths);
         });
         for (const file of filteredSectionFiles.slice(0, 20)) {
-          lines.push(formatFileLink(relative3(rootDir, file)));
+          lines.push(formatFileLink(relativePosix(rootDir, file)));
         }
         if (filteredSectionFiles.length > 20) {
           lines.push(`- _... and ${filteredSectionFiles.length - 20} more files_`);
@@ -1572,7 +1573,7 @@ var TypeScriptParser = class {
 };
 
 // src/entropy/snapshot.ts
-import { join as join3, resolve, relative as relative4 } from "path";
+import { join as join3, resolve } from "path";
 import { minimatch as minimatch2 } from "minimatch";
 async function resolveEntryPoints(rootDir, explicitEntries) {
   if (explicitEntries && explicitEntries.length > 0) {
@@ -1836,7 +1837,7 @@ async function buildSnapshot(config) {
     sourceFilePaths.push(...files2);
   }
   sourceFilePaths = sourceFilePaths.filter((f) => {
-    const rel = relative4(rootDir, f);
+    const rel = relativePosix(rootDir, f);
     return !excludePatterns.some((p) => minimatch2(rel, p));
   });
   const files = [];
@@ -2368,9 +2369,8 @@ async function detectDeadCode(snapshot, graphDeadCodeData) {
 
 // src/entropy/detectors/patterns.ts
 import { minimatch as minimatch3 } from "minimatch";
-import { relative as relative5 } from "path";
 function fileMatchesPattern(filePath, pattern, rootDir) {
-  const relativePath = relative5(rootDir, filePath);
+  const relativePath = relativePosix(rootDir, filePath);
   return minimatch3(relativePath, pattern);
 }
 function checkConfigPattern(pattern, file, rootDir) {
@@ -6405,238 +6405,270 @@ var ALL_CHECKS = [
   "phase-gate",
   "arch"
 ];
-async function runSingleCheck(name, projectRoot, config) {
-  const start = Date.now();
+async function runValidateCheck(projectRoot, config) {
   const issues = [];
-  try {
-    switch (name) {
-      case "validate": {
-        const agentsPath = path12.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
-        const result = await validateAgentsMap(agentsPath);
-        if (!result.ok) {
-          issues.push({ severity: "error", message: result.error.message });
-        } else if (!result.value.valid) {
-          if (result.value.errors) {
-            for (const err of result.value.errors) {
-              issues.push({ severity: "error", message: err.message });
-            }
-          }
-          for (const section of result.value.missingSections) {
-            issues.push({ severity: "warning", message: `Missing section: ${section}` });
-          }
-          for (const link of result.value.brokenLinks) {
-            issues.push({
-              severity: "warning",
-              message: `Broken link: ${link.text} \u2192 ${link.path}`,
-              file: link.path
-            });
-          }
-        }
-        break;
+  const agentsPath = path12.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+  const result = await validateAgentsMap(agentsPath);
+  if (!result.ok) {
+    issues.push({ severity: "error", message: result.error.message });
+  } else if (!result.value.valid) {
+    if (result.value.errors) {
+      for (const err of result.value.errors) {
+        issues.push({ severity: "error", message: err.message });
+      }
+    }
+    for (const section of result.value.missingSections) {
+      issues.push({ severity: "warning", message: `Missing section: ${section}` });
+    }
+    for (const link of result.value.brokenLinks) {
+      issues.push({
+        severity: "warning",
+        message: `Broken link: ${link.text} \u2192 ${link.path}`,
+        file: link.path
+      });
+    }
+  }
+  return issues;
+}
+async function runDepsCheck(projectRoot, config) {
+  const issues = [];
+  const rawLayers = config.layers;
+  if (rawLayers && rawLayers.length > 0) {
+    const parser = new TypeScriptParser();
+    const layers = rawLayers.map(
+      (l) => defineLayer(
+        l.name,
+        Array.isArray(l.patterns) ? l.patterns : [l.pattern],
+        l.allowedDependencies
+      )
+    );
+    const result = await validateDependencies({
+      layers,
+      rootDir: projectRoot,
+      parser
+    });
+    if (!result.ok) {
+      issues.push({ severity: "error", message: result.error.message });
+    } else if (result.value.violations.length > 0) {
+      for (const v of result.value.violations) {
+        issues.push({
+          severity: "error",
+          message: `${v.reason}: ${v.file} imports ${v.imports} (${v.fromLayer} \u2192 ${v.toLayer})`,
+          file: v.file,
+          line: v.line
+        });
       }
-      case "deps": {
-        const rawLayers = config.layers;
-        if (rawLayers && rawLayers.length > 0) {
-          const parser = new TypeScriptParser();
-          const layers = rawLayers.map(
-            (l) => defineLayer(
-              l.name,
-              Array.isArray(l.patterns) ? l.patterns : [l.pattern],
-              l.allowedDependencies
-            )
-          );
-          const result = await validateDependencies({
-            layers,
-            rootDir: projectRoot,
-            parser
-          });
-          if (!result.ok) {
-            issues.push({ severity: "error", message: result.error.message });
-          } else if (result.value.violations.length > 0) {
-            for (const v of result.value.violations) {
-              issues.push({
-                severity: "error",
-                message: `${v.reason}: ${v.file} imports ${v.imports} (${v.fromLayer} \u2192 ${v.toLayer})`,
-                file: v.file,
-                line: v.line
-              });
-            }
-          }
-        }
-        break;
+    }
+  }
+  return issues;
+}
+async function runDocsCheck(projectRoot, config) {
+  const issues = [];
+  const docsDir = path12.join(projectRoot, config.docsDir ?? "docs");
+  const entropyConfig = config.entropy || {};
+  const result = await checkDocCoverage("project", {
+    docsDir,
+    sourceDir: projectRoot,
+    excludePatterns: entropyConfig.excludePatterns || [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/*.test.ts",
+      "**/fixtures/**"
+    ]
+  });
+  if (!result.ok) {
+    issues.push({ severity: "warning", message: result.error.message });
+  } else if (result.value.gaps.length > 0) {
+    for (const gap of result.value.gaps) {
+      issues.push({
+        severity: "warning",
+        message: `Undocumented: ${gap.file} (suggested: ${gap.suggestedSection})`,
+        file: gap.file
+      });
+    }
+  }
+  return issues;
+}
+async function runEntropyCheck(projectRoot, _config) {
+  const issues = [];
+  const analyzer = new EntropyAnalyzer({
+    rootDir: projectRoot,
+    analyze: { drift: true, deadCode: true, patterns: false }
+  });
+  const result = await analyzer.analyze();
+  if (!result.ok) {
+    issues.push({ severity: "warning", message: result.error.message });
+  } else {
+    const report = result.value;
+    if (report.drift) {
+      for (const drift of report.drift.drifts) {
+        issues.push({
+          severity: "warning",
+          message: `Doc drift (${drift.type}): ${drift.details}`,
+          file: drift.docFile,
+          line: drift.line
+        });
       }
-      case "docs": {
-        const docsDir = path12.join(projectRoot, config.docsDir ?? "docs");
-        const entropyConfig = config.entropy || {};
-        const result = await checkDocCoverage("project", {
-          docsDir,
-          sourceDir: projectRoot,
-          excludePatterns: entropyConfig.excludePatterns || [
-            "**/node_modules/**",
-            "**/dist/**",
-            "**/*.test.ts",
-            "**/fixtures/**"
-          ]
+    }
+    if (report.deadCode) {
+      for (const dead of report.deadCode.deadExports) {
+        issues.push({
+          severity: "warning",
+          message: `Dead export: ${dead.name}`,
+          file: dead.file,
+          line: dead.line
         });
-        if (!result.ok) {
-          issues.push({ severity: "warning", message: result.error.message });
-        } else if (result.value.gaps.length > 0) {
-          for (const gap of result.value.gaps) {
-            issues.push({
-              severity: "warning",
-              message: `Undocumented: ${gap.file} (suggested: ${gap.suggestedSection})`,
-              file: gap.file
-            });
-          }
-        }
-        break;
       }
-      case "entropy": {
-        const analyzer = new EntropyAnalyzer({
-          rootDir: projectRoot,
-          analyze: { drift: true, deadCode: true, patterns: false }
+    }
+  }
+  return issues;
+}
+async function runSecurityCheck(projectRoot, config) {
+  const issues = [];
+  const securityConfig = parseSecurityConfig(config.security);
+  if (!securityConfig.enabled) return issues;
+  const scanner = new SecurityScanner(securityConfig);
+  scanner.configureForProject(projectRoot);
+  const { glob: globFn } = await import("glob");
+  const sourceFiles = await globFn("**/*.{ts,tsx,js,jsx,go,py}", {
+    cwd: projectRoot,
+    ignore: securityConfig.exclude ?? [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/*.test.ts",
+      "**/fixtures/**"
+    ],
+    absolute: true
+  });
+  const scanResult = await scanner.scanFiles(sourceFiles);
+  for (const finding of scanResult.findings) {
+    issues.push({
+      severity: finding.severity === "info" ? "warning" : finding.severity,
+      message: `[${finding.ruleId}] ${finding.message}: ${finding.match}`,
+      file: finding.file,
+      line: finding.line
+    });
+  }
+  return issues;
+}
+async function runPerfCheck(projectRoot, config) {
+  const issues = [];
+  const perfConfig = config.performance || {};
+  const perfAnalyzer = new EntropyAnalyzer({
+    rootDir: projectRoot,
+    analyze: {
+      complexity: perfConfig.complexity || true,
+      coupling: perfConfig.coupling || true,
+      sizeBudget: perfConfig.sizeBudget || false
+    }
+  });
+  const perfResult = await perfAnalyzer.analyze();
+  if (!perfResult.ok) {
+    issues.push({ severity: "warning", message: perfResult.error.message });
+  } else {
+    const perfReport = perfResult.value;
+    if (perfReport.complexity) {
+      for (const v of perfReport.complexity.violations) {
+        issues.push({
+          severity: v.severity === "info" ? "warning" : v.severity,
+          message: `[Tier ${v.tier}] ${v.metric}: ${v.function} in ${v.file} (${v.value} > ${v.threshold})`,
+          file: v.file,
+          line: v.line
         });
-        const result = await analyzer.analyze();
-        if (!result.ok) {
-          issues.push({ severity: "warning", message: result.error.message });
-        } else {
-          const report = result.value;
-          if (report.drift) {
-            for (const drift of report.drift.drifts) {
-              issues.push({
-                severity: "warning",
-                message: `Doc drift (${drift.type}): ${drift.details}`,
-                file: drift.docFile,
-                line: drift.line
-              });
-            }
-          }
-          if (report.deadCode) {
-            for (const dead of report.deadCode.deadExports) {
-              issues.push({
-                severity: "warning",
-                message: `Dead export: ${dead.name}`,
-                file: dead.file,
-                line: dead.line
-              });
-            }
-          }
-        }
-        break;
       }
-      case "security": {
-        const securityConfig = parseSecurityConfig(config.security);
-        if (!securityConfig.enabled) break;
-        const scanner = new SecurityScanner(securityConfig);
-        scanner.configureForProject(projectRoot);
-        const { glob: globFn } = await import("glob");
-        const sourceFiles = await globFn("**/*.{ts,tsx,js,jsx,go,py}", {
-          cwd: projectRoot,
-          ignore: securityConfig.exclude ?? [
-            "**/node_modules/**",
-            "**/dist/**",
-            "**/*.test.ts",
-            "**/fixtures/**"
-          ],
-          absolute: true
+    }
+    if (perfReport.coupling) {
+      for (const v of perfReport.coupling.violations) {
+        issues.push({
+          severity: v.severity === "info" ? "warning" : v.severity,
+          message: `[Tier ${v.tier}] ${v.metric}: ${v.file} (${v.value} > ${v.threshold})`,
+          file: v.file
         });
-        const scanResult = await scanner.scanFiles(sourceFiles);
-        for (const finding of scanResult.findings) {
-          issues.push({
-            severity: finding.severity === "info" ? "warning" : finding.severity,
-            message: `[${finding.ruleId}] ${finding.message}: ${finding.match}`,
-            file: finding.file,
-            line: finding.line
-          });
-        }
-        break;
       }
-      case "perf": {
-        const perfConfig = config.performance || {};
-        const perfAnalyzer = new EntropyAnalyzer({
-          rootDir: projectRoot,
-          analyze: {
-            complexity: perfConfig.complexity || true,
-            coupling: perfConfig.coupling || true,
-            sizeBudget: perfConfig.sizeBudget || false
-          }
+    }
+  }
+  return issues;
+}
+async function runPhaseGateCheck(_projectRoot, config) {
+  const issues = [];
+  const phaseGates = config.phaseGates;
+  if (!phaseGates?.enabled) {
+    return issues;
+  }
+  issues.push({
+    severity: "warning",
+    message: "Phase gate is enabled but requires CLI context. Run `harness check-phase-gate` separately for full validation."
+  });
+  return issues;
+}
+async function runArchCheck(projectRoot, config) {
+  const issues = [];
+  const rawArchConfig = config.architecture;
+  const archConfig = ArchConfigSchema.parse(rawArchConfig ?? {});
+  if (!archConfig.enabled) return issues;
+  const results = await runAll(archConfig, projectRoot);
+  const baselineManager = new ArchBaselineManager(projectRoot, archConfig.baselinePath);
+  const baseline = baselineManager.load();
+  if (baseline) {
+    const diffResult = diff(results, baseline);
+    if (!diffResult.passed) {
+      for (const v of diffResult.newViolations) {
+        issues.push({
+          severity: v.severity,
+          message: `[${v.category || "arch"}] NEW: ${v.detail}`,
+          file: v.file
         });
-        const perfResult = await perfAnalyzer.analyze();
-        if (!perfResult.ok) {
-          issues.push({ severity: "warning", message: perfResult.error.message });
-        } else {
-          const perfReport = perfResult.value;
-          if (perfReport.complexity) {
-            for (const v of perfReport.complexity.violations) {
-              issues.push({
-                severity: v.severity === "info" ? "warning" : v.severity,
-                message: `[Tier ${v.tier}] ${v.metric}: ${v.function} in ${v.file} (${v.value} > ${v.threshold})`,
-                file: v.file,
-                line: v.line
-              });
-            }
-          }
-          if (perfReport.coupling) {
-            for (const v of perfReport.coupling.violations) {
-              issues.push({
-                severity: v.severity === "info" ? "warning" : v.severity,
-                message: `[Tier ${v.tier}] ${v.metric}: ${v.file} (${v.value} > ${v.threshold})`,
-                file: v.file
-              });
-            }
-          }
-        }
-        break;
       }
-      case "phase-gate": {
-        const phaseGates = config.phaseGates;
-        if (!phaseGates?.enabled) {
-          break;
-        }
+      for (const r of diffResult.regressions) {
         issues.push({
-          severity: "warning",
-          message: "Phase gate is enabled but requires CLI context. Run `harness check-phase-gate` separately for full validation."
+          severity: "error",
+          message: `[${r.category}] REGRESSION: ${r.currentValue} > ${r.baselineValue} (delta: ${r.delta})`
         });
-        break;
       }
-      case "arch": {
-        const rawArchConfig = config.architecture;
-        const archConfig = ArchConfigSchema.parse(rawArchConfig ?? {});
-        if (!archConfig.enabled) break;
-        const results = await runAll(archConfig, projectRoot);
-        const baselineManager = new ArchBaselineManager(projectRoot, archConfig.baselinePath);
-        const baseline = baselineManager.load();
-        if (baseline) {
-          const diffResult = diff(results, baseline);
-          if (!diffResult.passed) {
-            for (const v of diffResult.newViolations) {
-              issues.push({
-                severity: v.severity,
-                message: `[${v.category || "arch"}] NEW: ${v.detail}`,
-                file: v.file
-              });
-            }
-            for (const r of diffResult.regressions) {
-              issues.push({
-                severity: "error",
-                message: `[${r.category}] REGRESSION: ${r.currentValue} > ${r.baselineValue} (delta: ${r.delta})`
-              });
-            }
-          }
-        } else {
-          for (const result of results) {
-            for (const v of result.violations) {
-              issues.push({
-                severity: v.severity,
-                message: `[${result.category}] ${v.detail}`,
-                file: v.file
-              });
-            }
-          }
-        }
-        break;
+    }
+  } else {
+    for (const result of results) {
+      for (const v of result.violations) {
+        issues.push({
+          severity: v.severity,
+          message: `[${result.category}] ${v.detail}`,
+          file: v.file
+        });
       }
     }
+  }
+  return issues;
+}
+async function runSingleCheck(name, projectRoot, config) {
+  const start = Date.now();
+  const issues = [];
+  try {
+    switch (name) {
+      case "validate":
+        issues.push(...await runValidateCheck(projectRoot, config));
+        break;
+      case "deps":
+        issues.push(...await runDepsCheck(projectRoot, config));
+        break;
+      case "docs":
+        issues.push(...await runDocsCheck(projectRoot, config));
+        break;
+      case "entropy":
+        issues.push(...await runEntropyCheck(projectRoot, config));
+        break;
+      case "security":
+        issues.push(...await runSecurityCheck(projectRoot, config));
+        break;
+      case "perf":
+        issues.push(...await runPerfCheck(projectRoot, config));
+        break;
+      case "phase-gate":
+        issues.push(...await runPhaseGateCheck(projectRoot, config));
+        break;
+      case "arch":
+        issues.push(...await runArchCheck(projectRoot, config));
+        break;
+    }
   } catch (error) {
     issues.push({
       severity: "error",
@@ -7011,7 +7043,7 @@ async function readContextFile(projectRoot, filePath, reason) {
   if (!result.ok) return null;
   const content = result.value;
   const lines = content.split("\n").length;
-  const relPath = path14.isAbsolute(filePath) ? path14.relative(projectRoot, filePath) : filePath;
+  const relPath = path14.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
   return { path: relPath, content, reason, lines };
 }
 function extractImportSources(content) {
@@ -7029,7 +7061,7 @@ async function resolveImportPath(projectRoot, fromFile, importSource) {
   const fromDir = path14.dirname(path14.join(projectRoot, fromFile));
   const basePath = path14.resolve(fromDir, importSource);
   if (!isWithinProject(basePath, projectRoot)) return null;
-  const relBase = path14.relative(projectRoot, basePath);
+  const relBase = relativePosix(projectRoot, basePath);
   const candidates = [
     relBase + ".ts",
     relBase + ".tsx",
@@ -7048,7 +7080,7 @@ async function findTestFiles(projectRoot, sourceFile) {
   const baseName = path14.basename(sourceFile, path14.extname(sourceFile));
   const pattern = `**/${baseName}.{test,spec}.{ts,tsx,mts}`;
   const results = await findFiles(pattern, projectRoot);
-  return results.map((f) => path14.relative(projectRoot, f));
+  return results.map((f) => relativePosix(projectRoot, f));
 }
 async function gatherImportContext(projectRoot, changedFiles, budget) {
   const contextFiles = [];
@@ -8910,7 +8942,7 @@ Run "harness update" to upgrade.`;
 }
 
 // src/index.ts
-var VERSION = "0.11.0";
+var VERSION = "0.13.0";
 export {
   AGENT_DESCRIPTORS,
   ARCHITECTURE_DESCRIPTOR,