@harness-engineering/cli 1.13.0 → 1.14.0

package/dist/chunk-6KTUUFRN.js

@@ -0,0 +1,217 @@
+import {
+  logger
+} from "./chunk-EBJQ6N4M.js";
+import {
+  resolveConfig
+} from "./chunk-O5OJVPL6.js";
+import {
+  ExitCode
+} from "./chunk-3WGJMBKH.js";
+import {
+  Ok
+} from "./chunk-ERS5EVUZ.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"
+};
+var OutputFormatter = class {
+  /**
+   * Creates a new OutputFormatter.
+   *
+   * @param mode - The output mode to use. Defaults to TEXT.
+   */
+  constructor(mode = OutputMode.TEXT) {
+    this.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) {
+        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 && this.mode === OutputMode.VERBOSE) {
+          lines.push(`    ${chalk.dim("->")} ${issue.suggestion}`);
+        }
+      }
+    }
+    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);
+}
+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);
+      if (!fs.existsSync(expectedSpec)) {
+        missingSpecs.push({
+          implFile: path.relative(cwd, implFile).replace(/\\/g, "/"),
+          expectedSpec: path.relative(cwd, expectedSpec).replace(/\\/g, "/")
+        });
+      }
+    }
+  }
+  const pass = missingSpecs.length === 0;
+  return Ok({
+    pass,
+    skipped: false,
+    severity: phaseGates.severity,
+    missingSpecs,
+    checkedFiles
+  });
+}
+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 = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
+    const formatter = new OutputFormatter(mode);
+    const result = await runCheckPhaseGate({
+      configPath: globalOpts.config,
+      json: globalOpts.json,
+      verbose: globalOpts.verbose,
+      quiet: globalOpts.quiet
+    });
+    if (!result.ok) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ error: result.error.message }));
+      } else {
+        logger.error(result.error.message);
+      }
+      process.exit(result.error.exitCode);
+    }
+    const value = result.value;
+    if (value.skipped) {
+      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);
+    }
+    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);
+    }
+    if (!value.pass && value.severity === "error") {
+      process.exit(ExitCode.VALIDATION_FAILED);
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+  return command;
+}
+
+export {
+  OutputMode,
+  OutputFormatter,
+  findFiles,
+  runCheckPhaseGate,
+  createCheckPhaseGateCommand
+};

package/dist/{chunk-MI5XJQDY.js → chunk-7IP4JIFL.js}

@@ -1,3 +1,7 @@
+import {
+  findConfigFile,
+  loadConfig
+} from "./chunk-O5OJVPL6.js";
 import {
   resultToMcpResponse
 } from "./chunk-IDZNPTYD.js";
@@ -6,10 +10,20 @@ import {
 } from "./chunk-W6Y7ZW3Y.js";
 import {
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.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",
@@ -32,18 +46,18 @@ async function handleCheckDocs(input) {
     const projectPath = sanitizePath(input.path);
     const scope = input.scope ?? "coverage";
     if (scope === "integrity") {
-      const { validateKnowledgeMap } = await import("./dist-WF4C7A4A.js");
+      const { validateKnowledgeMap } = await import("./dist-HWXF2C3R.js");
       const result2 = await validateKnowledgeMap(projectPath);
       return resultToMcpResponse(result2);
     }
     if (scope === "all") {
-      const { checkDocCoverage: checkDocCoverage2, validateKnowledgeMap } = await import("./dist-WF4C7A4A.js");
+      const { checkDocCoverage: checkDocCoverage2, validateKnowledgeMap } = await import("./dist-HWXF2C3R.js");
       const domain2 = input.domain ?? "src";
-      const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-KO4GJ5N2.js");
+      const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-2M2HXDQI.js");
       const store2 = await loadGraphStore2(projectPath);
       let graphCoverage2;
       if (store2) {
-        const { Assembler } = await import("./dist-M6BQODWC.js");
+        const { Assembler } = await import("./dist-B26DFXMP.js");
         const assembler = new Assembler(store2);
         const report = assembler.checkCoverage();
         graphCoverage2 = {
@@ -55,7 +69,7 @@ async function handleCheckDocs(input) {
       const [coverageResult, integrityResult] = await Promise.allSettled([
         checkDocCoverage2(domain2, {
           sourceDir: path.resolve(projectPath, "src"),
-          docsDir: path.resolve(projectPath, "docs"),
+          docsDir: resolveDocsDir(projectPath),
           ...graphCoverage2 !== void 0 && { graphCoverage: graphCoverage2 }
         }),
         validateKnowledgeMap(projectPath)
@@ -76,13 +90,13 @@ async function handleCheckDocs(input) {
       }
       return resultToMcpResponse(Ok({ coverage, integrity }));
     }
-    const { checkDocCoverage } = await import("./dist-WF4C7A4A.js");
+    const { checkDocCoverage } = await import("./dist-HWXF2C3R.js");
     const domain = input.domain ?? "src";
-    const { loadGraphStore } = await import("./graph-loader-KO4GJ5N2.js");
+    const { loadGraphStore } = await import("./graph-loader-2M2HXDQI.js");
     const store = await loadGraphStore(projectPath);
     let graphCoverage;
     if (store) {
-      const { Assembler } = await import("./dist-M6BQODWC.js");
+      const { Assembler } = await import("./dist-B26DFXMP.js");
       const assembler = new Assembler(store);
       const report = assembler.checkCoverage();
       graphCoverage = {
@@ -93,7 +107,7 @@ async function handleCheckDocs(input) {
     }
     const result = await checkDocCoverage(domain, {
       sourceDir: path.resolve(projectPath, "src"),
-      docsDir: path.resolve(projectPath, "docs"),
+      docsDir: resolveDocsDir(projectPath),
       ...graphCoverage !== void 0 && { graphCoverage }
     });
     return resultToMcpResponse(result);

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