@harness-engineering/cli 1.13.1 → 1.14.0

package/dist/{chunk-QPEH2QPG.js → chunk-DBSOCI3G.js}

@@ -264,6 +264,49 @@ async function validate(options) {
   }
   return { success: true, ruleCount: parseResult.data.rules.length };
 }
+function resolveOutputDir(options, configOutput) {
+  const configDir = path3.dirname(path3.resolve(options.configPath));
+  return options.outputDir ? path3.resolve(options.outputDir) : path3.resolve(configDir, configOutput);
+}
+async function prepareOutputDir(outputDir, clean) {
+  if (clean) {
+    try {
+      await fs3.rm(outputDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  await fs3.mkdir(outputDir, { recursive: true });
+}
+async function processRule(rule, templates, configDir, outputDir, configPath, dryRun, errors) {
+  const templateResult = await loadTemplate(rule.type, templates, configDir);
+  if (!templateResult.success) {
+    errors.push({ type: "template", error: templateResult.error, ruleName: rule.name });
+    return null;
+  }
+  const ruleResult = generateRule(rule, templateResult.source, outputDir, configPath);
+  if (!ruleResult.success) {
+    errors.push({ type: "render", error: ruleResult.error, ruleName: ruleResult.ruleName });
+    return null;
+  }
+  if (!dryRun) {
+    try {
+      await fs3.writeFile(ruleResult.rule.outputPath, ruleResult.rule.content, "utf-8");
+    } catch (err) {
+      errors.push({ type: "write", error: err, path: ruleResult.rule.outputPath });
+      return null;
+    }
+  }
+  return rule.name;
+}
+async function writeIndexFile(outputDir, generatedRules, errors) {
+  const indexContent = generateIndex(generatedRules);
+  const indexPath = path3.join(outputDir, "index.ts");
+  try {
+    await fs3.writeFile(indexPath, indexContent, "utf-8");
+  } catch (err) {
+    errors.push({ type: "write", error: err, path: indexPath });
+  }
+}
 async function generate(options) {
   const errors = [];
   const parseResult = await parseConfig(options.configPath);
@@ -271,69 +314,25 @@ async function generate(options) {
     return { success: false, errors: [{ type: "parse", error: parseResult.error }] };
   }
   const config = parseResult.data;
+  const outputDir = resolveOutputDir(options, config.output);
+  const dryRun = options.dryRun ?? false;
   const configDir = path3.dirname(path3.resolve(options.configPath));
-  const outputDir = options.outputDir ? path3.resolve(options.outputDir) : path3.resolve(configDir, config.output);
-  if (options.clean && !options.dryRun) {
-    try {
-      await fs3.rm(outputDir, { recursive: true, force: true });
-    } catch {
-    }
-  }
-  if (!options.dryRun) {
-    await fs3.mkdir(outputDir, { recursive: true });
+  if (!dryRun) {
+    await prepareOutputDir(outputDir, options.clean ?? false);
   }
   const generatedRules = [];
   for (const rule of config.rules) {
-    const templateResult = await loadTemplate(rule.type, config.templates, configDir);
-    if (!templateResult.success) {
-      errors.push({
-        type: "template",
-        error: templateResult.error,
-        ruleName: rule.name
-      });
-      continue;
-    }
-    const ruleResult = generateRule(rule, templateResult.source, outputDir, options.configPath);
-    if (!ruleResult.success) {
-      errors.push({
-        type: "render",
-        error: ruleResult.error,
-        ruleName: ruleResult.ruleName
-      });
-      continue;
-    }
-    if (!options.dryRun) {
-      try {
-        await fs3.writeFile(ruleResult.rule.outputPath, ruleResult.rule.content, "utf-8");
-      } catch (err) {
-        errors.push({
-          type: "write",
-          error: err,
-          path: ruleResult.rule.outputPath
-        });
-        continue;
-      }
-    }
-    generatedRules.push(rule.name);
+    const name = await processRule(rule, config.templates, configDir, outputDir, options.configPath, dryRun, errors);
+    if (name)
+      generatedRules.push(name);
   }
-  if (generatedRules.length > 0 && !options.dryRun) {
-    const indexContent = generateIndex(generatedRules);
-    const indexPath = path3.join(outputDir, "index.ts");
-    try {
-      await fs3.writeFile(indexPath, indexContent, "utf-8");
-    } catch (err) {
-      errors.push({ type: "write", error: err, path: indexPath });
-    }
+  if (generatedRules.length > 0 && !dryRun) {
+    await writeIndexFile(outputDir, generatedRules, errors);
   }
   if (errors.length > 0) {
     return { success: false, errors };
   }
-  return {
-    success: true,
-    rulesGenerated: generatedRules,
-    outputDir,
-    dryRun: options.dryRun ?? false
-  };
+  return { success: true, rulesGenerated: generatedRules, outputDir, dryRun };
 }
 
 export {

package/dist/{chunk-MHBMTPW7.js → chunk-ERS5EVUZ.js}

@@ -1,4 +1,12 @@
 // ../types/dist/index.mjs
+var SESSION_SECTION_NAMES = [
+  "terminology",
+  "decisions",
+  "constraints",
+  "risks",
+  "openQuestions",
+  "evidence"
+];
 function Ok(value) {
   return { ok: true, value };
 }
@@ -21,6 +29,7 @@ var STANDARD_COGNITIVE_MODES = [
 ];
 
 export {
+  SESSION_SECTION_NAMES,
   Ok,
   Err,
   isOk,

package/dist/{chunk-JSTQ3AWB.js → chunk-FIAPHX37.js}

@@ -4,7 +4,7 @@ import {
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/persona/generators/runtime.ts
 function generateRuntime(persona) {

package/dist/{chunk-IMFVFNJE.js → chunk-FTMXDOR6.js}

@@ -15,7 +15,7 @@ function evictIfNeeded() {
   }
 }
 async function doLoadGraphStore(projectRoot) {
-  const { GraphStore } = await import("./dist-HXHWB7SV.js");
+  const { GraphStore } = await import("./dist-B26DFXMP.js");
   const graphDir = path.join(projectRoot, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);

package/dist/{chunk-72GHBOL2.js → chunk-GZKSBLQL.js}

@@ -1,6 +1,6 @@
 import {
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/commands/validate-cross-check.ts
 import * as fs from "fs";

package/dist/{chunk-K6XAPGML.js → chunk-H7Y5CKTM.js}

@@ -1,7 +1,7 @@
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/mcp/utils/config-resolver.ts
 import * as fs from "fs";

package/dist/{chunk-4ZMOCPYO.js → chunk-NLVUVUGD.js}

@@ -45,7 +45,7 @@ var runCodeReviewDefinition = {
 };
 async function handleRunCodeReview(input) {
   try {
-    const { parseDiff, runReviewPipeline } = await import("./dist-2B363XUH.js");
+    const { parseDiff, runReviewPipeline } = await import("./dist-HWXF2C3R.js");
     const parseResult = parseDiff(input.diff);
     if (!parseResult.ok) {
       return {

package/dist/{chunk-Z77YQRQT.js → chunk-O5OJVPL6.js}

@@ -4,11 +4,11 @@ import {
 } from "./chunk-3WGJMBKH.js";
 import {
   ArchConfigSchema
-} from "./chunk-PQ5YK4AY.js";
+} from "./chunk-ABQHQ6I5.js";
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/config/loader.ts
 import * as fs from "fs";
@@ -184,12 +184,23 @@ var HarnessConfigSchema = z.object({
   performance: PerformanceConfigSchema.optional(),
   /** Project template settings (used by 'harness init') */
   template: z.object({
-    /** Complexity level of the template */
-    level: z.enum(["basic", "intermediate", "advanced"]),
+    /** Complexity level of the template (JS/TS only) */
+    level: z.enum(["basic", "intermediate", "advanced"]).optional(),
+    /** Target language */
+    language: z.enum(["typescript", "python", "go", "rust", "java"]).optional(),
     /** Primary technology framework */
     framework: z.string().optional(),
     /** Template version */
-    version: z.number()
+    version: z.number(),
+    /** Language-specific tooling configuration */
+    tooling: z.object({
+      packageManager: z.string().optional(),
+      linter: z.string().optional(),
+      formatter: z.string().optional(),
+      buildTool: z.string().optional(),
+      testRunner: z.string().optional(),
+      lockFile: z.string().optional()
+    }).optional()
   }).optional(),
   /** Phase gate and readiness check configuration */
   phaseGates: PhaseGatesConfigSchema.optional(),

package/dist/{chunk-NKDM3FMH.js → chunk-OD3S2NHN.js}

@@ -1,7 +1,7 @@
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/persona/generators/agents-md.ts
 function formatTrigger(trigger) {

package/dist/{chunk-65FRIL4D.js → chunk-OSXBPAMK.js}

@@ -26,7 +26,7 @@ var runSecurityScanDefinition = {
 };
 async function handleRunSecurityScan(input) {
   try {
-    const core = await import("./dist-2B363XUH.js");
+    const core = await import("./dist-HWXF2C3R.js");
     const projectRoot = sanitizePath(input.path);
     let configData = {};
     try {

package/dist/{chunk-DZS7CJKL.js → chunk-OXLLOSSR.js}

@@ -6,14 +6,14 @@ import {
 } from "./chunk-W6Y7ZW3Y.js";
 import {
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/mcp/tools/entropy.ts
 async function loadEntropyGraphOptions(projectPath) {
-  const { loadGraphStore } = await import("./graph-loader-GJZ4FN4Y.js");
+  const { loadGraphStore } = await import("./graph-loader-2M2HXDQI.js");
   const store = await loadGraphStore(projectPath);
   if (!store) return void 0;
-  const { GraphEntropyAdapter } = await import("./dist-HXHWB7SV.js");
+  const { GraphEntropyAdapter } = await import("./dist-B26DFXMP.js");
   const adapter = new GraphEntropyAdapter(store);
   const driftData = adapter.computeDriftData();
   const deadCodeData = adapter.computeDeadCodeData();
@@ -82,9 +82,48 @@ var detectEntropyDefinition = {
     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-2B363XUH.js");
+    const { EntropyAnalyzer } = await import("./dist-HWXF2C3R.js");
     const typeFilter = input.type ?? "all";
     const analyzer = new EntropyAnalyzer({
       rootDir: sanitizePath(input.path),
@@ -97,54 +136,13 @@ async function handleDetectEntropy(input) {
     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 })
-          }
-        ]
-      };
+      return buildSummaryResponse(result.value);
     }
     if (!input.autoFix) {
       return resultToMcpResponse(result);
     }
     if (!result.ok) return resultToMcpResponse(result);
-    const { createFixes, applyFixes, generateSuggestions } = await import("./dist-2B363XUH.js");
+    const { createFixes, applyFixes, generateSuggestions } = await import("./dist-HWXF2C3R.js");
     const report = result.value;
     const deadCode = report.deadCode;
     const fixTypesConfig = input.fixTypes ? { fixTypes: input.fixTypes } : void 0;

package/dist/{chunk-TS3XWPW5.js → chunk-RCWZBSK5.js}

@@ -1,7 +1,7 @@
 import {
   listPersonas,
   loadPersona
-} from "./chunk-Q6AB7W5Z.js";
+} from "./chunk-YQ6KC6TE.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";

package/dist/{chunk-NOPU4RZ4.js → chunk-S2FXOWOR.js}

@@ -1,6 +1,6 @@
 import {
   resolveProjectConfig
-} from "./chunk-K6XAPGML.js";
+} from "./chunk-H7Y5CKTM.js";
 import {
   sanitizePath
 } from "./chunk-W6Y7ZW3Y.js";
@@ -49,7 +49,7 @@ async function handleValidateProject(input) {
   checks.config = "pass";
   const config = configResult.value;
   try {
-    const core = await import("./dist-2B363XUH.js");
+    const core = await import("./dist-HWXF2C3R.js");
     if (typeof core.validateFileStructure === "function" && Array.isArray(config.conventions)) {
       const conventions = config.conventions;
       const structureResult = await core.validateFileStructure(projectPath, conventions);
@@ -68,7 +68,7 @@ async function handleValidateProject(input) {
   } catch {
   }
   try {
-    const core = await import("./dist-2B363XUH.js");
+    const core = await import("./dist-HWXF2C3R.js");
     if (typeof core.validateAgentsMap === "function") {
       const agentsMapPath = path.join(projectPath, "AGENTS.md");
       const agentsResult = await core.validateAgentsMap(agentsMapPath);

package/dist/{chunk-VUCPTQ6G.js → chunk-SD3SQOZ2.js}

@@ -1,7 +1,7 @@
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/persona/generators/ci-workflow.ts
 import YAML from "yaml";

package/dist/{chunk-IM32EEDM.js → chunk-TPOTOBR7.js}

@@ -33,7 +33,7 @@ var createSelfReviewDefinition = {
 };
 async function handleCreateSelfReview(input) {
   try {
-    const { parseDiff, createSelfReview } = await import("./dist-2B363XUH.js");
+    const { parseDiff, createSelfReview } = await import("./dist-HWXF2C3R.js");
     const parseResult = parseDiff(input.diff);
     if (!parseResult.ok) {
       return resultToMcpResponse(parseResult);
@@ -53,11 +53,11 @@ async function handleCreateSelfReview(input) {
         ...input.maxFileCount !== void 0 ? { maxChangedFiles: input.maxFileCount } : {}
       }
     };
-    const { loadGraphStore } = await import("./graph-loader-GJZ4FN4Y.js");
+    const { loadGraphStore } = await import("./graph-loader-2M2HXDQI.js");
     const store = await loadGraphStore(projectPath);
     let graphData;
     if (store) {
-      const { GraphFeedbackAdapter } = await import("./dist-HXHWB7SV.js");
+      const { GraphFeedbackAdapter } = await import("./dist-B26DFXMP.js");
       const adapter = new GraphFeedbackAdapter(store);
       const changedFiles = parseResult.value.files.map((f) => f.path);
       const impact = adapter.computeImpactData(changedFiles);
@@ -119,7 +119,7 @@ var analyzeDiffDefinition = {
 };
 async function handleAnalyzeDiff(input) {
   try {
-    const { parseDiff, analyzeDiff } = await import("./dist-2B363XUH.js");
+    const { parseDiff, analyzeDiff } = await import("./dist-HWXF2C3R.js");
     const parseResult = parseDiff(input.diff);
     if (!parseResult.ok) {
       return resultToMcpResponse(parseResult);
@@ -139,10 +139,10 @@ async function handleAnalyzeDiff(input) {
     let graphImpactData;
     if (input.path) {
       try {
-        const { loadGraphStore } = await import("./graph-loader-GJZ4FN4Y.js");
+        const { loadGraphStore } = await import("./graph-loader-2M2HXDQI.js");
         const store = await loadGraphStore(sanitizePath(input.path));
         if (store) {
-          const { GraphFeedbackAdapter } = await import("./dist-HXHWB7SV.js");
+          const { GraphFeedbackAdapter } = await import("./dist-B26DFXMP.js");
           const adapter = new GraphFeedbackAdapter(store);
           const changedFiles = parseResult.value.files.map((f) => f.path);
           const impact = adapter.computeImpactData(changedFiles);
@@ -195,7 +195,7 @@ var requestPeerReviewDefinition = {
 };
 async function handleRequestPeerReview(input) {
   try {
-    const { parseDiff, requestPeerReview } = await import("./dist-2B363XUH.js");
+    const { parseDiff, requestPeerReview } = await import("./dist-HWXF2C3R.js");
     const parseResult = parseDiff(input.diff);
     if (!parseResult.ok) {
       return resultToMcpResponse(parseResult);
@@ -206,10 +206,10 @@ async function handleRequestPeerReview(input) {
       ...input.context ? { metadata: { context: input.context } } : {}
     };
     try {
-      const { loadGraphStore } = await import("./graph-loader-GJZ4FN4Y.js");
+      const { loadGraphStore } = await import("./graph-loader-2M2HXDQI.js");
       const store = await loadGraphStore(sanitizePath(input.path));
       if (store) {
-        const { GraphFeedbackAdapter } = await import("./dist-HXHWB7SV.js");
+        const { GraphFeedbackAdapter } = await import("./dist-B26DFXMP.js");
         const adapter = new GraphFeedbackAdapter(store);
         const changedFiles = parseResult.value.files.map((f) => f.path);
         const impactData = adapter.computeImpactData(changedFiles);