@harness-engineering/cli 1.9.0 → 1.10.0

package/dist/chunk-PMTFPOCT.js

@@ -0,0 +1,122 @@
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+
+// src/mcp/tools/review-pipeline.ts
+var runCodeReviewDefinition = {
+  name: "run_code_review",
+  description: "Run the unified 7-phase code review pipeline: gate, mechanical checks, context scoping, parallel agents, validation, deduplication, and output.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      diff: { type: "string", description: "Git diff string to review" },
+      commitMessage: {
+        type: "string",
+        description: "Most recent commit message (for change-type detection)"
+      },
+      comment: {
+        type: "boolean",
+        description: "Post inline comments to GitHub PR (requires prNumber and repo)"
+      },
+      ci: {
+        type: "boolean",
+        description: "Enable eligibility gate and non-interactive output"
+      },
+      deep: {
+        type: "boolean",
+        description: "Add threat modeling pass to security agent"
+      },
+      noMechanical: {
+        type: "boolean",
+        description: "Skip mechanical checks (useful if already run)"
+      },
+      prNumber: {
+        type: "number",
+        description: "PR number (required for --comment and CI gate)"
+      },
+      repo: {
+        type: "string",
+        description: "Repository in owner/repo format (required for --comment)"
+      }
+    },
+    required: ["path", "diff"]
+  }
+};
+async function handleRunCodeReview(input) {
+  try {
+    const { parseDiff, runReviewPipeline } = await import("./dist-PBTNVK6K.js");
+    const parseResult = parseDiff(input.diff);
+    if (!parseResult.ok) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error parsing diff: ${parseResult.error.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+    const codeChanges = parseResult.value;
+    const projectRoot = sanitizePath(input.path);
+    const diffInfo = {
+      changedFiles: codeChanges.files.map((f) => f.path),
+      newFiles: codeChanges.files.filter((f) => f.status === "added").map((f) => f.path),
+      deletedFiles: codeChanges.files.filter((f) => f.status === "deleted").map((f) => f.path),
+      totalDiffLines: input.diff.split("\n").length,
+      fileDiffs: new Map(
+        codeChanges.files.map((f) => [f.path, f.diff ?? ""])
+      )
+    };
+    const result = await runReviewPipeline({
+      projectRoot,
+      diff: diffInfo,
+      commitMessage: input.commitMessage ?? "",
+      flags: {
+        comment: input.comment ?? false,
+        ci: input.ci ?? false,
+        deep: input.deep ?? false,
+        noMechanical: input.noMechanical ?? false
+      },
+      ...input.repo != null ? { repo: input.repo } : {}
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              skipped: result.skipped,
+              skipReason: result.skipReason,
+              stoppedByMechanical: result.stoppedByMechanical,
+              assessment: result.assessment,
+              findingCount: result.findings.length,
+              terminalOutput: result.terminalOutput,
+              githubCommentCount: result.githubComments.length,
+              exitCode: result.exitCode
+            },
+            null,
+            2
+          )
+        }
+      ],
+      isError: false
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  runCodeReviewDefinition,
+  handleRunCodeReview
+};

package/dist/chunk-PSXF277V.js

@@ -0,0 +1,89 @@
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+
+// src/mcp/tools/security.ts
+import * as path from "path";
+var runSecurityScanDefinition = {
+  name: "run_security_scan",
+  description: "Run the built-in security scanner on a project or specific files. Detects secrets, injection, XSS, weak crypto, and other vulnerabilities.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      files: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional list of specific files to scan. If omitted, scans all source files."
+      },
+      strict: {
+        type: "boolean",
+        description: "Override strict mode \u2014 promotes all warnings to errors"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleRunSecurityScan(input) {
+  try {
+    const core = await import("./dist-PBTNVK6K.js");
+    const projectRoot = sanitizePath(input.path);
+    let configData = {};
+    try {
+      const fs = await import("fs");
+      const configPath = path.join(projectRoot, "harness.config.json");
+      if (fs.existsSync(configPath)) {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        configData = parsed.security ?? {};
+      }
+    } catch {
+    }
+    if (input.strict !== void 0) {
+      configData.strict = input.strict;
+    }
+    const securityConfig = core.parseSecurityConfig(configData);
+    const scanner = new core.SecurityScanner(securityConfig);
+    scanner.configureForProject(projectRoot);
+    let filesToScan;
+    if (input.files && input.files.length > 0) {
+      filesToScan = input.files.map((f) => path.resolve(projectRoot, f));
+    } else {
+      const { globFiles } = await import("./glob-helper-5OHBUQAI.js");
+      filesToScan = await globFiles(projectRoot, securityConfig.exclude);
+    }
+    const result = await scanner.scanFiles(filesToScan);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            ...result,
+            summary: {
+              errors: result.findings.filter((f) => f.severity === "error").length,
+              warnings: result.findings.filter(
+                (f) => f.severity === "warning"
+              ).length,
+              info: result.findings.filter((f) => f.severity === "info").length
+            }
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  runSecurityScanDefinition,
+  handleRunSecurityScan
+};

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