@harness-engineering/cli 1.9.0 → 1.10.0

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-CWZ4Y2PO.js

@@ -0,0 +1,189 @@
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+import {
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/mcp/tools/entropy.ts
+async function loadEntropyGraphOptions(projectPath) {
+  const { loadGraphStore } = await import("./graph-loader-RLO3KRIX.js");
+  const store = await loadGraphStore(projectPath);
+  if (!store) return void 0;
+  const { GraphEntropyAdapter } = await import("./dist-I7DB5VKB.js");
+  const adapter = new GraphEntropyAdapter(store);
+  const driftData = adapter.computeDriftData();
+  const deadCodeData = adapter.computeDeadCodeData();
+  return {
+    graphDriftData: {
+      staleEdges: driftData.staleEdges.map((e) => ({
+        docNodeId: e.docNodeId,
+        codeNodeId: e.codeNodeId,
+        edgeType: e.edgeType
+      })),
+      missingTargets: [...driftData.missingTargets]
+    },
+    graphDeadCodeData: {
+      reachableNodeIds: new Set(deadCodeData.reachableNodeIds),
+      unreachableNodes: deadCodeData.unreachableNodes.map((n) => ({
+        id: n.id,
+        type: n.type,
+        name: n.name,
+        ...n.path !== void 0 && { path: n.path }
+      }))
+    }
+  };
+}
+var detectEntropyDefinition = {
+  name: "detect_entropy",
+  description: "Detect documentation drift, dead code, and pattern violations. Optionally auto-fix detected issues.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      type: {
+        type: "string",
+        enum: ["drift", "dead-code", "patterns", "all"],
+        description: "Type of entropy to detect (default: all)"
+      },
+      autoFix: {
+        type: "boolean",
+        description: "When true, apply fixes after analysis. Default: false (analysis only)"
+      },
+      dryRun: {
+        type: "boolean",
+        description: "Preview fixes without applying (only used when autoFix is true)"
+      },
+      fixTypes: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: [
+            "unused-imports",
+            "dead-files",
+            "dead-exports",
+            "commented-code",
+            "orphaned-deps",
+            "forbidden-import-replacement",
+            "import-ordering"
+          ]
+        },
+        description: "Specific fix types to apply (default: all safe types). Only used when autoFix is true."
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density: summary returns issue counts and top issues per category, detailed returns full findings. Default: detailed"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleDetectEntropy(input) {
+  try {
+    const { EntropyAnalyzer } = await import("./dist-PBTNVK6K.js");
+    const typeFilter = input.type ?? "all";
+    const analyzer = new EntropyAnalyzer({
+      rootDir: sanitizePath(input.path),
+      analyze: {
+        drift: typeFilter === "all" || typeFilter === "drift",
+        deadCode: typeFilter === "all" || typeFilter === "dead-code",
+        patterns: typeFilter === "all" || typeFilter === "patterns"
+      }
+    });
+    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 })
+          }
+        ]
+      };
+    }
+    if (!input.autoFix) {
+      return resultToMcpResponse(result);
+    }
+    if (!result.ok) return resultToMcpResponse(result);
+    const { createFixes, applyFixes, generateSuggestions } = await import("./dist-PBTNVK6K.js");
+    const report = result.value;
+    const deadCode = report.deadCode;
+    const fixTypesConfig = input.fixTypes ? { fixTypes: input.fixTypes } : void 0;
+    const fixes = deadCode ? createFixes(deadCode, fixTypesConfig) : [];
+    const suggestions = generateSuggestions(report.deadCode, report.drift, report.patterns);
+    if (input.dryRun) {
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ analysis: report, fixes, suggestions }) }
+        ]
+      };
+    }
+    if (fixes.length > 0) {
+      const applied = await applyFixes(fixes, {});
+      if (!applied.ok) return resultToMcpResponse(applied);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ analysis: report, ...applied.value, suggestions })
+          }
+        ]
+      };
+    }
+    return resultToMcpResponse(Ok({ analysis: report, fixes: [], applied: 0, suggestions }));
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  detectEntropyDefinition,
+  handleDetectEntropy
+};

package/dist/{chunk-ULSRSP53.js → chunk-ECUJQS3B.js}

@@ -1,115 +1,19 @@
+import {
+  logger
+} from "./chunk-HIOXKZYF.js";
+import {
+  CLIError,
+  ExitCode
+} from "./chunk-B7HFEHWP.js";
+import {
+  ALLOWED_COGNITIVE_MODES
+} from "./chunk-MDUK2J2O.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-EOLRW32Q.js

@@ -0,0 +1,72 @@
+// src/utils/paths.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function findUpFrom(startDir, targetName, marker, maxLevels) {
+  let dir = startDir;
+  for (let i = 0; i < maxLevels; i++) {
+    const candidate = path.join(dir, targetName);
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      if (fs.existsSync(path.join(candidate, marker))) {
+        return candidate;
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+function findUpDir(targetName, marker, maxLevels = 8) {
+  const fromModule = findUpFrom(__dirname, targetName, marker, maxLevels);
+  if (fromModule) return fromModule;
+  return findUpFrom(process.cwd(), targetName, marker, maxLevels);
+}
+function resolveTemplatesDir() {
+  return findUpDir("templates", "base") ?? path.join(__dirname, "templates");
+}
+function resolvePersonasDir() {
+  const agentsDir = findUpDir("agents", "personas");
+  if (agentsDir) {
+    return path.join(agentsDir, "personas");
+  }
+  return path.join(__dirname, "agents", "personas");
+}
+function resolveSkillsDir() {
+  const agentsDir = findUpDir("agents", "skills");
+  if (agentsDir) {
+    return path.join(agentsDir, "skills", "claude-code");
+  }
+  return path.join(__dirname, "agents", "skills", "claude-code");
+}
+function resolveProjectSkillsDir(cwd) {
+  let dir = cwd ?? process.cwd();
+  for (let i = 0; i < 8; i++) {
+    const candidate = path.join(dir, "agents", "skills", "claude-code");
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      const agentsDir = path.join(dir, "agents");
+      if (fs.existsSync(path.join(agentsDir, "skills"))) {
+        return candidate;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function resolveGlobalSkillsDir() {
+  const agentsDir = findUpDir("agents", "skills");
+  if (agentsDir) {
+    return path.join(agentsDir, "skills", "claude-code");
+  }
+  return path.join(__dirname, "agents", "skills", "claude-code");
+}
+
+export {
+  resolveTemplatesDir,
+  resolvePersonasDir,
+  resolveSkillsDir,
+  resolveProjectSkillsDir,
+  resolveGlobalSkillsDir
+};