@harness-engineering/cli 1.23.2 → 1.24.1

package/dist/chunk-C5FTJ3EU.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-TZQUURSP.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-CQ553GZO.js

@@ -0,0 +1,350 @@
+// ../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.4";
+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 };
+}
+function resolveOutputDir(options, configOutput) {
+  const configDir = path3.dirname(path3.resolve(options.configPath));
+  return options.outputDir ? path3.resolve(options.outputDir) : path3.resolve(configDir, configOutput);
+}
+async function prepareOutputDir(outputDir, clean) {
+  if (clean) {
+    try {
+      await fs3.rm(outputDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  await fs3.mkdir(outputDir, { recursive: true });
+}
+async function processRule(rule, templates, configDir, outputDir, configPath, dryRun, errors) {
+  const templateResult = await loadTemplate(rule.type, templates, configDir);
+  if (!templateResult.success) {
+    errors.push({ type: "template", error: templateResult.error, ruleName: rule.name });
+    return null;
+  }
+  const ruleResult = generateRule(rule, templateResult.source, outputDir, configPath);
+  if (!ruleResult.success) {
+    errors.push({ type: "render", error: ruleResult.error, ruleName: ruleResult.ruleName });
+    return null;
+  }
+  if (!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 });
+      return null;
+    }
+  }
+  return rule.name;
+}
+async function writeIndexFile(outputDir, generatedRules, errors) {
+  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 });
+  }
+}
+async function processAllRules(rules, templates, configDir, outputDir, configPath, dryRun, errors) {
+  const generatedRules = [];
+  for (const rule of rules) {
+    const name = await processRule(rule, templates, configDir, outputDir, configPath, dryRun, errors);
+    if (name)
+      generatedRules.push(name);
+  }
+  return generatedRules;
+}
+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 outputDir = resolveOutputDir(options, config.output);
+  const dryRun = options.dryRun ?? false;
+  const configDir = path3.dirname(path3.resolve(options.configPath));
+  if (!dryRun) {
+    await prepareOutputDir(outputDir, options.clean ?? false);
+  }
+  const generatedRules = await processAllRules(config.rules, config.templates, configDir, outputDir, options.configPath, dryRun, errors);
+  if (generatedRules.length > 0 && !dryRun) {
+    await writeIndexFile(outputDir, generatedRules, errors);
+  }
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+  return { success: true, rulesGenerated: generatedRules, outputDir, dryRun };
+}
+
+export {
+  RuleConfigSchema,
+  LinterConfigSchema,
+  ParseError,
+  TemplateLoadError,
+  TemplateError,
+  validate,
+  generate
+};

package/dist/chunk-GISMXMVL.js

@@ -0,0 +1,164 @@
+// src/persona/runner.ts
+import { setTimeout } from "timers";
+
+// src/persona/trigger-detector.ts
+import * as fs from "fs";
+import * as path from "path";
+function detectTrigger(projectPath) {
+  const handoffPath = path.join(projectPath, ".harness", "handoff.json");
+  if (!fs.existsSync(handoffPath)) {
+    return { trigger: "manual" };
+  }
+  try {
+    const raw = fs.readFileSync(handoffPath, "utf-8");
+    const handoff = JSON.parse(raw);
+    if (handoff.fromSkill === "harness-planning" && Array.isArray(handoff.pending) && handoff.pending.length > 0) {
+      return {
+        trigger: "on_plan_approved",
+        handoff: {
+          fromSkill: handoff.fromSkill,
+          summary: handoff.summary ?? "",
+          pending: handoff.pending,
+          planPath: handoff.planPath
+        }
+      };
+    }
+    return { trigger: "manual" };
+  } catch {
+    return { trigger: "manual" };
+  }
+}
+
+// src/persona/runner.ts
+var TIMEOUT_ERROR_MESSAGE = "__PERSONA_RUNNER_TIMEOUT__";
+function stepName(step) {
+  return "command" in step ? step.command : step.skill;
+}
+function stepType(step) {
+  return "command" in step ? "command" : "skill";
+}
+function matchesTrigger(step, trigger) {
+  const when = step.when ?? "always";
+  return when === "always" || when === trigger;
+}
+function skipRemaining(activeSteps, fromIndex, report) {
+  for (let j = fromIndex; j < activeSteps.length; j++) {
+    const remaining = activeSteps[j];
+    report.steps.push({
+      name: stepName(remaining),
+      type: stepType(remaining),
+      status: "skipped",
+      durationMs: 0
+    });
+  }
+}
+async function executeCommandStep(command, remainingTime, context) {
+  const timeoutResult = {
+    ok: false,
+    error: new Error(TIMEOUT_ERROR_MESSAGE)
+  };
+  const result = await Promise.race([
+    context.commandExecutor(command),
+    new Promise(
+      (resolve) => setTimeout(() => resolve(timeoutResult), remainingTime)
+    )
+  ]);
+  if (result.ok) {
+    return { stepReport: { name: command, type: "command", status: "pass", result: result.value } };
+  }
+  if (result.error.message === TIMEOUT_ERROR_MESSAGE) {
+    return {
+      stepReport: { name: command, type: "command", status: "skipped", error: "timed out" },
+      halt: "partial"
+    };
+  }
+  return {
+    stepReport: { name: command, type: "command", status: "fail", error: result.error.message },
+    halt: "fail"
+  };
+}
+async function executeSkillStep(step, trigger, remainingTime, context, handoff) {
+  const SKILL_TIMEOUT_RESULT = {
+    status: "fail",
+    output: "timed out",
+    durationMs: 0
+  };
+  const skillContext = {
+    trigger,
+    projectPath: context.projectPath,
+    outputMode: step.output ?? "auto",
+    ...handoff ? { handoff } : {}
+  };
+  const result = await Promise.race([
+    context.skillExecutor(step.skill, skillContext),
+    new Promise(
+      (resolve) => setTimeout(() => resolve(SKILL_TIMEOUT_RESULT), remainingTime)
+    )
+  ]);
+  if (result === SKILL_TIMEOUT_RESULT) {
+    return {
+      stepReport: { name: step.skill, type: "skill", status: "skipped", error: "timed out" },
+      halt: "partial"
+    };
+  }
+  if (result.status === "pass") {
+    return {
+      stepReport: {
+        name: step.skill,
+        type: "skill",
+        status: "pass",
+        result: result.output,
+        ...result.artifactPath ? { artifactPath: result.artifactPath } : {}
+      }
+    };
+  }
+  return {
+    stepReport: { name: step.skill, type: "skill", status: "fail", error: result.output },
+    halt: "fail"
+  };
+}
+async function runPersona(persona, context) {
+  const startTime = Date.now();
+  const timeout = persona.config.timeout;
+  const report = {
+    persona: persona.name.toLowerCase().replace(/\s+/g, "-"),
+    status: "pass",
+    steps: [],
+    totalDurationMs: 0
+  };
+  let resolvedTrigger;
+  let handoff = context.handoff;
+  if (context.trigger === "auto") {
+    const detection = detectTrigger(context.projectPath);
+    resolvedTrigger = detection.trigger;
+    handoff = detection.handoff ?? handoff;
+  } else {
+    resolvedTrigger = context.trigger;
+  }
+  const activeSteps = persona.steps.filter((s) => matchesTrigger(s, resolvedTrigger));
+  for (let i = 0; i < activeSteps.length; i++) {
+    const step = activeSteps[i];
+    if (Date.now() - startTime >= timeout) {
+      skipRemaining(activeSteps, i, report);
+      report.status = "partial";
+      break;
+    }
+    const stepStart = Date.now();
+    const remainingTime = timeout - (Date.now() - startTime);
+    const outcome = "command" in step ? await executeCommandStep(step.command, remainingTime, context) : await executeSkillStep(step, resolvedTrigger, remainingTime, context, handoff);
+    const durationMs = Date.now() - stepStart;
+    report.steps.push({ ...outcome.stepReport, durationMs });
+    if (outcome.halt) {
+      report.status = outcome.halt;
+      skipRemaining(activeSteps, i + 1, report);
+      break;
+    }
+  }
+  report.totalDurationMs = Date.now() - startTime;
+  return report;
+}
+
+export {
+  detectTrigger,
+  runPersona
+};