@harness-engineering/cli 1.9.0 → 1.11.0

package/dist/chunk-Q6AB7W5Z.js

@@ -0,0 +1,135 @@
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/persona/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import YAML from "yaml";
+
+// src/persona/schema.ts
+import { z } from "zod";
+var TriggerContextSchema = z.enum(["always", "on_pr", "on_commit", "on_review", "scheduled", "manual", "on_plan_approved"]).default("always");
+var CommandStepSchema = z.object({
+  command: z.string(),
+  when: TriggerContextSchema
+});
+var SkillStepSchema = z.object({
+  skill: z.string(),
+  when: TriggerContextSchema,
+  output: z.enum(["inline", "artifact", "auto"]).default("auto")
+});
+var StepSchema = z.union([CommandStepSchema, SkillStepSchema]);
+var PersonaTriggerSchema = z.discriminatedUnion("event", [
+  z.object({
+    event: z.literal("on_pr"),
+    conditions: z.object({
+      paths: z.array(z.string()).optional(),
+      min_files: z.number().optional()
+    }).optional()
+  }),
+  z.object({
+    event: z.literal("on_commit"),
+    conditions: z.object({ branches: z.array(z.string()).optional() }).optional()
+  }),
+  z.object({
+    event: z.literal("scheduled"),
+    cron: z.string()
+  }),
+  z.object({
+    event: z.literal("manual")
+  })
+]);
+var PersonaConfigSchema = z.object({
+  severity: z.enum(["error", "warning"]).default("error"),
+  autoFix: z.boolean().default(false),
+  timeout: z.number().default(3e5)
+});
+var PersonaOutputsSchema = z.object({
+  "agents-md": z.boolean().default(true),
+  "ci-workflow": z.boolean().default(true),
+  "runtime-config": z.boolean().default(true)
+});
+var PersonaSchemaV1 = z.object({
+  version: z.literal(1),
+  name: z.string(),
+  description: z.string(),
+  role: z.string(),
+  skills: z.array(z.string()),
+  commands: z.array(z.string()),
+  triggers: z.array(PersonaTriggerSchema),
+  config: PersonaConfigSchema.default({}),
+  outputs: PersonaOutputsSchema.default({})
+});
+var PersonaSchemaV2 = z.object({
+  version: z.literal(2),
+  name: z.string(),
+  description: z.string(),
+  role: z.string(),
+  skills: z.array(z.string()),
+  steps: z.array(StepSchema),
+  triggers: z.array(PersonaTriggerSchema),
+  config: PersonaConfigSchema.default({}),
+  outputs: PersonaOutputsSchema.default({})
+});
+var PersonaSchema = z.union([PersonaSchemaV1, PersonaSchemaV2]);
+
+// src/persona/loader.ts
+function normalizePersona(raw) {
+  if (raw.version === 1 && Array.isArray(raw.commands)) {
+    const { commands, ...rest } = raw;
+    return {
+      ...rest,
+      steps: commands.map((cmd) => ({
+        command: cmd,
+        when: "always"
+      }))
+    };
+  }
+  return raw;
+}
+function loadPersona(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return Err(new Error(`Persona file not found: ${filePath}`));
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = YAML.parse(raw);
+    const result = PersonaSchema.safeParse(parsed);
+    if (!result.success) {
+      return Err(new Error(`Invalid persona ${filePath}: ${result.error.message}`));
+    }
+    return Ok(normalizePersona(result.data));
+  } catch (error) {
+    return Err(
+      new Error(`Failed to load persona: ${error instanceof Error ? error.message : String(error)}`)
+    );
+  }
+}
+function listPersonas(dir) {
+  try {
+    if (!fs.existsSync(dir)) return Ok([]);
+    const entries = fs.readdirSync(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    const personas = [];
+    for (const entry of entries) {
+      const filePath = path.join(dir, entry);
+      const result = loadPersona(filePath);
+      if (result.ok) {
+        personas.push({ name: result.value.name, description: result.value.description, filePath });
+      }
+    }
+    return Ok(personas);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to list personas: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+export {
+  loadPersona,
+  listPersonas
+};

package/dist/chunk-QPEH2QPG.js

@@ -0,0 +1,347 @@
+// ../linter-gen/dist/generator/orchestrator.js
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+
+// ../linter-gen/dist/parser/config-parser.js
+import * as fs from "fs/promises";
+import * as yaml from "yaml";
+
+// ../linter-gen/dist/schema/linter-config.js
+import { z } from "zod";
+var RuleConfigSchema = z.object({
+  /** Rule name in kebab-case (e.g., 'no-ui-in-services') */
+  name: z.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "Rule name must be kebab-case"),
+  /** Rule type - determines which template to use */
+  type: z.string().min(1),
+  /** ESLint severity level */
+  severity: z.enum(["error", "warn", "off"]).default("error"),
+  /** Template-specific configuration */
+  config: z.record(z.unknown())
+});
+var LinterConfigSchema = z.object({
+  /** Config version - currently only 1 is supported */
+  version: z.literal(1),
+  /** Output directory for generated rules */
+  output: z.string().min(1),
+  /** Optional explicit template path mappings (type → path) */
+  templates: z.record(z.string()).optional(),
+  /** Rules to generate */
+  rules: z.array(RuleConfigSchema).min(1, "At least one rule is required")
+});
+
+// ../linter-gen/dist/parser/config-parser.js
+var ParseError = class extends Error {
+  code;
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "ParseError";
+  }
+};
+async function parseConfig(configPath) {
+  let content;
+  try {
+    content = await fs.readFile(configPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {
+        success: false,
+        error: new ParseError(`Config file not found: ${configPath}`, "FILE_NOT_FOUND", err)
+      };
+    }
+    return {
+      success: false,
+      error: new ParseError(`Failed to read config file: ${configPath}`, "FILE_READ_ERROR", err)
+    };
+  }
+  let parsed;
+  try {
+    parsed = yaml.parse(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: new ParseError(`Invalid YAML syntax in ${configPath}: ${err.message}`, "YAML_PARSE_ERROR", err)
+    };
+  }
+  const result = LinterConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    return {
+      success: false,
+      error: new ParseError(`Invalid config: ${issues}`, "VALIDATION_ERROR", result.error)
+    };
+  }
+  return {
+    success: true,
+    data: result.data,
+    configPath
+  };
+}
+
+// ../linter-gen/dist/engine/template-loader.js
+import * as fs2 from "fs/promises";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var TemplateLoadError = class extends Error {
+  code;
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "TemplateLoadError";
+  }
+};
+var BUILTIN_TEMPLATES = ["import-restriction", "boundary-validation", "dependency-graph"];
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadTemplateFile(filePath, type) {
+  try {
+    const content = await fs2.readFile(filePath, "utf-8");
+    return {
+      success: true,
+      source: { type, path: filePath, content }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: new TemplateLoadError(`Failed to read template: ${filePath}`, "TEMPLATE_READ_ERROR", err)
+    };
+  }
+}
+async function loadTemplate(ruleType, templatesConfig, configDir) {
+  if (templatesConfig?.[ruleType]) {
+    const explicitPath = path.resolve(configDir, templatesConfig[ruleType]);
+    if (await fileExists(explicitPath)) {
+      return loadTemplateFile(explicitPath, "explicit");
+    }
+    return {
+      success: false,
+      error: new TemplateLoadError(`Explicit template not found: ${explicitPath}`, "TEMPLATE_NOT_FOUND")
+    };
+  }
+  const conventionPath = path.join(configDir, "templates", `${ruleType}.ts.hbs`);
+  if (await fileExists(conventionPath)) {
+    return loadTemplateFile(conventionPath, "convention");
+  }
+  if (BUILTIN_TEMPLATES.includes(ruleType)) {
+    const builtinPath = path.join(__dirname, "..", "templates", `${ruleType}.ts.hbs`);
+    if (await fileExists(builtinPath)) {
+      return loadTemplateFile(builtinPath, "builtin");
+    }
+  }
+  return {
+    success: false,
+    error: new TemplateLoadError(`Template not found for type '${ruleType}'. Checked: explicit config, ./templates/${ruleType}.ts.hbs, built-in templates.`, "TEMPLATE_NOT_FOUND")
+  };
+}
+
+// ../linter-gen/dist/generator/rule-generator.js
+import * as path2 from "path";
+
+// ../linter-gen/dist/engine/context-builder.js
+var GENERATOR_VERSION = "0.1.0";
+function toCamelCase(str) {
+  return str.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function buildRuleContext(rule, configPath) {
+  return {
+    name: rule.name,
+    nameCamel: toCamelCase(rule.name),
+    namePascal: toPascalCase(rule.name),
+    severity: rule.severity,
+    config: rule.config,
+    meta: {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      generatorVersion: GENERATOR_VERSION,
+      configPath
+    }
+  };
+}
+
+// ../linter-gen/dist/engine/template-renderer.js
+import Handlebars from "handlebars";
+var TemplateError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "TemplateError";
+  }
+};
+function toCamelCase2(str) {
+  return str.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function toPascalCase2(str) {
+  const camel = toCamelCase2(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+Handlebars.registerHelper("json", (obj) => JSON.stringify(obj));
+Handlebars.registerHelper("jsonPretty", (obj) => JSON.stringify(obj, null, 2));
+Handlebars.registerHelper("camelCase", (str) => toCamelCase2(str));
+Handlebars.registerHelper("pascalCase", (str) => toPascalCase2(str));
+function renderTemplate(templateSource, context) {
+  try {
+    const compiled = Handlebars.compile(templateSource, { strict: true });
+    const output = compiled(context);
+    return { success: true, output };
+  } catch (err) {
+    return {
+      success: false,
+      error: new TemplateError(`Template rendering failed: ${err.message}`, err)
+    };
+  }
+}
+
+// ../linter-gen/dist/generator/rule-generator.js
+function generateRule(rule, template, outputDir, configPath) {
+  const context = buildRuleContext(rule, configPath);
+  const renderResult = renderTemplate(template.content, context);
+  if (!renderResult.success) {
+    return {
+      success: false,
+      error: renderResult.error,
+      ruleName: rule.name
+    };
+  }
+  const outputPath = path2.join(outputDir, `${rule.name}.ts`);
+  return {
+    success: true,
+    rule: {
+      name: rule.name,
+      outputPath,
+      content: renderResult.output
+    }
+  };
+}
+
+// ../linter-gen/dist/generator/index-generator.js
+function toCamelCase3(str) {
+  return str.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function generateIndex(ruleNames) {
+  const imports = ruleNames.map((name) => {
+    const camel = toCamelCase3(name);
+    return `import ${camel} from './${name}';`;
+  }).join("\n");
+  const rulesObject = ruleNames.map((name) => {
+    const camel = toCamelCase3(name);
+    return `  '${name}': ${camel},`;
+  }).join("\n");
+  const namedExports = ruleNames.map(toCamelCase3).join(", ");
+  return `// Generated by @harness-engineering/linter-gen
+// Do not edit manually - regenerate from harness-linter.yml
+
+${imports}
+
+export const rules = {
+${rulesObject}
+};
+
+export { ${namedExports} };
+`;
+}
+
+// ../linter-gen/dist/generator/orchestrator.js
+async function validate(options) {
+  const parseResult = await parseConfig(options.configPath);
+  if (!parseResult.success) {
+    return { success: false, error: parseResult.error };
+  }
+  return { success: true, ruleCount: parseResult.data.rules.length };
+}
+async function generate(options) {
+  const errors = [];
+  const parseResult = await parseConfig(options.configPath);
+  if (!parseResult.success) {
+    return { success: false, errors: [{ type: "parse", error: parseResult.error }] };
+  }
+  const config = parseResult.data;
+  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 });
+  }
+  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);
+  }
+  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 (errors.length > 0) {
+    return { success: false, errors };
+  }
+  return {
+    success: true,
+    rulesGenerated: generatedRules,
+    outputDir,
+    dryRun: options.dryRun ?? false
+  };
+}
+
+export {
+  RuleConfigSchema,
+  LinterConfigSchema,
+  ParseError,
+  TemplateLoadError,
+  TemplateError,
+  validate,
+  generate
+};

package/dist/chunk-TEFCFC4H.js

@@ -0,0 +1,15 @@
+// src/persona/constants.ts
+var ALLOWED_PERSONA_COMMANDS = /* @__PURE__ */ new Set([
+  "validate",
+  "check-deps",
+  "check-docs",
+  "check-perf",
+  "check-security",
+  "cleanup",
+  "fix-drift",
+  "add"
+]);
+
+export {
+  ALLOWED_PERSONA_COMMANDS
+};

package/dist/chunk-TI4TGEX6.js

@@ -0,0 +1,85 @@
+import {
+  resolveProjectConfig
+} from "./chunk-K6XAPGML.js";
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+
+// src/mcp/tools/architecture.ts
+var checkDependenciesDefinition = {
+  name: "check_dependencies",
+  description: "Validate layer boundaries and detect circular dependencies",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" }
+    },
+    required: ["path"]
+  }
+};
+async function handleCheckDependencies(input) {
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const configResult = resolveProjectConfig(projectPath);
+  if (!configResult.ok) return resultToMcpResponse(configResult);
+  try {
+    const { validateDependencies, TypeScriptParser } = await import("./dist-JVZ2MKBC.js");
+    const config = configResult.value;
+    const rawLayers = Array.isArray(config.layers) ? config.layers : [];
+    const layers = rawLayers.map((l) => ({
+      name: l.name,
+      patterns: [l.pattern],
+      allowedDependencies: l.allowedDependencies
+    }));
+    const parser = new TypeScriptParser();
+    const { loadGraphStore } = await import("./graph-loader-KO4GJ5N2.js");
+    const store = await loadGraphStore(projectPath);
+    let graphDependencyData;
+    if (store) {
+      const { GraphConstraintAdapter } = await import("./dist-M6BQODWC.js");
+      const adapter = new GraphConstraintAdapter(store);
+      const graphData = adapter.computeDependencyGraph();
+      graphDependencyData = {
+        nodes: [...graphData.nodes],
+        edges: graphData.edges.map((e) => ({ ...e }))
+      };
+    }
+    const result = await validateDependencies({
+      layers,
+      rootDir: projectPath,
+      parser,
+      ...graphDependencyData !== void 0 && { graphDependencyData }
+    });
+    return resultToMcpResponse(result);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  checkDependenciesDefinition,
+  handleCheckDependencies
+};