@lsctech/polaris 0.5.5 → 0.5.7

package/dist/loop/worker-packet.js

@@ -11,7 +11,7 @@
  * accept BootstrapPacket transparently accept WorkerPacket.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STARTUP_RETURN_CONTRACT = exports.PREFLIGHT_RETURN_CONTRACT = exports.WORKER_PROHIBITED_WRITE_PATHS = exports.FINALIZE_RETURN_CONTRACT = exports.IMPL_RETURN_CONTRACT = void 0;
+exports.REPAIR_RETURN_CONTRACT = exports.STARTUP_RETURN_CONTRACT = exports.PREFLIGHT_RETURN_CONTRACT = exports.WORKER_PROHIBITED_WRITE_PATHS = exports.FINALIZE_RETURN_CONTRACT = exports.IMPL_RETURN_CONTRACT = void 0;
 exports.roleContextForWorkerRole = roleContextForWorkerRole;
 exports.isWorkerPacket = isWorkerPacket;
 exports.getWorkerCommitPolicy = getWorkerCommitPolicy;
@@ -19,6 +19,7 @@ exports.compileStartupPacket = compileStartupPacket;
 exports.compileImplPacket = compileImplPacket;
 exports.compileFinalizePacket = compileFinalizePacket;
 exports.compilePreflightPacket = compilePreflightPacket;
+exports.compileRepairWorkerPacket = compileRepairWorkerPacket;
 const worker_prompt_js_1 = require("./worker-prompt.js");
 const body_parser_js_1 = require("./body-parser.js");
 const WORKER_ROLE_CONTEXT = {
@@ -421,3 +422,76 @@ function compilePreflightPacket(input) {
         },
     };
 }
+/** Return contract for repair workers (same shape as impl). */
+exports.REPAIR_RETURN_CONTRACT = [
+    'child_id',
+    'status',
+    'commit',
+    'validation',
+    'next_recommended_action',
+];
+/**
+ * Build a compiled repair worker packet.
+ *
+ * Repair workers use `worker_role: "repair"` and the same sealed packet/result
+ * contracts as impl workers, but with tightly scoped allowed/prohibited paths
+ * derived from the compiled repair packet manifest.
+ *
+ * The parent/orchestrator MUST use this function and MUST NOT implement
+ * repair work inline.
+ */
+function compileRepairWorkerPacket(input) {
+    const steps = [
+        `Confirm QC repair scope: allowed=${JSON.stringify(input.allowedScope)}, prohibited=${JSON.stringify(input.prohibitedScope)}.`,
+        `Review root-cause hint: ${input.rootCauseHint}`,
+        `Apply minimal repair to files within allowed scope only. Do NOT touch prohibited paths.`,
+        `Run validation commands and confirm all pass.`,
+        `Create exactly ONE git commit: [REPAIR] ${input.clusterId} round-${input.round} packet-${input.packetId}.`,
+        `Write compact return JSON to stdout (fields: ${exports.REPAIR_RETURN_CONTRACT.join(', ')}). next_recommended_action MUST be "continue" on success, "stop" on unresolvable blocker.`,
+        `TERMINATE SESSION IMMEDIATELY.`,
+    ];
+    return {
+        schema_version: '2.1',
+        worker_role: 'repair',
+        run_id: input.runId,
+        cluster_id: input.clusterId,
+        active_child: input.packetId,
+        state_file: input.stateFile,
+        telemetry_file: input.telemetryFile,
+        instructions: {
+            primary_goal: `QC repair worker for cluster ${input.clusterId}, round ${input.round}, packet ${input.packetId}. ` +
+                `Apply minimal targeted repairs to findings within the allowed scope. Root cause: ${input.rootCauseHint}`,
+            steps,
+            allowed_scope: input.allowedScope,
+            validation_commands: input.validationCommands,
+        },
+        lifecycle: defaultLifecycle(input.maxConcurrentWorkers ?? 1, 'commit-and-exit'),
+        return_contract: exports.REPAIR_RETURN_CONTRACT,
+        prompt_mode: 'full',
+        prompt_metrics: { mode: 'full', char_count: 0, estimated_tokens: 0 },
+        role_context: roleContextForWorkerRole('repair'),
+        routing_context: {
+            task_type: "repair",
+            required_capabilities: ["repair"],
+        },
+        prohibited_write_paths: [
+            ...exports.WORKER_PROHIBITED_WRITE_PATHS,
+            ...input.prohibitedScope,
+        ],
+        result_file_contract: {
+            result_file: input.resultFile,
+            result_required_fields: Object.fromEntries([
+                ['run_id', input.runId],
+                ['cluster_id', input.clusterId],
+                ['child_id', input.packetId],
+                ...exports.REPAIR_RETURN_CONTRACT.filter((key) => key !== 'child_id').map((key) => [key, `<${key}>`]),
+            ]),
+        },
+        context: {
+            branch: input.branch,
+            worker_role: 'repair',
+            repair_round: input.round,
+            repair_packet_id: input.packetId,
+        },
+    };
+}

package/dist/qc/fixtures/repair-packets.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TEST_CONFIG = void 0;
+exports.makeFinding = makeFinding;
+exports.makeResult = makeResult;
+exports.makeSameFileFindings = makeSameFileFindings;
+exports.makeCrossFileSubsystemFindings = makeCrossFileSubsystemFindings;
+exports.makeOverlappingScopeFindings = makeOverlappingScopeFindings;
+exports.makeHighRiskFindings = makeHighRiskFindings;
+exports.makeLowConfidenceBroadFindings = makeLowConfidenceBroadFindings;
+exports.DEFAULT_TEST_CONFIG = {
+    enabled: true,
+    severityThresholds: { block: "high", repair: "medium", followUp: "low" },
+};
+function makeFinding(overrides = {}) {
+    return {
+        findingId: `f-${Math.random().toString(36).slice(2, 8)}`,
+        severity: "medium",
+        category: "style",
+        title: "Test finding",
+        fixAvailable: true,
+        autofixEligible: false,
+        attribution: { confidence: "high", reason: "changed-file-owner", childId: "POL-472" },
+        status: "open",
+        ...overrides,
+    };
+}
+function makeResult(overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: "1.0",
+        qcRunId: `qc-run-${Math.random().toString(36).slice(2, 8)}`,
+        runId: "run-1",
+        clusterId: "POL-TEST",
+        trigger: "completed-cluster",
+        provider: "coderabbit",
+        providerMode: "local",
+        startedAt: now,
+        completedAt: now,
+        status: "findings",
+        findings: [],
+        rawArtifactPaths: [],
+        parserVersion: "coderabbit-1.0",
+        policyDecision: {
+            blocksDelivery: false,
+            requiresOperatorReview: false,
+            routedToRepair: false,
+            summary: "ok",
+        },
+        ...overrides,
+    };
+}
+function makeSameFileFindings() {
+    return [
+        makeFinding({
+            findingId: "f-same-1",
+            filePath: "src/auth/login.ts",
+            category: "style",
+            severity: "medium",
+            range: { startLine: 10, endLine: 15 },
+        }),
+        makeFinding({
+            findingId: "f-same-2",
+            filePath: "src/auth/login.ts",
+            category: "type-safety",
+            severity: "medium",
+            range: { startLine: 30, endLine: 35 },
+        }),
+        makeFinding({
+            findingId: "f-same-3",
+            filePath: "src/auth/login.ts",
+            category: "style",
+            severity: "medium",
+            range: { startLine: 12, endLine: 16 },
+        }),
+    ];
+}
+function makeCrossFileSubsystemFindings() {
+    return [
+        makeFinding({
+            findingId: "f-sub-a",
+            filePath: "src/qc/compiler.ts",
+            category: "error-handling",
+            severity: "medium",
+            range: { startLine: 5, endLine: 8 },
+        }),
+        makeFinding({
+            findingId: "f-sub-b",
+            filePath: "src/qc/runner.ts",
+            category: "error-handling",
+            severity: "medium",
+            range: { startLine: 20, endLine: 24 },
+        }),
+        makeFinding({
+            findingId: "f-sub-c",
+            filePath: "src/loop/worker.ts",
+            category: "error-handling",
+            severity: "medium",
+            range: { startLine: 7, endLine: 11 },
+        }),
+    ];
+}
+function makeOverlappingScopeFindings() {
+    return [
+        makeFinding({
+            findingId: "f-overlap-1",
+            filePath: "src/core/state.ts",
+            category: "race-condition",
+            severity: "high",
+            range: { startLine: 40, endLine: 45 },
+        }),
+        makeFinding({
+            findingId: "f-overlap-2",
+            filePath: "src/core/state.ts",
+            category: "race-condition",
+            severity: "high",
+            range: { startLine: 42, endLine: 48 },
+        }),
+    ];
+}
+function makeHighRiskFindings() {
+    return [
+        makeFinding({
+            findingId: "f-security-1",
+            filePath: "src/auth/token.ts",
+            category: "security",
+            severity: "high",
+            range: { startLine: 1, endLine: 5 },
+        }),
+        makeFinding({
+            findingId: "f-security-2",
+            filePath: "src/auth/token.ts",
+            category: "auth",
+            severity: "medium",
+            range: { startLine: 10, endLine: 14 },
+        }),
+        makeFinding({
+            findingId: "f-migration-1",
+            filePath: "src/db/migrate.ts",
+            category: "migration",
+            severity: "medium",
+            range: { startLine: 3, endLine: 7 },
+        }),
+    ];
+}
+function makeLowConfidenceBroadFindings() {
+    return [
+        makeFinding({
+            findingId: "f-broad-1",
+            filePath: undefined,
+            category: "architecture",
+            severity: "medium",
+            attribution: { confidence: "low", reason: "provider-uncertain" },
+        }),
+        makeFinding({
+            findingId: "f-broad-2",
+            filePath: undefined,
+            category: "architecture",
+            severity: "low",
+            attribution: { confidence: "unattributed", reason: "unattributed" },
+        }),
+        makeFinding({
+            findingId: "f-preexisting-1",
+            filePath: "src/legacy/old.ts",
+            category: "tech-debt",
+            severity: "low",
+            attribution: { confidence: "medium", reason: "pre-existing" },
+        }),
+    ];
+}

package/dist/qc/index.js

@@ -28,3 +28,5 @@ __exportStar(require("./registry.js"), exports);
 __exportStar(require("./attribution.js"), exports);
 __exportStar(require("./autofix.js"), exports);
 __exportStar(require("./routing.js"), exports);
+__exportStar(require("./repair-packets.js"), exports);
+__exportStar(require("./repair-loop.js"), exports);

package/dist/qc/orchestration.js

@@ -108,6 +108,8 @@ async function runQcAtTrigger(options) {
                 branch,
                 telemetryFile,
                 timeoutMs,
+                config,
+                registry,
             });
             const result = applyAttributionAndRouting(rawResult, config, attributionContext, ownership, routeName);
             try {

package/dist/qc/policy.js

@@ -9,6 +9,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decideQcAction = decideQcAction;
+exports.decideProviderFailureAction = decideProviderFailureAction;
 exports.computeQcPolicyDecision = computeQcPolicyDecision;
 const severity_js_1 = require("./severity.js");
 /**
@@ -16,6 +17,7 @@ const severity_js_1 = require("./severity.js");
  *
  * Rules:
  *   - passed / skipped  -> pass (no effect on delivery)
+ *   - allProvidersFailed -> block
  *   - repairRouting: "block"  -> block finalize/delivery
  *   - repairRouting: "log"    -> pass (passive report only)
  *   - repairRouting: "route" / "follow-up" -> create follow-up work, but high/critical
@@ -27,6 +29,9 @@ function decideQcAction(result, config) {
     if (result.status === "passed" || result.status === "skipped") {
         return "pass";
     }
+    if (result.allProvidersFailed) {
+        return "block";
+    }
     const routing = config.repairRouting ?? "route";
     if (routing === "block") {
         return "block";
@@ -41,19 +46,41 @@ function decideQcAction(result, config) {
     }
     return "follow-up";
 }
+/**
+ * Decide what the runtime should do with a classified provider failure.
+ *
+ * Maps a failure reason to the per-provider failure policy from configuration.
+ * Reasons without a dedicated policy key default to "fail" so behavior is
+ * deterministic even for newly-classified failures.
+ */
+function decideProviderFailureAction(reason, policy) {
+    switch (reason) {
+        case "timeout":
+            return policy?.timeout ?? "fail";
+        case "parse-failed":
+            return policy?.parseFailure ?? "fail";
+        default:
+            return "fail";
+    }
+}
 /**
  * Compute the detailed policy decision for a QC result after attribution and
  * repair routing have been applied.
  */
 function computeQcPolicyDecision(result, config) {
     const blockThreshold = config.severityThresholds?.block ?? "high";
-    const blocksDelivery = result.findings.some((f) => (0, severity_js_1.compareSeverity)(f.severity, blockThreshold) >= 0 &&
-        (f.routingDecision === "operator-review" || f.routingDecision === undefined));
-    const requiresOperatorReview = result.status === "failed" ||
+    const blocksDelivery = result.allProvidersFailed ||
+        result.findings.some((f) => (0, severity_js_1.compareSeverity)(f.severity, blockThreshold) >= 0 &&
+            (f.routingDecision === "operator-review" || f.routingDecision === undefined));
+    const requiresOperatorReview = result.allProvidersFailed ||
+        result.status === "failed" ||
         result.status === "blocked" ||
         result.findings.some((f) => f.routingDecision === "operator-review");
     const routedToRepair = result.findings.some((f) => f.routingDecision === "original-worker" || f.routingDecision === "repair-worker");
     const summaryParts = [];
+    if (result.allProvidersFailed) {
+        summaryParts.push("all providers failed");
+    }
     summaryParts.push(`${result.findings.length} findings`);
     if (requiresOperatorReview) {
         summaryParts.push("operator review required");

package/dist/qc/providers/coderabbit.js

@@ -53,7 +53,13 @@ function parseFindingsFromPayload(payload) {
     }
     return [];
 }
-function parseReport(output) {
+function parseReport(output, format, parser) {
+    if (parser && parser !== "coderabbit") {
+        throw new Error(`Unsupported parser for CodeRabbit provider: ${parser}`);
+    }
+    if (format === "sarif") {
+        throw new Error("SARIF output format is not supported by the CodeRabbit provider");
+    }
     const text = "stdout" in output && typeof output.stdout === "string" ? output.stdout : "";
     const data = "data" in output ? output.data : undefined;
     if (data !== undefined && typeof data === "object" && data !== null) {
@@ -64,7 +70,10 @@ function parseReport(output) {
             ...(typeof record.prUrl === "string" ? { prUrl: record.prUrl } : {}),
         };
     }
-    if (text.trim().startsWith("{") || text.trim().startsWith("[")) {
+    if (text.trim().length === 0) {
+        return null;
+    }
+    if (format === "json" || text.trim().startsWith("{") || text.trim().startsWith("[")) {
         try {
             const parsed = JSON.parse(text);
             if (Array.isArray(parsed)) {
@@ -77,11 +86,15 @@ function parseReport(output) {
                     : {}),
             };
         }
-        catch {
-            // Fall through to line scanning.
+        catch (jsonError) {
+            // When the format is explicitly JSON, a parse error is a real failure.
+            // Otherwise, treat the text as JSONL and fall through to line scanning.
+            if (format === "json") {
+                throw jsonError;
+            }
         }
     }
-    // Try JSONL: one finding per line
+    // JSONL or generic line scanning: one finding per line
     const lines = text.split("\n").filter((line) => line.trim().length > 0);
     const lineFindings = [];
     for (const line of lines) {
@@ -96,7 +109,7 @@ function parseReport(output) {
     if (lineFindings.length > 0) {
         return { findings: lineFindings };
     }
-    return null;
+    throw new Error("CodeRabbit output could not be parsed as JSON, JSONL, or metrics payload");
 }
 function normalizeFinding(raw, index) {
     const severityLabel = pickString(raw.severity, raw.level) ?? "info";
@@ -179,6 +192,7 @@ function buildResultFromReport(report, output, mode, providerFailed = false) {
  * No external network calls are made here.
  */
 class CodeRabbitQcProvider {
+    config;
     name = "coderabbit";
     supportedModes = ["local", "pr", "metrics-import"];
     capabilities = [
@@ -188,12 +202,29 @@ class CodeRabbitQcProvider {
         "auto-fix",
         "metrics-import",
     ];
+    constructor(config) {
+        this.config = config;
+    }
     canReview(scope) {
         if (scope.prUrl)
             return true;
         return Boolean(scope.branch);
     }
     buildReviewCommand(scope) {
+        const execution = this.config?.execution;
+        if (execution) {
+            const args = execution.args ? [...execution.args] : [];
+            if (execution.configPath) {
+                args.push("--config", execution.configPath);
+            }
+            if (scope.prUrl) {
+                args.push("--pr-url", scope.prUrl);
+            }
+            else {
+                args.push("--branch", scope.branch ?? "HEAD");
+            }
+            return { command: execution.command, args };
+        }
         if (scope.prUrl) {
             return { command: "coderabbit", args: ["review", "--agent", "--pr-url", scope.prUrl] };
         }
@@ -203,7 +234,8 @@ class CodeRabbitQcProvider {
         };
     }
     parse(output) {
-        const report = parseReport(output);
+        const outputConfig = this.config?.execution?.output;
+        const report = parseReport(output, outputConfig?.format, outputConfig?.parser);
         return buildResultFromReport(report, output, "local", output.exitCode !== 0);
     }
     importMetrics(payload) {

package/dist/qc/registry.js

@@ -1,16 +1,49 @@
 "use strict";
 /**
- * Default QC provider registry.
+ * QC provider registry builders.
  *
- * Registers all built-in QC adapters. In the future this can be extended to
- * discover providers from configuration or installed plugins.
+ * `createDefaultQcRegistry` returns the static built-in registry for backward
+ * compatibility. `createQcRegistry` builds a registry from polaris.config.json
+ * qc.providers, wiring provider-agnostic command/output config into the
+ * matching built-in adapters.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDefaultQcRegistry = createDefaultQcRegistry;
+exports.createQcRegistry = createQcRegistry;
 const provider_js_1 = require("./provider.js");
 const coderabbit_js_1 = require("./providers/coderabbit.js");
+function createProvider(name, config) {
+    // Only CodeRabbit is supported as a concrete provider in this child.
+    // Future providers can be registered here by name.
+    if (name === "coderabbit") {
+        return new coderabbit_js_1.CodeRabbitQcProvider(config);
+    }
+    return undefined;
+}
 function createDefaultQcRegistry() {
     const registry = new provider_js_1.QcProviderRegistry();
     registry.register(new coderabbit_js_1.CodeRabbitQcProvider());
     return registry;
 }
+/**
+ * Build a registry from configured QC providers.
+ *
+ * Disabled providers (enabled: false) are skipped. Unknown provider names are
+ * skipped; callers should validate config before dispatch and may report
+ * unknown providers as blockers at runtime.
+ */
+function createQcRegistry(config) {
+    const registry = new provider_js_1.QcProviderRegistry();
+    if (!config?.enabled) {
+        return registry;
+    }
+    for (const [name, providerConfig] of Object.entries(config.providers ?? {})) {
+        if (providerConfig.enabled === false)
+            continue;
+        const provider = createProvider(name, providerConfig);
+        if (provider) {
+            registry.register(provider);
+        }
+    }
+    return registry;
+}