@harness-engineering/cli 1.13.1 → 1.15.0

package/dist/{chunk-C2ERUR3L.js → chunk-7MJAPE3Z.js}

@@ -1,7 +1,7 @@
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/templates/engine.ts
 import * as fs from "fs";
@@ -10,6 +10,19 @@ import Handlebars from "handlebars";
 
 // src/templates/schema.ts
 import { z } from "zod";
+var LanguageEnum = z.enum(["typescript", "python", "go", "rust", "java"]);
+var ToolingSchema = 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()
+});
+var DetectPatternSchema = z.object({
+  file: z.string(),
+  contains: z.string().optional()
+});
 var MergeStrategySchema = z.object({
   json: z.enum(["deep-merge", "overlay-wins"]).default("deep-merge"),
   files: z.literal("overlay-wins").default("overlay-wins")
@@ -21,7 +34,10 @@ var TemplateMetadataSchema = z.object({
   framework: z.string().optional(),
   extends: z.string().optional(),
   mergeStrategy: MergeStrategySchema.default({}),
-  version: z.literal(1)
+  version: z.literal(1),
+  language: LanguageEnum.optional(),
+  tooling: ToolingSchema.optional(),
+  detect: z.array(DetectPatternSchema).optional()
 });
 
 // src/templates/merger.ts
@@ -64,6 +80,57 @@ function mergePackageJson(base, overlay) {
 }
 
 // src/templates/engine.ts
+var NON_JSON_PACKAGE_CONFIGS = /* @__PURE__ */ new Set(["pyproject.toml", "go.mod", "Cargo.toml", "pom.xml"]);
+function scoreDetectPatterns(targetDir, patterns) {
+  let score = 0;
+  for (const pattern of patterns) {
+    const filePath = path.join(targetDir, pattern.file);
+    if (!fs.existsSync(filePath)) continue;
+    if (!pattern.contains) {
+      score++;
+      continue;
+    }
+    const fd = fs.openSync(filePath, "r");
+    try {
+      const buf = Buffer.alloc(65536);
+      const bytesRead = fs.readSync(fd, buf, 0, 65536, 0);
+      const content = buf.toString("utf-8", 0, bytesRead);
+      if (content.includes(pattern.contains)) score++;
+    } finally {
+      fs.closeSync(fd);
+    }
+  }
+  return score;
+}
+function applyLanguageDefaults(context) {
+  return {
+    ...context,
+    ...context.language === "python" && context.pythonMinVersion === void 0 && { pythonMinVersion: "3.10" },
+    ...context.language === "go" && context.goModulePath === void 0 && {
+      goModulePath: `github.com/example/${context.projectName}`
+    },
+    ...context.language === "java" && context.javaGroupId === void 0 && {
+      javaGroupId: `com.example.${context.projectName.replace(/[^a-zA-Z0-9]/g, "").toLowerCase()}`
+    },
+    ...context.language === "rust" && context.rustEdition === void 0 && { rustEdition: "2021" }
+  };
+}
+function mergeJsonBuffers(jsonBuffers) {
+  try {
+    const results = [];
+    for (const [outputPath, jsons] of jsonBuffers) {
+      let merged = {};
+      for (const json of jsons) {
+        merged = outputPath === "package.json" ? mergePackageJson(merged, json) : deepMergeJson(merged, json);
+      }
+      results.push({ relativePath: outputPath, content: JSON.stringify(merged, null, 2) });
+    }
+    return Ok(results);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return Err(new Error(`JSON merge failed: ${msg}`));
+  }
+}
 var TemplateEngine = class {
   constructor(templatesDir) {
     this.templatesDir = templatesDir;
@@ -89,7 +156,13 @@ var TemplateEngine = class {
       );
     }
   }
-  resolveTemplate(level, framework) {
+  resolveTemplate(level, framework, language) {
+    if (language && language !== "typescript") {
+      return this.resolveLanguageTemplate(language, framework);
+    }
+    if (!level) {
+      return Err(new Error("Level is required for TypeScript/JavaScript templates"));
+    }
     const levelDir = this.findTemplateDir(level, "level");
     if (!levelDir) return Err(new Error(`Template not found for level: ${level}`));
     const metaPath = path.join(levelDir, "template.json");
@@ -122,69 +195,60 @@ var TemplateEngine = class {
     return Ok(resolved);
   }
   render(template, context) {
+    const effectiveContext = applyLanguageDefaults(context);
     const rendered = [];
     const jsonBuffers = /* @__PURE__ */ new Map();
     for (const file of template.files) {
-      const outputPath = file.relativePath.replace(/\.hbs$/, "");
-      if (file.isHandlebars) {
-        try {
-          const raw = fs.readFileSync(file.absolutePath, "utf-8");
-          const compiled = Handlebars.compile(raw, { strict: true });
-          const content = compiled(context);
-          if (outputPath.endsWith(".json") && file.relativePath.endsWith(".json.hbs")) {
-            if (!jsonBuffers.has(outputPath)) jsonBuffers.set(outputPath, []);
-            jsonBuffers.get(outputPath).push(JSON.parse(content));
-          } else {
-            rendered.push({ relativePath: outputPath, content });
-          }
-        } catch (error) {
-          const msg = error instanceof Error ? error.message : String(error);
-          return Err(
-            new Error(
-              `Template render failed in ${file.sourceTemplate}/${file.relativePath}: ${msg}`
-            )
-          );
-        }
-      } else {
-        try {
-          const content = fs.readFileSync(file.absolutePath, "utf-8");
-          rendered.push({ relativePath: file.relativePath, content });
-        } catch (error) {
-          const msg = error instanceof Error ? error.message : String(error);
-          return Err(
-            new Error(
-              `Template render failed in ${file.sourceTemplate}/${file.relativePath}: ${msg}`
-            )
-          );
-        }
-      }
+      const result = this.renderFile(file, effectiveContext, jsonBuffers);
+      if (!result.ok) return result;
+      if (result.value) rendered.push(result.value);
     }
+    const mergeResult = mergeJsonBuffers(jsonBuffers);
+    if (!mergeResult.ok) return mergeResult;
+    rendered.push(...mergeResult.value);
+    return Ok({ files: rendered });
+  }
+  renderFile(file, context, jsonBuffers) {
+    const outputPath = file.relativePath.replace(/\.hbs$/, "");
     try {
-      for (const [outputPath, jsons] of jsonBuffers) {
-        let merged = {};
-        for (const json of jsons) {
-          merged = outputPath === "package.json" ? mergePackageJson(merged, json) : deepMergeJson(merged, json);
+      if (file.isHandlebars) {
+        const raw = fs.readFileSync(file.absolutePath, "utf-8");
+        const compiled = Handlebars.compile(raw, { strict: true });
+        const content2 = compiled(context);
+        if (outputPath.endsWith(".json") && file.relativePath.endsWith(".json.hbs")) {
+          if (!jsonBuffers.has(outputPath)) jsonBuffers.set(outputPath, []);
+          jsonBuffers.get(outputPath).push(JSON.parse(content2));
+          return Ok(null);
         }
-        rendered.push({ relativePath: outputPath, content: JSON.stringify(merged, null, 2) });
+        return Ok({ relativePath: outputPath, content: content2 });
       }
+      const content = fs.readFileSync(file.absolutePath, "utf-8");
+      return Ok({ relativePath: file.relativePath, content });
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
-      return Err(new Error(`JSON merge failed: ${msg}`));
+      return Err(
+        new Error(`Template render failed in ${file.sourceTemplate}/${file.relativePath}: ${msg}`)
+      );
     }
-    return Ok({ files: rendered });
   }
   write(files, targetDir, options) {
     try {
       const written = [];
+      const skippedConfigs = [];
+      const isNonJsLanguage = options.language && options.language !== "typescript";
       for (const file of files.files) {
         const targetPath = path.join(targetDir, file.relativePath);
         const dir = path.dirname(targetPath);
+        if (!options.overwrite && isNonJsLanguage && NON_JSON_PACKAGE_CONFIGS.has(file.relativePath) && fs.existsSync(targetPath)) {
+          skippedConfigs.push(file.relativePath);
+          continue;
+        }
         if (!options.overwrite && fs.existsSync(targetPath)) continue;
         fs.mkdirSync(dir, { recursive: true });
         fs.writeFileSync(targetPath, file.content);
         written.push(file.relativePath);
       }
-      return Ok(written);
+      return Ok({ written, skippedConfigs });
     } catch (error) {
       return Err(
         new Error(
@@ -193,6 +257,61 @@ var TemplateEngine = class {
       );
     }
   }
+  detectFramework(targetDir) {
+    try {
+      const templatesResult = this.listTemplates();
+      if (!templatesResult.ok) return Err(templatesResult.error);
+      const candidates = [];
+      for (const meta of templatesResult.value) {
+        if (!meta.detect || meta.detect.length === 0) continue;
+        if (!meta.framework || !meta.language) continue;
+        const score = scoreDetectPatterns(targetDir, meta.detect);
+        if (score > 0) {
+          candidates.push({
+            framework: meta.framework,
+            language: meta.language,
+            score,
+            templateName: meta.name
+          });
+        }
+      }
+      candidates.sort((a, b) => b.score - a.score);
+      return Ok(candidates);
+    } catch (error) {
+      return Err(
+        new Error(
+          `Framework detection failed: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+    }
+  }
+  resolveLanguageTemplate(language, framework) {
+    const baseName = `${language}-base`;
+    const baseDir = this.findTemplateDir(baseName, "name");
+    if (!baseDir) return Err(new Error(`Language base template not found: ${baseName}`));
+    const metaPath = path.join(baseDir, "template.json");
+    const metaRaw = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+    const metaResult = TemplateMetadataSchema.safeParse(metaRaw);
+    if (!metaResult.success)
+      return Err(new Error(`Invalid template.json in ${baseName}: ${metaResult.error.message}`));
+    const metadata = metaResult.data;
+    let files = this.collectFiles(baseDir, baseName);
+    let overlayMetadata;
+    if (framework) {
+      const frameworkDir = this.findTemplateDir(framework, "framework");
+      if (!frameworkDir) return Err(new Error(`Framework template not found: ${framework}`));
+      const fMetaPath = path.join(frameworkDir, "template.json");
+      const fMetaRaw = JSON.parse(fs.readFileSync(fMetaPath, "utf-8"));
+      const fMetaResult = TemplateMetadataSchema.safeParse(fMetaRaw);
+      if (fMetaResult.success) overlayMetadata = fMetaResult.data;
+      const frameworkFiles = this.collectFiles(frameworkDir, framework);
+      files = this.mergeFileLists(files, frameworkFiles);
+    }
+    files = files.filter((f) => f.relativePath !== "template.json");
+    const resolved = { metadata, files };
+    if (overlayMetadata !== void 0) resolved.overlayMetadata = overlayMetadata;
+    return Ok(resolved);
+  }
   findTemplateDir(name, type) {
     const entries = fs.readdirSync(this.templatesDir, { withFileTypes: true });
     for (const entry of entries) {
@@ -202,11 +321,8 @@ var TemplateEngine = class {
       const raw = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
       const parsed = TemplateMetadataSchema.safeParse(raw);
       if (!parsed.success) continue;
-      if (type === "level" && parsed.data.level === name)
-        return path.join(this.templatesDir, entry.name);
-      if (type === "framework" && parsed.data.framework === name)
-        return path.join(this.templatesDir, entry.name);
-      if (parsed.data.name === name) return path.join(this.templatesDir, entry.name);
+      const fieldValue = parsed.data[type];
+      if (fieldValue === name) return path.join(this.templatesDir, entry.name);
     }
     return null;
   }

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

@@ -4,11 +4,11 @@ import {
 } from "./chunk-3WGJMBKH.js";
 import {
   ArchConfigSchema
-} from "./chunk-PQ5YK4AY.js";
+} from "./chunk-Z2OOPXJO.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-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-TKJZKICB.js → chunk-EDXIVMAP.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-W6Y7ZW3Y.js";
 import {
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/mcp/tools/performance.ts
 var checkPerformanceDefinition = {
@@ -27,7 +27,7 @@ var checkPerformanceDefinition = {
 };
 async function handleCheckPerformance(input) {
   try {
-    const { EntropyAnalyzer } = await import("./dist-2B363XUH.js");
+    const { EntropyAnalyzer } = await import("./dist-ALQDD67R.js");
     const typeFilter = input.type ?? "all";
     const projectPath = sanitizePath(input.path);
     const analyzer = new EntropyAnalyzer({
@@ -40,10 +40,10 @@ async function handleCheckPerformance(input) {
     });
     let graphOptions;
     try {
-      const { loadGraphStore } = await import("./graph-loader-GJZ4FN4Y.js");
+      const { loadGraphStore } = await import("./graph-loader-2M2HXDQI.js");
       const store = await loadGraphStore(projectPath);
       if (store) {
-        const { GraphComplexityAdapter, GraphCouplingAdapter } = await import("./dist-HXHWB7SV.js");
+        const { GraphComplexityAdapter, GraphCouplingAdapter } = await import("./dist-B26DFXMP.js");
         const complexityAdapter = new GraphComplexityAdapter(store);
         const couplingAdapter = new GraphCouplingAdapter(store);
         graphOptions = {
@@ -80,7 +80,7 @@ var getPerfBaselinesDefinition = {
 };
 async function handleGetPerfBaselines(input) {
   try {
-    const { BaselineManager } = await import("./dist-2B363XUH.js");
+    const { BaselineManager } = await import("./dist-ALQDD67R.js");
     const manager = new BaselineManager(sanitizePath(input.path));
     const baselines = manager.load();
     return resultToMcpResponse(
@@ -128,7 +128,7 @@ var updatePerfBaselinesDefinition = {
 };
 async function handleUpdatePerfBaselines(input) {
   try {
-    const { BaselineManager } = await import("./dist-2B363XUH.js");
+    const { BaselineManager } = await import("./dist-ALQDD67R.js");
     const manager = new BaselineManager(sanitizePath(input.path));
     manager.save(input.results, input.commitHash);
     const updated = manager.load();
@@ -158,7 +158,7 @@ var getCriticalPathsDefinition = {
 };
 async function handleGetCriticalPaths(input) {
   try {
-    const { CriticalPathResolver } = await import("./dist-2B363XUH.js");
+    const { CriticalPathResolver } = await import("./dist-ALQDD67R.js");
     const resolver = new CriticalPathResolver(sanitizePath(input.path));
     const result = await resolver.resolve();
     return resultToMcpResponse(Ok(result));

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";