@harness-engineering/core 0.5.0 → 0.7.0

package/dist/index.mjs

@@ -1,22 +1,6 @@
 // src/index.ts
 export * from "@harness-engineering/types";
 
-// src/shared/result.ts
-var Ok = (value) => ({
-  ok: true,
-  value
-});
-function isOk(result) {
-  return result.ok === true;
-}
-var Err = (error) => ({
-  ok: false,
-  error
-});
-function isErr(result) {
-  return result.ok === false;
-}
-
 // src/shared/errors.ts
 function createError(code, message, details = {}, suggestions = []) {
   return { code, message, details, suggestions };
@@ -25,23 +9,26 @@ function createEntropyError(code, message, details = {}, suggestions = []) {
   return { code, message, details, suggestions };
 }
 
+// src/shared/result.ts
+import { Ok, Err, isOk, isErr } from "@harness-engineering/types";
+
 // src/shared/fs-utils.ts
 import { access, constants, readFile } from "fs";
 import { promisify } from "util";
 import { glob } from "glob";
 var accessAsync = promisify(access);
 var readFileAsync = promisify(readFile);
-async function fileExists(path2) {
+async function fileExists(path3) {
   try {
-    await accessAsync(path2, constants.F_OK);
+    await accessAsync(path3, constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readFileContent(path2) {
+async function readFileContent(path3) {
   try {
-    const content = await readFileAsync(path2, "utf-8");
+    const content = await readFileAsync(path3, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(error);
@@ -89,15 +76,15 @@ function validateConfig(data, schema) {
   let message = "Configuration validation failed";
   const suggestions = [];
   if (firstError) {
-    const path2 = firstError.path.join(".");
-    const pathDisplay = path2 ? ` at "${path2}"` : "";
+    const path3 = firstError.path.join(".");
+    const pathDisplay = path3 ? ` at "${path3}"` : "";
     if (firstError.code === "invalid_type") {
       const received = firstError.received;
       const expected = firstError.expected;
       if (received === "undefined") {
         code = "MISSING_FIELD";
         message = `Missing required field${pathDisplay}: ${firstError.message}`;
-        suggestions.push(`Field "${path2}" is required and must be of type "${expected}"`);
+        suggestions.push(`Field "${path3}" is required and must be of type "${expected}"`);
       } else {
         code = "INVALID_TYPE";
         message = `Invalid type${pathDisplay}: ${firstError.message}`;
@@ -310,27 +297,27 @@ function extractSections(content) {
     return result;
   });
 }
-function isExternalLink(path2) {
-  return path2.startsWith("http://") || path2.startsWith("https://") || path2.startsWith("#") || path2.startsWith("mailto:");
+function isExternalLink(path3) {
+  return path3.startsWith("http://") || path3.startsWith("https://") || path3.startsWith("#") || path3.startsWith("mailto:");
 }
 function resolveLinkPath(linkPath, baseDir) {
   return linkPath.startsWith(".") ? join(baseDir, linkPath) : linkPath;
 }
-async function validateAgentsMap(path2 = "./AGENTS.md") {
-  const contentResult = await readFileContent(path2);
+async function validateAgentsMap(path3 = "./AGENTS.md") {
+  const contentResult = await readFileContent(path3);
   if (!contentResult.ok) {
     return Err(
       createError(
         "PARSE_ERROR",
         `Failed to read AGENTS.md: ${contentResult.error.message}`,
-        { path: path2 },
+        { path: path3 },
         ["Ensure the file exists", "Check file permissions"]
       )
     );
   }
   const content = contentResult.value;
   const sections = extractSections(content);
-  const baseDir = dirname(path2);
+  const baseDir = dirname(path3);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -458,8 +445,8 @@ async function checkDocCoverage(domain, options = {}) {
 
 // src/context/knowledge-map.ts
 import { join as join2, basename as basename2, relative as relative2 } from "path";
-function suggestFix(path2, existingFiles) {
-  const targetName = basename2(path2).toLowerCase();
+function suggestFix(path3, existingFiles) {
+  const targetName = basename2(path3).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = basename2(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -467,7 +454,7 @@ function suggestFix(path2, existingFiles) {
   if (similar) {
     return `Did you mean "${similar}"?`;
   }
-  return `Create the file "${path2}" or remove the link`;
+  return `Create the file "${path3}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
   const agentsPath = join2(rootDir, "AGENTS.md");
@@ -962,8 +949,8 @@ function createBoundaryValidator(schema, name) {
         return Ok(result.data);
       }
       const suggestions = result.error.issues.map((issue) => {
-        const path2 = issue.path.join(".");
-        return path2 ? `${path2}: ${issue.message}` : issue.message;
+        const path3 = issue.path.join(".");
+        return path3 ? `${path3}: ${issue.message}` : issue.message;
       });
       return Err(
         createError(
@@ -1032,11 +1019,11 @@ function walk(node, visitor) {
 var TypeScriptParser = class {
   name = "typescript";
   extensions = [".ts", ".tsx", ".mts", ".cts"];
-  async parseFile(path2) {
-    const contentResult = await readFileContent(path2);
+  async parseFile(path3) {
+    const contentResult = await readFileContent(path3);
     if (!contentResult.ok) {
       return Err(
-        createParseError("NOT_FOUND", `File not found: ${path2}`, { path: path2 }, [
+        createParseError("NOT_FOUND", `File not found: ${path3}`, { path: path3 }, [
           "Check that the file exists",
           "Verify the path is correct"
         ])
@@ -1046,7 +1033,7 @@ var TypeScriptParser = class {
       const ast = parse(contentResult.value, {
         loc: true,
         range: true,
-        jsx: path2.endsWith(".tsx"),
+        jsx: path3.endsWith(".tsx"),
         errorOnUnknownASTType: false
       });
       return Ok({
@@ -1057,7 +1044,7 @@ var TypeScriptParser = class {
     } catch (e) {
       const error = e;
       return Err(
-        createParseError("SYNTAX_ERROR", `Failed to parse ${path2}: ${error.message}`, { path: path2 }, [
+        createParseError("SYNTAX_ERROR", `Failed to parse ${path3}: ${error.message}`, { path: path3 }, [
           "Check for syntax errors in the file",
           "Ensure valid TypeScript syntax"
         ])
@@ -1341,22 +1328,22 @@ function extractInlineRefs(content) {
   }
   return refs;
 }
-async function parseDocumentationFile(path2) {
-  const contentResult = await readFileContent(path2);
+async function parseDocumentationFile(path3) {
+  const contentResult = await readFileContent(path3);
   if (!contentResult.ok) {
     return Err(
       createEntropyError(
         "PARSE_ERROR",
-        `Failed to read documentation file: ${path2}`,
-        { file: path2 },
+        `Failed to read documentation file: ${path3}`,
+        { file: path3 },
         ["Check that the file exists"]
       )
     );
   }
   const content = contentResult.value;
-  const type = path2.endsWith(".md") ? "markdown" : "text";
+  const type = path3.endsWith(".md") ? "markdown" : "text";
   return Ok({
-    path: path2,
+    path: path3,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -3867,8 +3854,183 @@ async function runMultiTurnPipeline(initialContext, turnExecutor, options) {
   };
 }
 
+// src/ci/check-orchestrator.ts
+import * as path2 from "path";
+var ALL_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
+async function runSingleCheck(name, projectRoot, config) {
+  const start = Date.now();
+  const issues = [];
+  try {
+    switch (name) {
+      case "validate": {
+        const agentsPath = path2.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;
+      }
+      case "deps": {
+        const layers = config.layers;
+        if (layers && layers.length > 0) {
+          const parser = new TypeScriptParser();
+          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;
+      }
+      case "docs": {
+        const docsDir = path2.join(projectRoot, config.docsDir ?? "docs");
+        const result = await checkDocCoverage("project", { docsDir });
+        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 }
+        });
+        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 "phase-gate": {
+        const phaseGates = config.phaseGates;
+        if (!phaseGates?.enabled) {
+          break;
+        }
+        issues.push({
+          severity: "warning",
+          message: "Phase gate is enabled but requires CLI context. Run `harness check-phase-gate` separately for full validation."
+        });
+        break;
+      }
+    }
+  } catch (error) {
+    issues.push({
+      severity: "error",
+      message: `Check '${name}' threw: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  const hasWarnings = issues.some((i) => i.severity === "warning");
+  const status = hasErrors ? "fail" : hasWarnings ? "warn" : "pass";
+  return {
+    name,
+    status,
+    issues,
+    durationMs: Date.now() - start
+  };
+}
+function buildSummary(checks) {
+  return {
+    total: checks.length,
+    passed: checks.filter((c) => c.status === "pass").length,
+    failed: checks.filter((c) => c.status === "fail").length,
+    warnings: checks.filter((c) => c.status === "warn").length,
+    skipped: checks.filter((c) => c.status === "skip").length
+  };
+}
+function determineExitCode(summary, failOn = "error") {
+  if (summary.failed > 0) return 1;
+  if (failOn === "warning" && summary.warnings > 0) return 1;
+  return 0;
+}
+async function runCIChecks(input) {
+  const { projectRoot, config, skip = [], failOn = "error" } = input;
+  try {
+    const checks = [];
+    for (const name of ALL_CHECKS) {
+      if (skip.includes(name)) {
+        checks.push({ name, status: "skip", issues: [], durationMs: 0 });
+      } else {
+        const result = await runSingleCheck(name, projectRoot, config);
+        checks.push(result);
+      }
+    }
+    const summary = buildSummary(checks);
+    const exitCode = determineExitCode(summary, failOn);
+    const report = {
+      version: 1,
+      project: config.name ?? "unknown",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      checks,
+      summary,
+      exitCode
+    };
+    return Ok(report);
+  } catch (error) {
+    return Err(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
 // src/index.ts
-var VERSION = "0.5.0";
+var VERSION = "0.6.0";
 export {
   AgentActionEmitter,
   ChecklistBuilder,
@@ -3876,7 +4038,6 @@ export {
   DEFAULT_STATE,
   EntropyAnalyzer,
   EntropyConfigSchema,
-  Err,
   FailureEntrySchema,
   FileSink,
   GateConfigSchema,
@@ -3886,7 +4047,6 @@ export {
   NoOpExecutor,
   NoOpSink,
   NoOpTelemetryAdapter,
-  Ok,
   PatternConfigSchema,
   REQUIRED_SECTIONS,
   TypeScriptParser,
@@ -3897,9 +4057,7 @@ export {
   applyFixes,
   archiveFailures,
   buildDependencyGraph,
-  buildReachabilityMap,
   buildSnapshot,
-  checkConfigPattern,
   checkDocCoverage,
   configureFeedback,
   contextBudget,
@@ -3918,28 +4076,23 @@ export {
   executeWorkflow,
   extractMarkdownLinks,
   extractSections,
-  findPossibleMatches,
   generateAgentsMap,
   generateSuggestions,
   getActionEmitter,
   getFeedbackConfig,
   getPhaseCategories,
-  isErr,
-  isOk,
-  levenshteinDistance,
   loadFailures,
   loadHandoff,
   loadRelevantLearnings,
   loadState,
   logAgentAction,
   parseDiff,
-  parseDocumentationFile,
   previewFix,
   requestMultiplePeerReviews,
   requestPeerReview,
   resetFeedbackConfig,
-  resolveEntryPoints,
   resolveFileToLayer,
+  runCIChecks,
   runMechanicalGate,
   runMultiTurnPipeline,
   runPipeline,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/core",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Core library for Harness Engineering toolkit",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -41,7 +41,7 @@
     "glob": "^10.3.0",
     "minimatch": "^10.2.4",
     "zod": "^3.22.0",
-    "@harness-engineering/types": "0.0.0"
+    "@harness-engineering/types": "0.1.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.18",
@@ -56,7 +56,8 @@
     "lint": "eslint src",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",
-    "test": "vitest",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:ui": "vitest --ui"
   }