@pourkit/cli 0.0.0-next-20260703025114 → 0.0.0-next-20260703225916

package/dist/cli.js

@@ -355,8 +355,234 @@ import { Command, Option, CommanderError } from "commander";
 // shared/config.ts
 import { existsSync, readFileSync } from "fs";
 import { fileURLToPath } from "url";
-import { dirname, isAbsolute, join, normalize, sep, resolve } from "path";
+import { dirname, join, resolve } from "path";
 import Ajv from "ajv";
+
+// shared/config-normalization.ts
+import { isAbsolute, normalize, sep } from "path";
+var DEFAULT_MISSING_OR_EMPTY_OUTPUT_RETRIES = 3;
+var DEFAULT_BRANCH_TEMPLATE = "pourkit/{{issue.number}}/{{issue.slug}}";
+function applyOutputRetriesDefaults(retries) {
+  if (retries === void 0) return void 0;
+  return {
+    missingOrEmpty: retries.missingOrEmpty ?? DEFAULT_MISSING_OR_EMPTY_OUTPUT_RETRIES
+  };
+}
+function applyStageAgentDefaults(agent) {
+  return {
+    ...agent,
+    outputRetries: applyOutputRetriesDefaults(agent.outputRetries)
+  };
+}
+function assertRepoRelativePath(value, location) {
+  const normalized = normalize(value);
+  if (isAbsolute(value) || isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${sep}`)) {
+    throw new Error(
+      `${location} must stay within the repository and be repo-relative; got "${value}"`
+    );
+  }
+}
+function assertBaseBranch(value, location) {
+  if (value.includes("/")) {
+    throw new Error(
+      `${location} must be a local branch name, not a remote-qualified, tag, ref, or path-like name; got "${value}"`
+    );
+  }
+  if (/^[0-9a-f]{7,40}$/i.test(value)) {
+    throw new Error(
+      `${location} must be a branch name, not a commit SHA; got "${value}"`
+    );
+  }
+}
+function assertStageAgentPath(agent, location) {
+  if (!agent) return;
+  assertRepoRelativePath(agent.promptTemplate, `${location}.promptTemplate`);
+}
+function validateConfigSemantics(input) {
+  const sandbox = input.sandbox;
+  sandbox.copyToWorktree?.forEach((entry, index) => {
+    assertRepoRelativePath(entry, `sandbox.copyToWorktree[${index}]`);
+  });
+  const targetNames = /* @__PURE__ */ new Set();
+  for (const [targetIndex, target] of input.targets.entries()) {
+    if (targetNames.has(target.name)) {
+      throw new Error(
+        `Duplicate target name "${target.name}"; target names must be unique`
+      );
+    }
+    targetNames.add(target.name);
+    assertBaseBranch(target.baseBranch, `targets[${targetIndex}].baseBranch`);
+    assertStageAgentPath(
+      target.strategy.implement.builder,
+      `targets[${targetIndex}].strategy.implement.builder`
+    );
+    assertStageAgentPath(
+      target.strategy.failureResolution,
+      `targets[${targetIndex}].strategy.failureResolution`
+    );
+    assertStageAgentPath(
+      target.strategy.review.reviewer,
+      `targets[${targetIndex}].strategy.review.reviewer`
+    );
+    assertStageAgentPath(
+      target.strategy.review.refactor,
+      `targets[${targetIndex}].strategy.review.refactor`
+    );
+    assertStageAgentPath(
+      target.strategy.issueFinalReview,
+      `targets[${targetIndex}].strategy.issueFinalReview`
+    );
+    assertStageAgentPath(
+      target.strategy.finalize.prDescriptionAgent,
+      `targets[${targetIndex}].strategy.finalize.prDescriptionAgent`
+    );
+  }
+}
+function normalizePourkitConfig(input) {
+  const targets = input.targets.map((t) => {
+    const setupCommands = t.setupCommands?.map((cmd, i) => ({
+      command: cmd.command,
+      label: cmd.label ?? `check-${i}`
+    }));
+    const verifyLabeled = t.strategy.verify?.commands.map((cmd, i) => ({
+      command: cmd.command,
+      label: cmd.label ?? `check-${i}`
+    }));
+    return {
+      name: t.name,
+      baseBranch: t.baseBranch,
+      branchTemplate: t.branchTemplate ?? DEFAULT_BRANCH_TEMPLATE,
+      prdRun: t.prdRun,
+      setupCommands,
+      autoMerge: t.autoMerge ?? true,
+      queue: t.queue,
+      serena: t.serena,
+      strategy: {
+        type: "review-refactor-loop",
+        implement: {
+          builder: applyStageAgentDefaults(
+            t.strategy.implement.builder
+          )
+        },
+        failureResolution: {
+          agent: t.strategy.failureResolution.agent,
+          model: t.strategy.failureResolution.model,
+          variant: t.strategy.failureResolution.variant,
+          env: t.strategy.failureResolution.env,
+          promptTemplate: t.strategy.failureResolution.promptTemplate,
+          outputRetries: applyOutputRetriesDefaults(
+            t.strategy.failureResolution.outputRetries
+          ),
+          maxAttemptsPerFailure: t.strategy.failureResolution.maxAttemptsPerFailure,
+          failureLimits: t.strategy.failureResolution.failureLimits
+        },
+        review: {
+          reviewer: {
+            agent: t.strategy.review.reviewer.agent,
+            model: t.strategy.review.reviewer.model,
+            variant: t.strategy.review.reviewer.variant,
+            env: t.strategy.review.reviewer.env,
+            promptTemplate: t.strategy.review.reviewer.promptTemplate,
+            outputRetries: applyOutputRetriesDefaults(
+              t.strategy.review.reviewer.outputRetries
+            ),
+            criteria: t.strategy.review.reviewer.criteria,
+            includeReviewHistory: t.strategy.review.reviewer.includeReviewHistory
+          },
+          refactor: applyStageAgentDefaults(
+            t.strategy.review.refactor
+          ),
+          maxIterations: t.strategy.review.maxIterations
+        },
+        ...verifyLabeled ? { verify: { commands: verifyLabeled } } : {},
+        issueFinalReview: {
+          agent: t.strategy.issueFinalReview.agent,
+          model: t.strategy.issueFinalReview.model,
+          variant: t.strategy.issueFinalReview.variant,
+          env: t.strategy.issueFinalReview.env,
+          promptTemplate: t.strategy.issueFinalReview.promptTemplate,
+          outputRetries: applyOutputRetriesDefaults(
+            t.strategy.issueFinalReview.outputRetries
+          ),
+          maxAttempts: t.strategy.issueFinalReview.maxAttempts
+        },
+        finalize: {
+          prDescriptionAgent: applyStageAgentDefaults(
+            t.strategy.finalize.prDescriptionAgent
+          ),
+          maxAttempts: t.strategy.finalize.maxAttempts
+        }
+      }
+    };
+  });
+  const serenaConfig = input.serena;
+  const serenaDefaults = {
+    mcpUrl: serenaConfig?.mcpUrl ?? "http://localhost:9121/mcp",
+    sandboxMcpUrl: serenaConfig?.sandboxMcpUrl ?? "http://localhost:9121/mcp",
+    dataDir: serenaConfig?.dataDir ?? ".pourkit/serena/"
+  };
+  const serena = {
+    enabled: serenaConfig?.enabled ?? false,
+    required: serenaConfig?.required ?? false,
+    mcpUrl: process.env.POURKIT_SERENA_MCP_URL ?? serenaDefaults.mcpUrl,
+    sandboxMcpUrl: process.env.POURKIT_SERENA_SANDBOX_MCP_URL ?? serenaDefaults.sandboxMcpUrl,
+    dataDir: serenaDefaults.dataDir,
+    autoStart: serenaConfig?.autoStart ?? false
+  };
+  if (serena.mcpUrl.trim() === "") {
+    throw new Error("POURKIT_SERENA_MCP_URL must be a non-empty string");
+  }
+  if (serena.sandboxMcpUrl.trim() === "") {
+    throw new Error(
+      "POURKIT_SERENA_SANDBOX_MCP_URL must be a non-empty string"
+    );
+  }
+  const labels = input.labels;
+  const cleanupConfig = input.cleanup;
+  const sandboxInput = input.sandbox;
+  const checksInput = input.checks;
+  const memoryInput = input.memory;
+  return {
+    targets,
+    labels: {
+      readyForAgent: labels?.readyForAgent ?? "ready-for-agent",
+      agentInProgress: labels?.agentInProgress ?? "agent-in-progress",
+      blocked: labels?.blocked ?? "blocked",
+      prOpenAwaitingMerge: labels?.prOpenAwaitingMerge ?? "pr-open-awaiting-merge",
+      readyForHuman: labels?.readyForHuman ?? "ready-for-human",
+      needsTriage: labels?.needsTriage ?? "needs-triage"
+    },
+    sandbox: {
+      provider: sandboxInput.provider,
+      copyToWorktree: sandboxInput.copyToWorktree,
+      mounts: sandboxInput.mounts ? sandboxInput.mounts.map((m) => ({
+        hostPath: m.hostPath,
+        sandboxPath: m.sandboxPath,
+        readonly: m.readonly ?? false
+      })) : void 0,
+      env: sandboxInput.env,
+      idleTimeoutSeconds: sandboxInput.idleTimeoutSeconds,
+      forceRebuild: sandboxInput.forceRebuild
+    },
+    checks: {
+      requiredLabels: checksInput.requiredLabels,
+      allowedAuthors: checksInput.allowedAuthors,
+      checksFoundTimeoutSeconds: checksInput.checksFoundTimeoutSeconds ?? 60,
+      checksCompletionTimeoutSeconds: checksInput.checksCompletionTimeoutSeconds ?? 30 * 60,
+      pollIntervalSeconds: checksInput.pollIntervalSeconds ?? 15,
+      issueListLimit: checksInput.issueListLimit ?? 50
+    },
+    serena,
+    cleanup: {
+      enabled: cleanupConfig?.enabled ?? true,
+      worktreeRetentionDays: cleanupConfig?.worktreeRetentionDays ?? 14,
+      logRetentionDays: cleanupConfig?.logRetentionDays ?? 30
+    },
+    memory: memoryInput
+  };
+}
+
+// shared/config.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 function resolvePackagedAssetPath(fileName) {
@@ -386,8 +612,6 @@ function getValidator() {
   }
   return _validate;
 }
-var DEFAULT_MISSING_OR_EMPTY_OUTPUT_RETRIES = 3;
-var DEFAULT_BRANCH_TEMPLATE = "pourkit/{{issue.number}}/{{issue.slug}}";
 function resolveMissingOrEmptyOutputRetries(config) {
   return config?.outputRetries?.missingOrEmpty ?? DEFAULT_MISSING_OR_EMPTY_OUTPUT_RETRIES;
 }
@@ -555,98 +779,6 @@ function formatFirstAjvError(errors) {
   }
   return `${path9 || "Config"} ${error.message || "is invalid"}`;
 }
-function applyOutputRetriesDefaults(retries) {
-  if (retries === void 0) return void 0;
-  return {
-    missingOrEmpty: retries.missingOrEmpty ?? DEFAULT_MISSING_OR_EMPTY_OUTPUT_RETRIES
-  };
-}
-function applyStageAgentDefaults(agent) {
-  return {
-    ...agent,
-    outputRetries: applyOutputRetriesDefaults(agent.outputRetries)
-  };
-}
-function assertRepoRelativePath(value, location) {
-  const normalized = normalize(value);
-  if (isAbsolute(value) || isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${sep}`)) {
-    throw new Error(
-      `${location} must stay within the repository and be repo-relative; got "${value}"`
-    );
-  }
-}
-function assertBaseBranch(value, location) {
-  if (value.includes("/")) {
-    throw new Error(
-      `${location} must be a local branch name, not a remote-qualified, tag, ref, or path-like name; got "${value}"`
-    );
-  }
-  if (/^[0-9a-f]{7,40}$/i.test(value)) {
-    throw new Error(
-      `${location} must be a branch name, not a commit SHA; got "${value}"`
-    );
-  }
-}
-function assertStageAgentPath(agent, location) {
-  if (!agent) return;
-  const promptTemplate = agent.promptTemplate;
-  if (typeof promptTemplate === "string") {
-    assertRepoRelativePath(promptTemplate, `${location}.promptTemplate`);
-  }
-}
-function validateConfigSemantics(data) {
-  const sandbox = data.sandbox;
-  const copyToWorktree = sandbox?.copyToWorktree;
-  copyToWorktree?.forEach((entry, index) => {
-    assertRepoRelativePath(entry, `sandbox.copyToWorktree[${index}]`);
-  });
-  const targetNames = /* @__PURE__ */ new Set();
-  data.targets.forEach((target, targetIndex) => {
-    const name = target.name;
-    if (targetNames.has(name)) {
-      throw new Error(
-        `Duplicate target name "${name}"; target names must be unique`
-      );
-    }
-    targetNames.add(name);
-    assertBaseBranch(
-      target.baseBranch,
-      `targets[${targetIndex}].baseBranch`
-    );
-    const strategy = target.strategy;
-    const implement = strategy.implement;
-    const review = strategy.review;
-    const finalize = strategy.finalize;
-    assertStageAgentPath(
-      implement.builder,
-      `targets[${targetIndex}].strategy.implement.builder`
-    );
-    assertStageAgentPath(
-      strategy.conflictResolution,
-      `targets[${targetIndex}].strategy.conflictResolution`
-    );
-    assertStageAgentPath(
-      strategy.failureResolution,
-      `targets[${targetIndex}].strategy.failureResolution`
-    );
-    assertStageAgentPath(
-      review.reviewer,
-      `targets[${targetIndex}].strategy.review.reviewer`
-    );
-    assertStageAgentPath(
-      review.refactor,
-      `targets[${targetIndex}].strategy.review.refactor`
-    );
-    assertStageAgentPath(
-      strategy.issueFinalReview,
-      `targets[${targetIndex}].strategy.issueFinalReview`
-    );
-    assertStageAgentPath(
-      finalize.prDescriptionAgent,
-      `targets[${targetIndex}].strategy.finalize.prDescriptionAgent`
-    );
-  });
-}
 function assertKnownKeys(value, path9, knownKeys) {
   for (const key of Object.keys(value)) {
     if (!knownKeys.includes(key)) {
@@ -731,157 +863,9 @@ function parseConfig(raw) {
       )
     );
   }
-  const data = config;
-  validateConfigSemantics(data);
-  const targets = data.targets.map(
-    (t) => {
-      const input = t;
-      const strategy = input.strategy;
-      const implement = strategy.implement;
-      const failureResolution = strategy.failureResolution;
-      const review = strategy.review;
-      const reviewReviewer = review.reviewer;
-      const reviewRefactor = review.refactor;
-      const finalize = strategy.finalize;
-      const issueFinalReview = strategy.issueFinalReview;
-      const setupCommands = input.setupCommands?.map((cmd, i) => ({
-        command: cmd.command,
-        label: cmd.label ?? `check-${i}`
-      }));
-      const verifyCommands = strategy.verify?.commands ? strategy.verify.commands : void 0;
-      const verifyLabeled = verifyCommands?.map((cmd, i) => ({
-        command: cmd.command,
-        label: cmd.label ?? `check-${i}`
-      }));
-      return {
-        name: input.name,
-        baseBranch: input.baseBranch,
-        branchTemplate: input.branchTemplate ?? DEFAULT_BRANCH_TEMPLATE,
-        prdRun: input.prdRun,
-        setupCommands,
-        autoMerge: input.autoMerge !== void 0 ? input.autoMerge : true,
-        queue: input.queue,
-        serena: input.serena,
-        strategy: {
-          type: "review-refactor-loop",
-          implement: {
-            builder: applyStageAgentDefaults(
-              implement.builder
-            )
-          },
-          failureResolution: {
-            agent: failureResolution.agent,
-            model: failureResolution.model,
-            variant: failureResolution.variant,
-            env: failureResolution.env,
-            promptTemplate: failureResolution.promptTemplate,
-            outputRetries: applyOutputRetriesDefaults(
-              failureResolution.outputRetries
-            ),
-            maxAttemptsPerFailure: failureResolution.maxAttemptsPerFailure,
-            failureLimits: failureResolution.failureLimits
-          },
-          review: {
-            reviewer: {
-              agent: reviewReviewer.agent,
-              model: reviewReviewer.model,
-              variant: reviewReviewer.variant,
-              env: reviewReviewer.env,
-              promptTemplate: reviewReviewer.promptTemplate,
-              outputRetries: applyOutputRetriesDefaults(
-                reviewReviewer.outputRetries
-              ),
-              criteria: reviewReviewer.criteria,
-              includeReviewHistory: reviewReviewer.includeReviewHistory
-            },
-            refactor: applyStageAgentDefaults(
-              reviewRefactor
-            ),
-            maxIterations: review.maxIterations
-          },
-          ...verifyLabeled ? { verify: { commands: verifyLabeled } } : {},
-          issueFinalReview: {
-            ...issueFinalReview,
-            maxAttempts: issueFinalReview.maxAttempts,
-            outputRetries: applyOutputRetriesDefaults(
-              issueFinalReview.outputRetries
-            )
-          },
-          finalize: {
-            prDescriptionAgent: applyStageAgentDefaults(
-              finalize.prDescriptionAgent
-            ),
-            maxAttempts: finalize.maxAttempts
-          }
-        }
-      };
-    }
-  );
-  const serenaRaw = data.serena;
-  const serenaDefaults = {
-    mcpUrl: serenaRaw?.mcpUrl ?? "http://localhost:9121/mcp",
-    sandboxMcpUrl: serenaRaw?.sandboxMcpUrl ?? "http://localhost:9121/mcp",
-    dataDir: serenaRaw?.dataDir ?? ".pourkit/serena/"
-  };
-  const serena = {
-    enabled: serenaRaw?.enabled ?? false,
-    required: serenaRaw?.required ?? false,
-    mcpUrl: process.env.POURKIT_SERENA_MCP_URL ?? serenaDefaults.mcpUrl,
-    sandboxMcpUrl: process.env.POURKIT_SERENA_SANDBOX_MCP_URL ?? serenaDefaults.sandboxMcpUrl,
-    dataDir: serenaDefaults.dataDir,
-    autoStart: serenaRaw?.autoStart ?? false
-  };
-  if (serena.mcpUrl.trim() === "") {
-    throw new Error("POURKIT_SERENA_MCP_URL must be a non-empty string");
-  }
-  if (serena.sandboxMcpUrl.trim() === "") {
-    throw new Error(
-      "POURKIT_SERENA_SANDBOX_MCP_URL must be a non-empty string"
-    );
-  }
-  const checksRaw = data.checks;
-  const labelsRaw = data.labels;
-  const cleanupRaw = data.cleanup;
-  const sandboxRaw = data.sandbox;
-  const memoryRaw = data.memory;
-  return {
-    targets,
-    labels: {
-      readyForAgent: labelsRaw?.readyForAgent ?? "ready-for-agent",
-      agentInProgress: labelsRaw?.agentInProgress ?? "agent-in-progress",
-      blocked: labelsRaw?.blocked ?? "blocked",
-      prOpenAwaitingMerge: labelsRaw?.prOpenAwaitingMerge ?? "pr-open-awaiting-merge",
-      readyForHuman: labelsRaw?.readyForHuman ?? "ready-for-human",
-      needsTriage: labelsRaw?.needsTriage ?? "needs-triage"
-    },
-    sandbox: {
-      provider: sandboxRaw?.provider ?? "docker",
-      copyToWorktree: sandboxRaw?.copyToWorktree,
-      mounts: sandboxRaw?.mounts ? sandboxRaw.mounts.map((m) => ({
-        hostPath: m.hostPath,
-        sandboxPath: m.sandboxPath,
-        readonly: m.readonly ?? false
-      })) : void 0,
-      env: sandboxRaw?.env,
-      idleTimeoutSeconds: sandboxRaw?.idleTimeoutSeconds,
-      forceRebuild: sandboxRaw?.forceRebuild
-    },
-    checks: {
-      requiredLabels: checksRaw?.requiredLabels ?? [],
-      allowedAuthors: checksRaw?.allowedAuthors ?? [],
-      checksFoundTimeoutSeconds: checksRaw?.checksFoundTimeoutSeconds ?? 60,
-      checksCompletionTimeoutSeconds: checksRaw?.checksCompletionTimeoutSeconds ?? 30 * 60,
-      pollIntervalSeconds: checksRaw?.pollIntervalSeconds ?? 15,
-      issueListLimit: checksRaw?.issueListLimit ?? 50
-    },
-    serena,
-    cleanup: {
-      enabled: cleanupRaw?.enabled ?? true,
-      worktreeRetentionDays: cleanupRaw?.worktreeRetentionDays ?? 14,
-      logRetentionDays: cleanupRaw?.logRetentionDays ?? 30
-    },
-    memory: memoryRaw
-  };
+  const input = raw;
+  validateConfigSemantics(input);
+  return normalizePourkitConfig(input);
 }
 function getVerificationCommands(target) {
   return target.strategy.verify?.commands ?? [];
@@ -19343,11 +19327,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260703025114")) {
-    return "0.0.0-next-20260703025114";
+  if (isPackageVersion("0.0.0-next-20260703225916")) {
+    return "0.0.0-next-20260703225916";
   }
-  if (isReleaseVersion("0.0.0-next-20260703025114")) {
-    return "0.0.0-next-20260703025114";
+  if (isReleaseVersion("0.0.0-next-20260703225916")) {
+    return "0.0.0-next-20260703225916";
   }
   try {
     const root = repoRoot();