@mcoda/mswarm 0.1.57 → 0.1.60

package/dist/vendor/codali/cognitive/MemoryWriteback.js

@@ -0,0 +1,287 @@
+import path from "node:path";
+import { DEFAULT_LEARNING_GOVERNANCE_POLICY, governLearningRule, mergeLearningRuleIntoLedger, promoteLearningRuleCandidate, readLearningRuleLedger, writeLearningRuleLedger, } from "./LearningGovernance.js";
+const isUnsupportedDocdexMethod = (error) => {
+    if (!error)
+        return false;
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    return normalized.includes("unknown method") || normalized.includes("method not found");
+};
+const resolveLedgerPath = (workspaceRoot, candidateStoreFile) => {
+    if (path.isAbsolute(candidateStoreFile))
+        return candidateStoreFile;
+    return path.resolve(workspaceRoot, candidateStoreFile);
+};
+const mapLearningPolicy = (learning) => ({
+    persistence_min_confidence: learning?.persistence_min_confidence
+        ?? DEFAULT_LEARNING_GOVERNANCE_POLICY.persistence_min_confidence,
+    enforcement_min_confidence: learning?.enforcement_min_confidence
+        ?? DEFAULT_LEARNING_GOVERNANCE_POLICY.enforcement_min_confidence,
+    require_confirmation_for_low_confidence: learning?.require_confirmation_for_low_confidence
+        ?? DEFAULT_LEARNING_GOVERNANCE_POLICY.require_confirmation_for_low_confidence,
+    auto_enforce_high_confidence: learning?.auto_enforce_high_confidence
+        ?? DEFAULT_LEARNING_GOVERNANCE_POLICY.auto_enforce_high_confidence,
+});
+export class MemoryWriteback {
+    constructor(client, options = {}) {
+        this.client = client;
+        this.agentId = options.agentId ?? "default";
+        this.workspaceRoot = path.resolve(options.workspaceRoot ?? process.cwd());
+        const candidateStoreFile = options.learning?.candidate_store_file ?? "logs/codali/learning-rules.json";
+        this.ledgerPath = resolveLedgerPath(this.workspaceRoot, candidateStoreFile);
+        this.policy = mapLearningPolicy(options.learning);
+        this.logger = options.logger;
+    }
+    async logOutcome(outcome) {
+        if (!this.logger)
+            return;
+        await this.logger.log("learning_write_decision", { ...outcome });
+    }
+    toLegacyProposals(input) {
+        const rules = [];
+        if (input.failures >= input.maxRetries && input.lesson.trim()) {
+            const overshoot = Math.max(0, input.failures - input.maxRetries);
+            const confidence = Math.min(0.95, 0.55 + overshoot * 0.05);
+            rules.push({
+                category: "lesson",
+                content: input.lesson.trim(),
+                source: "smart_pipeline_failure_threshold",
+                scope: "repo_memory",
+                confidence_score: confidence,
+                evidence: [{ kind: "run", ref: `failures=${input.failures};maxRetries=${input.maxRetries}` }],
+            });
+        }
+        for (const preference of input.preferences ?? []) {
+            rules.push({
+                category: preference.category,
+                content: preference.content,
+                source: preference.source ?? "request_directive",
+                scope: preference.scope,
+                agent_id: preference.agentId,
+                confidence_score: preference.confidence_score,
+                confidence_band: preference.confidence_band,
+                confidence_reasons: preference.confidence_reasons,
+                evidence: preference.evidence,
+                explicit_confirmation: preference.explicit_confirmation,
+            });
+        }
+        return rules;
+    }
+    async persistRuleToDocdex(rule) {
+        const metadata = {
+            schema_version: 1,
+            rule_id: rule.id,
+            dedupe_key: rule.dedupe_key,
+            lifecycle_state: rule.lifecycle_state,
+            confidence_score: rule.confidence_score,
+            confidence_band: rule.confidence_band,
+            confidence_reasons: rule.confidence_reasons,
+            source: rule.source,
+            evidence: rule.evidence,
+            supersedes: rule.supersedes,
+        };
+        if (rule.scope === "repo_memory") {
+            try {
+                await this.client.memorySave(rule.content, metadata);
+            }
+            catch (error) {
+                if (!isUnsupportedDocdexMethod(error))
+                    throw error;
+                await this.client.memorySave(rule.content);
+            }
+            return;
+        }
+        const agentId = rule.agent_id ?? this.agentId;
+        try {
+            await this.client.savePreference(agentId, rule.category, rule.content, metadata);
+        }
+        catch (error) {
+            if (!isUnsupportedDocdexMethod(error))
+                throw error;
+            try {
+                await this.client.savePreference(agentId, rule.category, rule.content);
+            }
+            catch (fallbackError) {
+                if (!isUnsupportedDocdexMethod(fallbackError))
+                    throw fallbackError;
+                await this.client.memorySave(`[profile:${rule.category}] ${rule.content}`);
+            }
+        }
+    }
+    async persist(input) {
+        const outcomes = [];
+        const proposals = [...(input.rules ?? []), ...this.toLegacyProposals(input)];
+        const promotions = input.promotions ?? [];
+        let ledgerChanged = false;
+        const ledger = await readLearningRuleLedger(this.ledgerPath);
+        for (const proposal of proposals) {
+            try {
+                const decision = governLearningRule(proposal, this.policy);
+                const baseOutcome = {
+                    status: decision.status,
+                    code: decision.code,
+                    message: decision.message,
+                    rule_id: decision.rule.id,
+                    dedupe_key: decision.rule.dedupe_key,
+                    scope: decision.rule.scope,
+                    lifecycle_state: decision.rule.lifecycle_state,
+                    confidence_score: decision.rule.confidence_score,
+                    confidence_band: decision.rule.confidence_band,
+                    target: decision.rule.scope,
+                };
+                if (decision.status !== "accepted") {
+                    outcomes.push(baseOutcome);
+                    await this.logOutcome(baseOutcome);
+                    continue;
+                }
+                const mergeResult = mergeLearningRuleIntoLedger(ledger, decision.rule);
+                if (mergeResult.action === "suppressed") {
+                    const suppressed = {
+                        ...baseOutcome,
+                        status: "suppressed",
+                        code: "dedupe_suppressed",
+                        message: "Duplicate or weaker learning rule was suppressed.",
+                        rule_id: mergeResult.rule.id,
+                        lifecycle_state: mergeResult.rule.lifecycle_state,
+                        confidence_score: mergeResult.rule.confidence_score,
+                        confidence_band: mergeResult.rule.confidence_band,
+                    };
+                    outcomes.push(suppressed);
+                    await this.logOutcome(suppressed);
+                    continue;
+                }
+                ledgerChanged = true;
+                try {
+                    await this.persistRuleToDocdex(mergeResult.rule);
+                    const accepted = {
+                        ...baseOutcome,
+                        status: "accepted",
+                        code: mergeResult.action === "superseded"
+                            ? "accepted_superseded_previous"
+                            : baseOutcome.code,
+                        message: mergeResult.action === "superseded"
+                            ? "Rule accepted and superseded previous rule."
+                            : baseOutcome.message,
+                        rule_id: mergeResult.rule.id,
+                        lifecycle_state: mergeResult.rule.lifecycle_state,
+                        confidence_score: mergeResult.rule.confidence_score,
+                        confidence_band: mergeResult.rule.confidence_band,
+                    };
+                    outcomes.push(accepted);
+                    await this.logOutcome(accepted);
+                }
+                catch (error) {
+                    const rejected = {
+                        ...baseOutcome,
+                        status: "rejected",
+                        code: "docdex_write_failed",
+                        message: error instanceof Error ? error.message : String(error),
+                        rule_id: mergeResult.rule.id,
+                    };
+                    outcomes.push(rejected);
+                    await this.logOutcome(rejected);
+                }
+            }
+            catch (error) {
+                const rejected = {
+                    status: "rejected",
+                    code: "governance_error",
+                    message: error instanceof Error ? error.message : String(error),
+                };
+                outcomes.push(rejected);
+                await this.logOutcome(rejected);
+            }
+        }
+        for (const promotion of promotions) {
+            try {
+                const result = promoteLearningRuleCandidate(ledger, promotion.dedupe_key, this.policy);
+                if (result.action === "not_found") {
+                    const outcome = {
+                        status: "rejected",
+                        code: "candidate_not_found",
+                        message: `No candidate rule found for ${promotion.dedupe_key}.`,
+                        dedupe_key: promotion.dedupe_key,
+                    };
+                    outcomes.push(outcome);
+                    await this.logOutcome(outcome);
+                    continue;
+                }
+                if (result.action === "already_enforced") {
+                    const outcome = {
+                        status: "suppressed",
+                        code: "candidate_already_enforced",
+                        message: "Candidate is already enforced.",
+                        dedupe_key: promotion.dedupe_key,
+                        rule_id: result.previous?.id,
+                        lifecycle_state: result.previous?.lifecycle_state,
+                        scope: result.previous?.scope,
+                        target: result.previous?.scope,
+                    };
+                    outcomes.push(outcome);
+                    await this.logOutcome(outcome);
+                    continue;
+                }
+                ledgerChanged = true;
+                if (!result.promoted) {
+                    const outcome = {
+                        status: "rejected",
+                        code: "promotion_failed",
+                        message: "Candidate promotion failed.",
+                        dedupe_key: promotion.dedupe_key,
+                    };
+                    outcomes.push(outcome);
+                    await this.logOutcome(outcome);
+                    continue;
+                }
+                try {
+                    await this.persistRuleToDocdex({
+                        ...result.promoted,
+                        agent_id: promotion.agentId ?? result.promoted.agent_id,
+                    });
+                    const outcome = {
+                        status: "promoted",
+                        code: "candidate_promoted",
+                        message: "Candidate promoted to enforced.",
+                        dedupe_key: result.promoted.dedupe_key,
+                        rule_id: result.promoted.id,
+                        scope: result.promoted.scope,
+                        lifecycle_state: result.promoted.lifecycle_state,
+                        confidence_score: result.promoted.confidence_score,
+                        confidence_band: result.promoted.confidence_band,
+                        target: result.promoted.scope,
+                    };
+                    outcomes.push(outcome);
+                    await this.logOutcome(outcome);
+                }
+                catch (error) {
+                    const outcome = {
+                        status: "rejected",
+                        code: "promotion_write_failed",
+                        message: error instanceof Error ? error.message : String(error),
+                        dedupe_key: result.promoted.dedupe_key,
+                        rule_id: result.promoted.id,
+                    };
+                    outcomes.push(outcome);
+                    await this.logOutcome(outcome);
+                }
+            }
+            catch (error) {
+                const outcome = {
+                    status: "rejected",
+                    code: "promotion_error",
+                    message: error instanceof Error ? error.message : String(error),
+                    dedupe_key: promotion.dedupe_key,
+                };
+                outcomes.push(outcome);
+                await this.logOutcome(outcome);
+            }
+        }
+        if (ledgerChanged) {
+            await writeLearningRuleLedger(this.ledgerPath, ledger);
+        }
+        return {
+            outcomes,
+            ledgerPath: this.ledgerPath,
+        };
+    }
+}

package/dist/vendor/codali/cognitive/PatchApplier.d.ts

@@ -0,0 +1,49 @@
+import type { PatchAction } from "./BuilderOutputParser.js";
+export interface PatchApplyResult {
+    touched: string[];
+}
+export type PatchPolicyReasonCode = "patch_outside_workspace" | "patch_outside_allowed_scope" | "patch_read_only_path" | "destructive_operation_blocked" | "writes_disabled_by_profile";
+export interface PatchPolicyErrorMetadata {
+    reason_code: PatchPolicyReasonCode;
+    file: string;
+    normalized_file: string;
+    action: PatchAction["action"];
+    allowed_paths?: string[];
+    read_only_paths?: string[];
+    policy?: string;
+}
+export declare class PatchPolicyError extends Error {
+    readonly metadata: PatchPolicyErrorMetadata;
+    constructor(message: string, metadata: PatchPolicyErrorMetadata);
+}
+export interface PatchApplyPolicy {
+    allowWritePaths?: string[];
+    readOnlyPaths?: string[];
+    allowDestructiveOperations?: boolean;
+    allowWrites?: boolean;
+}
+export interface PatchApplierOptions {
+    workspaceRoot: string;
+    validateFile?: (filePath: string) => Promise<void> | void;
+    policy?: PatchApplyPolicy;
+}
+export interface PatchRollbackEntry {
+    file: string;
+    normalizedFile: string;
+    resolved: string;
+    existed: boolean;
+    content?: string;
+}
+export interface PatchRollbackPlan {
+    entries: PatchRollbackEntry[];
+}
+export declare class PatchApplier {
+    private options;
+    constructor(options: PatchApplierOptions);
+    private resolvePolicy;
+    private resolvePatchTarget;
+    createRollback(patches: PatchAction[], policyOverride?: PatchApplyPolicy): Promise<PatchRollbackPlan>;
+    rollback(plan: PatchRollbackPlan): Promise<void>;
+    apply(patches: PatchAction[], policyOverride?: PatchApplyPolicy): Promise<PatchApplyResult>;
+}
+//# sourceMappingURL=PatchApplier.d.ts.map

package/dist/vendor/codali/cognitive/PatchApplier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PatchApplier.d.ts","sourceRoot":"","sources":["../../src/cognitive/PatchApplier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,MAAM,qBAAqB,GAC7B,yBAAyB,GACzB,6BAA6B,GAC7B,sBAAsB,GACtB,+BAA+B,GAC/B,4BAA4B,CAAC;AAEjC,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,qBAAqB,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;gBAEhC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,wBAAwB;CAKhE;AAED,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1D,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,kBAAkB,EAAE,CAAC;CAC/B;AAqED,qBAAa,YAAY;IACX,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,mBAAmB;IAEhD,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,kBAAkB;IAuDpB,cAAc,CAClB,OAAO,EAAE,WAAW,EAAE,EACtB,cAAc,CAAC,EAAE,gBAAgB,GAChC,OAAO,CAAC,iBAAiB,CAAC;IA6BvB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAWhD,KAAK,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,cAAc,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAwBlG"}

package/dist/vendor/codali/cognitive/PatchApplier.js

@@ -0,0 +1,199 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export class PatchPolicyError extends Error {
+    constructor(message, metadata) {
+        super(message);
+        this.name = "PatchPolicyError";
+        this.metadata = metadata;
+    }
+}
+const normalizePath = (value) => value.replace(/\\/g, "/").replace(/^\.?\//, "").replace(/\/+/g, "/");
+const dedupePaths = (values) => Array.from(new Set(values.map(normalizePath)));
+const pathMatches = (candidates, target) => candidates.some((entry) => target === entry || target.startsWith(`${entry}/`));
+const resolvePath = (workspaceRoot, targetPath) => {
+    const normalizedTarget = normalizePath(targetPath);
+    const resolved = path.resolve(workspaceRoot, normalizedTarget);
+    const relative = normalizePath(path.relative(workspaceRoot, resolved));
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Path is outside workspace root");
+    }
+    return { resolved, normalized: normalizedTarget };
+};
+const buildWhitespaceCollapsed = (input) => {
+    let compact = "";
+    const map = [];
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        if (/\s/.test(char)) {
+            continue;
+        }
+        compact += char;
+        map.push(index);
+    }
+    return { compact, map };
+};
+const replaceOnce = (content, search, replace) => {
+    const occurrences = content.split(search).length - 1;
+    if (occurrences === 1) {
+        return content.replace(search, replace);
+    }
+    if (occurrences > 1) {
+        throw new Error("Ambiguous search block. Provide more context.");
+    }
+    const compactSearch = search.replace(/\s+/g, "");
+    if (!compactSearch) {
+        throw new Error("Search block not found in file.");
+    }
+    const collapsed = buildWhitespaceCollapsed(content);
+    const firstIndex = collapsed.compact.indexOf(compactSearch);
+    if (firstIndex < 0) {
+        throw new Error("Search block not found in file.");
+    }
+    if (collapsed.compact.indexOf(compactSearch, firstIndex + 1) >= 0) {
+        throw new Error("Ambiguous search block. Provide more context.");
+    }
+    const start = collapsed.map[firstIndex];
+    const end = collapsed.map[firstIndex + compactSearch.length - 1] + 1;
+    return `${content.slice(0, start)}${replace}${content.slice(end)}`;
+};
+const toMessage = (error) => (error instanceof Error ? error.message : String(error));
+const isNotFoundError = (error) => {
+    const message = toMessage(error);
+    return message.includes("no such file") || message.includes("ENOENT");
+};
+export class PatchApplier {
+    constructor(options) {
+        this.options = options;
+    }
+    resolvePolicy(override) {
+        const merged = {
+            ...(this.options.policy ?? {}),
+            ...(override ?? {}),
+        };
+        return {
+            allowWritePaths: dedupePaths((merged.allowWritePaths ?? []).filter(Boolean)),
+            readOnlyPaths: dedupePaths((merged.readOnlyPaths ?? []).filter(Boolean)),
+            allowDestructiveOperations: merged.allowDestructiveOperations === true,
+            allowWrites: merged.allowWrites !== false,
+        };
+    }
+    resolvePatchTarget(patch, policyOverride) {
+        const policy = this.resolvePolicy(policyOverride);
+        let target;
+        try {
+            target = resolvePath(this.options.workspaceRoot, patch.file);
+        }
+        catch (error) {
+            throw new PatchPolicyError("Path is outside workspace root", {
+                reason_code: "patch_outside_workspace",
+                file: patch.file,
+                normalized_file: normalizePath(patch.file),
+                action: patch.action,
+            });
+        }
+        if (!policy.allowWrites) {
+            throw new PatchPolicyError("Write actions are disabled for the active workflow profile", {
+                reason_code: "writes_disabled_by_profile",
+                file: patch.file,
+                normalized_file: target.normalized,
+                action: patch.action,
+                policy: "allowWrites",
+            });
+        }
+        if (pathMatches(policy.readOnlyPaths, target.normalized)) {
+            throw new PatchPolicyError(`Patch target is read-only: ${patch.file}`, {
+                reason_code: "patch_read_only_path",
+                file: patch.file,
+                normalized_file: target.normalized,
+                action: patch.action,
+                read_only_paths: policy.readOnlyPaths,
+            });
+        }
+        if (policy.allowWritePaths.length > 0 && !pathMatches(policy.allowWritePaths, target.normalized)) {
+            throw new PatchPolicyError(`Patch target is outside allowed scope: ${patch.file}`, {
+                reason_code: "patch_outside_allowed_scope",
+                file: patch.file,
+                normalized_file: target.normalized,
+                action: patch.action,
+                allowed_paths: policy.allowWritePaths,
+            });
+        }
+        if (patch.action === "delete" && !policy.allowDestructiveOperations) {
+            throw new PatchPolicyError("Delete action blocked by destructive-operation policy", {
+                reason_code: "destructive_operation_blocked",
+                file: patch.file,
+                normalized_file: target.normalized,
+                action: patch.action,
+                policy: "allowDestructiveOperations",
+            });
+        }
+        return { resolved: target.resolved, normalized: target.normalized, policy };
+    }
+    async createRollback(patches, policyOverride) {
+        const entries = [];
+        for (const patch of patches) {
+            const target = this.resolvePatchTarget(patch, policyOverride);
+            try {
+                const content = await fs.readFile(target.resolved, "utf8");
+                entries.push({
+                    file: patch.file,
+                    normalizedFile: target.normalized,
+                    resolved: target.resolved,
+                    existed: true,
+                    content,
+                });
+            }
+            catch (error) {
+                if (isNotFoundError(error)) {
+                    entries.push({
+                        file: patch.file,
+                        normalizedFile: target.normalized,
+                        resolved: target.resolved,
+                        existed: false,
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return { entries };
+    }
+    async rollback(plan) {
+        for (const entry of plan.entries) {
+            if (entry.existed) {
+                await fs.mkdir(path.dirname(entry.resolved), { recursive: true });
+                await fs.writeFile(entry.resolved, entry.content ?? "", "utf8");
+            }
+            else {
+                await fs.rm(entry.resolved, { force: true });
+            }
+        }
+    }
+    async apply(patches, policyOverride) {
+        const touched = [];
+        for (const patch of patches) {
+            const target = this.resolvePatchTarget(patch, policyOverride);
+            if (patch.action === "create") {
+                await fs.mkdir(path.dirname(target.resolved), { recursive: true });
+                await fs.writeFile(target.resolved, patch.content, "utf8");
+                touched.push(patch.file);
+                if (this.options.validateFile)
+                    await this.options.validateFile(target.resolved);
+                continue;
+            }
+            if (patch.action === "delete") {
+                await fs.rm(target.resolved, { force: true });
+                touched.push(patch.file);
+                continue;
+            }
+            const content = await fs.readFile(target.resolved, "utf8");
+            const updated = replaceOnce(content, patch.search_block, patch.replace_block);
+            await fs.writeFile(target.resolved, updated, "utf8");
+            touched.push(patch.file);
+            if (this.options.validateFile)
+                await this.options.validateFile(target.resolved);
+        }
+        return { touched };
+    }
+}

package/dist/vendor/codali/cognitive/PatchInterpreter.d.ts

@@ -0,0 +1,35 @@
+import type { Provider, ProviderResponseFormat } from "../providers/ProviderTypes.js";
+import { type PatchFormat, type PatchPayload } from "./BuilderOutputParser.js";
+export interface PatchInterpreterLogger {
+    log(type: string, data: Record<string, unknown>): Promise<void>;
+}
+export interface PatchInterpreterOptions {
+    provider: Provider;
+    patchFormat: PatchFormat;
+    responseFormat?: ProviderResponseFormat;
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+    maxRetries?: number;
+    logger?: PatchInterpreterLogger;
+    model?: string;
+}
+export interface PatchInterpreterClient {
+    interpret(raw: string, patchFormatOverride?: PatchFormat): Promise<PatchPayload>;
+}
+export declare class PatchInterpreter implements PatchInterpreterClient {
+    private provider;
+    private patchFormat;
+    private responseFormat?;
+    private temperature?;
+    private maxTokens?;
+    private timeoutMs?;
+    private maxRetries;
+    private logger?;
+    private model?;
+    constructor(options: PatchInterpreterOptions);
+    private requestPatch;
+    private parse;
+    interpret(raw: string, patchFormatOverride?: PatchFormat): Promise<PatchPayload>;
+}
+//# sourceMappingURL=PatchInterpreter.d.ts.map

package/dist/vendor/codali/cognitive/PatchInterpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PatchInterpreter.d.ts","sourceRoot":"","sources":["../../src/cognitive/PatchInterpreter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAER,sBAAsB,EACvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAoB,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAIjG,MAAM,WAAW,sBAAsB;IACrC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjE;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,WAAW,CAAC;IACzB,cAAc,CAAC,EAAE,sBAAsB,CAAC;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,sBAAsB,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,mBAAmB,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CAClF;AAED,qBAAa,gBAAiB,YAAW,sBAAsB;IAC7D,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,cAAc,CAAC,CAAyB;IAChD,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAC,CAAyB;IACxC,OAAO,CAAC,KAAK,CAAC,CAAS;gBAEX,OAAO,EAAE,uBAAuB;YAY9B,YAAY;IA0C1B,OAAO,CAAC,KAAK;IAQP,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,mBAAmB,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;CAsCvF"}

package/dist/vendor/codali/cognitive/PatchInterpreter.js

@@ -0,0 +1,100 @@
+import { parsePatchOutput } from "./BuilderOutputParser.js";
+import { normalizePatchOutput } from "./PatchOutputNormalizer.js";
+import { buildInterpreterPrompt, buildInterpreterRetryPrompt } from "./Prompts.js";
+export class PatchInterpreter {
+    constructor(options) {
+        this.provider = options.provider;
+        this.patchFormat = options.patchFormat;
+        this.responseFormat = options.responseFormat;
+        this.temperature = options.temperature;
+        this.maxTokens = options.maxTokens;
+        this.timeoutMs = options.timeoutMs;
+        this.maxRetries = options.maxRetries ?? 1;
+        this.logger = options.logger;
+        this.model = options.model;
+    }
+    async requestPatch(prompt, raw, meta) {
+        const messages = [
+            { role: "system", content: prompt },
+            { role: "user", content: raw },
+        ];
+        if (this.logger) {
+            await this.logger.log("provider_request", {
+                provider: this.provider.name,
+                model: this.model,
+                messages,
+                temperature: this.temperature,
+                maxTokens: this.maxTokens,
+                responseFormat: this.responseFormat ?? { type: "json" },
+                stream: false,
+            });
+            await this.logger.log("interpreter_request", {
+                retry: meta.retry,
+                patchFormat: meta.patchFormat,
+                model: this.model,
+            });
+        }
+        const response = await this.provider.generate({
+            messages,
+            maxTokens: this.maxTokens,
+            temperature: this.temperature,
+            responseFormat: this.responseFormat ?? { type: "json" },
+            stream: false,
+        });
+        if (this.logger) {
+            await this.logger.log("interpreter_response", {
+                retry: meta.retry,
+                length: response.message?.content?.length ?? 0,
+                patchFormat: meta.patchFormat,
+            });
+        }
+        return response.message?.content ?? "";
+    }
+    parse(content, patchFormat) {
+        const normalized = normalizePatchOutput(content);
+        if (!normalized) {
+            throw new Error("Patch output is not valid JSON");
+        }
+        return parsePatchOutput(normalized, patchFormat);
+    }
+    async interpret(raw, patchFormatOverride) {
+        const patchFormat = patchFormatOverride ?? this.patchFormat;
+        // Fast-path: in patch_json mode the builder may already emit a usable payload.
+        try {
+            const parsed = this.parse(raw, patchFormat);
+            if (this.logger) {
+                await this.logger.log("interpreter_direct_parse", {
+                    patchFormat,
+                    length: raw.length,
+                });
+            }
+            return parsed;
+        }
+        catch {
+            // Fall back to provider-assisted interpretation below.
+        }
+        const prompt = buildInterpreterPrompt(patchFormat);
+        const content = await this.requestPatch(prompt, raw, {
+            retry: false,
+            patchFormat,
+        });
+        try {
+            return this.parse(content, patchFormat);
+        }
+        catch (error) {
+            if (this.maxRetries <= 0) {
+                throw error;
+            }
+            if (this.logger) {
+                const message = error instanceof Error ? error.message : String(error);
+                await this.logger.log("interpreter_retry", { error: message });
+            }
+            const retryPrompt = buildInterpreterRetryPrompt(patchFormat);
+            const retryContent = await this.requestPatch(retryPrompt, raw, {
+                retry: true,
+                patchFormat,
+            });
+            return this.parse(retryContent, patchFormat);
+        }
+    }
+}