@harness-engineering/cli 1.9.0 → 1.11.0

package/dist/chunk-3WGJMBKH.js

@@ -0,0 +1,45 @@
+// src/utils/errors.ts
+var ExitCode = {
+  /** Command completed successfully */
+  SUCCESS: 0,
+  /** Command failed because of a validation error (e.g. check-docs found issues) */
+  VALIDATION_FAILED: 1,
+  /** Command failed because of an unexpected error or misconfiguration */
+  ERROR: 2
+};
+var CLIError = class extends Error {
+  /** The exit code associated with this error */
+  exitCode;
+  /**
+   * Creates a new CLIError.
+   *
+   * @param message - Human-readable error message.
+   * @param exitCode - Exit code to use when process terminates. Defaults to ExitCode.ERROR.
+   */
+  constructor(message, exitCode = ExitCode.ERROR) {
+    super(message);
+    this.name = "CLIError";
+    this.exitCode = exitCode;
+  }
+};
+function formatError(error) {
+  if (error instanceof CLIError) {
+    return `Error: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return `Error: ${error.message}`;
+  }
+  return `Error: ${String(error)}`;
+}
+function handleError(error) {
+  const message = formatError(error);
+  console.error(message);
+  const exitCode = error instanceof CLIError ? error.exitCode : ExitCode.ERROR;
+  process.exit(exitCode);
+}
+
+export {
+  ExitCode,
+  CLIError,
+  handleError
+};

package/dist/{chunk-ULSRSP53.js → chunk-6N4R6FVX.js}

@@ -1,115 +1,19 @@
+import {
+  logger
+} from "./chunk-EBJQ6N4M.js";
+import {
+  CLIError,
+  ExitCode
+} from "./chunk-3WGJMBKH.js";
+import {
+  ALLOWED_COGNITIVE_MODES
+} from "./chunk-VRFZWGMS.js";
+
 // src/commands/create-skill.ts
 import { Command } from "commander";
 import * as path from "path";
 import * as fs from "fs";
 import YAML from "yaml";
-
-// src/skill/schema.ts
-import { z } from "zod";
-var SkillPhaseSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  required: z.boolean().default(true)
-});
-var SkillCliSchema = z.object({
-  command: z.string(),
-  args: z.array(
-    z.object({
-      name: z.string(),
-      description: z.string(),
-      required: z.boolean().default(false)
-    })
-  ).default([])
-});
-var SkillMcpSchema = z.object({
-  tool: z.string(),
-  input: z.record(z.string())
-});
-var SkillStateSchema = z.object({
-  persistent: z.boolean().default(false),
-  files: z.array(z.string()).default([])
-});
-var ALLOWED_TRIGGERS = [
-  "manual",
-  "on_pr",
-  "on_commit",
-  "on_new_feature",
-  "on_bug_fix",
-  "on_refactor",
-  "on_project_init",
-  "on_review",
-  "on_milestone",
-  "on_task_complete",
-  "on_doc_check"
-];
-var ALLOWED_PLATFORMS = ["claude-code", "gemini-cli"];
-var ALLOWED_COGNITIVE_MODES = [
-  "adversarial-reviewer",
-  "constructive-architect",
-  "meticulous-implementer",
-  "diagnostic-investigator",
-  "advisory-guide",
-  "meticulous-verifier"
-];
-var SkillMetadataSchema = z.object({
-  name: z.string().regex(/^[a-z][a-z0-9-]*$/, "Name must be lowercase with hyphens"),
-  version: z.string().regex(/^\d+\.\d+\.\d+$/, "Version must be semver format"),
-  description: z.string(),
-  cognitive_mode: z.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "Cognitive mode must be kebab-case").optional(),
-  triggers: z.array(z.enum(ALLOWED_TRIGGERS)),
-  platforms: z.array(z.enum(ALLOWED_PLATFORMS)),
-  tools: z.array(z.string()),
-  cli: SkillCliSchema.optional(),
-  mcp: SkillMcpSchema.optional(),
-  type: z.enum(["rigid", "flexible"]),
-  phases: z.array(SkillPhaseSchema).optional(),
-  state: SkillStateSchema.default({}),
-  depends_on: z.array(z.string()).default([])
-});
-
-// src/output/logger.ts
-import chalk from "chalk";
-var logger = {
-  info: (message) => console.log(chalk.blue("i"), message),
-  success: (message) => console.log(chalk.green("v"), message),
-  warn: (message) => console.log(chalk.yellow("!"), message),
-  error: (message) => console.error(chalk.red("x"), message),
-  dim: (message) => console.log(chalk.dim(message)),
-  // For JSON output mode
-  raw: (data) => console.log(JSON.stringify(data, null, 2))
-};
-
-// src/utils/errors.ts
-var ExitCode = {
-  SUCCESS: 0,
-  VALIDATION_FAILED: 1,
-  ERROR: 2
-};
-var CLIError = class extends Error {
-  exitCode;
-  constructor(message, exitCode = ExitCode.ERROR) {
-    super(message);
-    this.name = "CLIError";
-    this.exitCode = exitCode;
-  }
-};
-function formatError(error) {
-  if (error instanceof CLIError) {
-    return `Error: ${error.message}`;
-  }
-  if (error instanceof Error) {
-    return `Error: ${error.message}`;
-  }
-  return `Error: ${String(error)}`;
-}
-function handleError(error) {
-  const message = formatError(error);
-  console.error(message);
-  const exitCode = error instanceof CLIError ? error.exitCode : ExitCode.ERROR;
-  process.exit(exitCode);
-}
-
-// src/commands/create-skill.ts
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function buildSkillYaml(opts) {
   const doc = {
@@ -258,11 +162,6 @@ function createCreateSkillCommand() {
 }
 
 export {
-  ExitCode,
-  CLIError,
-  handleError,
-  logger,
-  SkillMetadataSchema,
   generateSkillFiles,
   createCreateSkillCommand
 };

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

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

package/dist/chunk-BM3PWGXQ.js

@@ -0,0 +1,14 @@
+// src/version.ts
+import { createRequire } from "module";
+var require_ = createRequire(import.meta.url);
+var resolved;
+try {
+  resolved = require_("../package.json").version ?? "0.0.0";
+} catch {
+  resolved = "0.0.0";
+}
+var CLI_VERSION = resolved;
+
+export {
+  CLI_VERSION
+};

package/dist/chunk-C2ERUR3L.js

@@ -0,0 +1,255 @@
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/templates/engine.ts
+import * as fs from "fs";
+import * as path from "path";
+import Handlebars from "handlebars";
+
+// src/templates/schema.ts
+import { z } from "zod";
+var MergeStrategySchema = z.object({
+  json: z.enum(["deep-merge", "overlay-wins"]).default("deep-merge"),
+  files: z.literal("overlay-wins").default("overlay-wins")
+});
+var TemplateMetadataSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  level: z.enum(["basic", "intermediate", "advanced"]).optional(),
+  framework: z.string().optional(),
+  extends: z.string().optional(),
+  mergeStrategy: MergeStrategySchema.default({}),
+  version: z.literal(1)
+});
+
+// src/templates/merger.ts
+function isPlainObject(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+function deepMergeJson(base, overlay) {
+  const result = { ...base };
+  for (const key of Object.keys(overlay)) {
+    if (isPlainObject(result[key]) && isPlainObject(overlay[key])) {
+      result[key] = deepMergeJson(
+        result[key],
+        overlay[key]
+      );
+    } else {
+      result[key] = overlay[key];
+    }
+  }
+  return result;
+}
+var CONCAT_KEYS = /* @__PURE__ */ new Set(["dependencies", "devDependencies", "peerDependencies"]);
+function mergePackageJson(base, overlay) {
+  const result = { ...base };
+  for (const key of Object.keys(overlay)) {
+    if (CONCAT_KEYS.has(key) && isPlainObject(result[key]) && isPlainObject(overlay[key])) {
+      result[key] = {
+        ...result[key],
+        ...overlay[key]
+      };
+    } else if (isPlainObject(result[key]) && isPlainObject(overlay[key])) {
+      result[key] = deepMergeJson(
+        result[key],
+        overlay[key]
+      );
+    } else {
+      result[key] = overlay[key];
+    }
+  }
+  return result;
+}
+
+// src/templates/engine.ts
+var TemplateEngine = class {
+  constructor(templatesDir) {
+    this.templatesDir = templatesDir;
+  }
+  listTemplates() {
+    try {
+      const entries = fs.readdirSync(this.templatesDir, { withFileTypes: true });
+      const templates = [];
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const metaPath = path.join(this.templatesDir, entry.name, "template.json");
+        if (!fs.existsSync(metaPath)) continue;
+        const raw = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+        const parsed = TemplateMetadataSchema.safeParse(raw);
+        if (parsed.success) templates.push(parsed.data);
+      }
+      return Ok(templates);
+    } catch (error) {
+      return Err(
+        new Error(
+          `Failed to list templates: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+    }
+  }
+  resolveTemplate(level, framework) {
+    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");
+    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 ${level}: ${metaResult.error.message}`));
+    const metadata = metaResult.data;
+    let files = [];
+    if (metadata.extends) {
+      const baseDir = path.join(this.templatesDir, metadata.extends);
+      if (fs.existsSync(baseDir)) files = this.collectFiles(baseDir, metadata.extends);
+    }
+    const levelFiles = this.collectFiles(levelDir, level);
+    files = this.mergeFileLists(files, levelFiles);
+    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);
+  }
+  render(template, 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}`
+            )
+          );
+        }
+      }
+    }
+    try {
+      for (const [outputPath, jsons] of jsonBuffers) {
+        let merged = {};
+        for (const json of jsons) {
+          merged = outputPath === "package.json" ? mergePackageJson(merged, json) : deepMergeJson(merged, json);
+        }
+        rendered.push({ relativePath: outputPath, content: JSON.stringify(merged, null, 2) });
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return Err(new Error(`JSON merge failed: ${msg}`));
+    }
+    return Ok({ files: rendered });
+  }
+  write(files, targetDir, options) {
+    try {
+      const written = [];
+      for (const file of files.files) {
+        const targetPath = path.join(targetDir, file.relativePath);
+        const dir = path.dirname(targetPath);
+        if (!options.overwrite && fs.existsSync(targetPath)) continue;
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(targetPath, file.content);
+        written.push(file.relativePath);
+      }
+      return Ok(written);
+    } catch (error) {
+      return Err(
+        new Error(
+          `Failed to write files: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+    }
+  }
+  findTemplateDir(name, type) {
+    const entries = fs.readdirSync(this.templatesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const metaPath = path.join(this.templatesDir, entry.name, "template.json");
+      if (!fs.existsSync(metaPath)) continue;
+      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);
+    }
+    return null;
+  }
+  collectFiles(dir, sourceName) {
+    const files = [];
+    const walk = (currentDir) => {
+      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else {
+          files.push({
+            relativePath: path.relative(dir, fullPath).replace(/\\/g, "/"),
+            absolutePath: fullPath,
+            isHandlebars: entry.name.endsWith(".hbs"),
+            sourceTemplate: sourceName
+          });
+        }
+      }
+    };
+    walk(dir);
+    return files;
+  }
+  mergeFileLists(base, overlay) {
+    const map = /* @__PURE__ */ new Map();
+    for (const file of base) map.set(file.relativePath, file);
+    for (const file of overlay) {
+      if (file.relativePath.endsWith(".json.hbs")) {
+        const baseKey = base.find((f) => f.relativePath === file.relativePath);
+        if (baseKey) {
+          map.set(`__overlay__${file.relativePath}`, file);
+        } else {
+          map.set(file.relativePath, file);
+        }
+      } else {
+        map.set(file.relativePath, file);
+      }
+    }
+    return Array.from(map.values());
+  }
+};
+
+export {
+  TemplateEngine
+};

package/dist/chunk-EBJQ6N4M.js

@@ -0,0 +1,39 @@
+// src/output/logger.ts
+import chalk from "chalk";
+var logger = {
+  /**
+   * Logs an informational message with a blue 'i' icon.
+   * @param message - The message to log.
+   */
+  info: (message) => console.log(chalk.blue("i"), message),
+  /**
+   * Logs a success message with a green 'v' icon.
+   * @param message - The message to log.
+   */
+  success: (message) => console.log(chalk.green("v"), message),
+  /**
+   * Logs a warning message with a yellow '!' icon.
+   * @param message - The message to log.
+   */
+  warn: (message) => console.log(chalk.yellow("!"), message),
+  /**
+   * Logs an error message with a red 'x' icon to stderr.
+   * @param message - The message to log.
+   */
+  error: (message) => console.error(chalk.red("x"), message),
+  /**
+   * Logs a dimmed message.
+   * @param message - The message to log.
+   */
+  dim: (message) => console.log(chalk.dim(message)),
+  /**
+   * Logs raw data as a formatted JSON string.
+   * Useful for JSON output mode.
+   * @param data - The data to log.
+   */
+  raw: (data) => console.log(JSON.stringify(data, null, 2))
+};
+
+export {
+  logger
+};