@mcoda/mswarm 0.1.57 → 0.1.60

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

@@ -0,0 +1,7 @@
+export declare const normalizePatchOutput: (raw: string) => string | undefined;
+export declare const __test__: {
+    stripCodeFences: (input: string) => string;
+    stripJsonPrefix: (input: string) => string;
+    findJsonSubstring: (input: string) => string | undefined;
+};
+//# sourceMappingURL=PatchOutputNormalizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PatchOutputNormalizer.d.ts","sourceRoot":"","sources":["../../src/cognitive/PatchOutputNormalizer.ts"],"names":[],"mappings":"AAqCA,eAAO,MAAM,oBAAoB,GAAI,KAAK,MAAM,KAAG,MAAM,GAAG,SAe3D,CAAC;AAEF,eAAO,MAAM,QAAQ;6BAtDW,MAAM,KAAG,MAAM;6BAQf,MAAM,KAAG,MAAM;+BAIb,MAAM,KAAG,MAAM,GAAG,SAAS;CA8C5D,CAAC"}

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

@@ -0,0 +1,59 @@
+const stripCodeFences = (input) => {
+    const match = input.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (match?.[1]) {
+        return match[1].trim();
+    }
+    return input.trim();
+};
+const stripJsonPrefix = (input) => {
+    return input.replace(/^json\s*:/i, "").trim();
+};
+const findJsonSubstring = (input) => {
+    const startBrace = input.indexOf("{");
+    const startBracket = input.indexOf("[");
+    const start = startBrace === -1
+        ? startBracket
+        : startBracket === -1
+            ? startBrace
+            : Math.min(startBrace, startBracket);
+    if (start === -1)
+        return undefined;
+    for (let end = input.length - 1; end > start; end -= 1) {
+        const char = input[end];
+        if (char !== "}" && char !== "]")
+            continue;
+        const candidate = input.slice(start, end + 1).trim();
+        try {
+            JSON.parse(candidate);
+            return candidate;
+        }
+        catch {
+            // keep searching shorter candidates
+        }
+    }
+    return undefined;
+};
+export const normalizePatchOutput = (raw) => {
+    if (!raw)
+        return undefined;
+    const fenced = stripCodeFences(raw);
+    const stripped = stripJsonPrefix(fenced);
+    const direct = stripped.trim();
+    if (!direct)
+        return undefined;
+    if (direct.startsWith("{") || direct.startsWith("[")) {
+        try {
+            JSON.parse(direct);
+            return direct;
+        }
+        catch {
+            return findJsonSubstring(direct);
+        }
+    }
+    return findJsonSubstring(direct);
+};
+export const __test__ = {
+    stripCodeFences,
+    stripJsonPrefix,
+    findJsonSubstring,
+};

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

@@ -0,0 +1,17 @@
+import type { Provider } from "../providers/ProviderTypes.js";
+import { type LearningEvidenceReference, type LearningRuleProposal } from "./LearningGovernance.js";
+export interface PostMortemAnalysisResult {
+    runId: string;
+    status: "rule_extracted" | "no_change";
+    message: string;
+    rule?: string;
+    rules: LearningRuleProposal[];
+    evidence: LearningEvidenceReference[];
+}
+export declare class PostMortemAnalyzer {
+    private provider;
+    private workspaceRoot;
+    constructor(provider: Provider, workspaceRoot: string);
+    analyze(filePath: string): Promise<PostMortemAnalysisResult>;
+}
+//# sourceMappingURL=PostMortemAnalyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PostMortemAnalyzer.d.ts","sourceRoot":"","sources":["../../src/cognitive/PostMortemAnalyzer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EAC1B,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,GAAG,WAAW,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,QAAQ,EAAE,yBAAyB,EAAE,CAAC;CACvC;AA+BD,qBAAa,kBAAkB;IAE3B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,aAAa;gBADb,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM;IAGzB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC;CA8GnE"}

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

@@ -0,0 +1,131 @@
+import { readFile } from "node:fs/promises";
+import { RunLogReader } from "../runtime/RunLogReader.js";
+import { scoreLearningConfidence, } from "./LearningGovernance.js";
+const normalizeRuleText = (value) => value.trim().replace(/^["'`]+|["'`]+$/g, "").trim();
+const inferRuleCategory = (rule) => {
+    const normalized = rule.trim().toLowerCase();
+    if (normalized.startsWith("prefer")
+        || normalized.startsWith("use ")
+        || normalized.startsWith("always use")) {
+        return "preference";
+    }
+    if (normalized.startsWith("avoid")
+        || normalized.startsWith("do not ")
+        || normalized.startsWith("don't ")
+        || normalized.startsWith("never ")
+        || normalized.includes("do not ")
+        || normalized.includes("don't ")
+        || normalized.includes("avoid ")) {
+        return "constraint";
+    }
+    return "constraint";
+};
+const inferExplicitDirective = (rule) => /^(prefer|avoid|do not|don't|never|must|always)\b/i.test(rule.trim());
+export class PostMortemAnalyzer {
+    constructor(provider, workspaceRoot) {
+        this.provider = provider;
+        this.workspaceRoot = workspaceRoot;
+    }
+    async analyze(filePath) {
+        const reader = new RunLogReader(this.workspaceRoot);
+        const runId = await reader.findLastRunForFile(filePath);
+        if (!runId) {
+            throw new Error(`No recent Codali run found for ${filePath}`);
+        }
+        const patchContent = await reader.getRunArtifact(runId, "builder-patch");
+        if (!patchContent) {
+            throw new Error(`Could not find builder patch for run ${runId}`);
+        }
+        let currentContent = "";
+        try {
+            currentContent = await readFile(filePath, "utf8");
+        }
+        catch {
+            throw new Error(`Could not read current file ${filePath}`);
+        }
+        const intent = await reader.getRunIntent(runId);
+        const evidence = [
+            { kind: "run", ref: runId, note: "post_mortem_comparison" },
+            { kind: "file", ref: filePath },
+            { kind: "artifact", ref: `phase/builder-patch:${runId}` },
+        ];
+        if (intent?.trim()) {
+            evidence.push({ kind: "request", ref: intent.trim() });
+        }
+        const prompt = `
+ROLE: Post-Mortem Analyst
+TASK: Compare the "CODALI PATCH" (what the agent attempted) against "CURRENT FILE" (user-adjusted result).
+GOAL: Extract one concise, durable coding rule that prevents this mismatch in future runs.
+
+RUN ID:
+${runId}
+
+CODALI PATCH ARTIFACT:
+${patchContent}
+
+CURRENT FILE CONTENT:
+${currentContent}
+
+INSTRUCTIONS:
+1. Determine whether the user materially changed/reverted the proposed patch.
+2. If yes, return one concise rule string.
+3. If no meaningful difference exists, return exactly: NO_CHANGE
+
+OUTPUT FORMAT:
+Return ONLY a single line rule string or NO_CHANGE.
+`;
+        const response = await this.provider.generate({
+            messages: [{ role: "user", content: prompt }],
+            temperature: 0.1,
+        });
+        const rawRule = response.message.content?.trim() ?? "";
+        if (!rawRule || rawRule.toUpperCase() === "NO_CHANGE") {
+            return {
+                runId,
+                status: "no_change",
+                message: "No meaningful user deviation detected; no rule persisted.",
+                rules: [],
+                evidence,
+            };
+        }
+        const rule = normalizeRuleText(rawRule);
+        if (!rule) {
+            return {
+                runId,
+                status: "no_change",
+                message: "Analyzer did not produce a valid rule.",
+                rules: [],
+                evidence,
+            };
+        }
+        const category = inferRuleCategory(rule);
+        const explicit = inferExplicitDirective(rule);
+        const confidence = scoreLearningConfidence({
+            source: "post_mortem_inferred_rule",
+            content: rule,
+            explicit,
+            evidence_count: evidence.length,
+            has_revert_signal: true,
+        });
+        return {
+            runId,
+            status: "rule_extracted",
+            message: "Extracted post-mortem learning rule.",
+            rule,
+            evidence,
+            rules: [
+                {
+                    category,
+                    content: rule,
+                    source: "post_mortem_inferred_rule",
+                    scope: "profile_memory",
+                    confidence_score: confidence.score,
+                    confidence_band: confidence.band,
+                    confidence_reasons: confidence.reasons,
+                    evidence,
+                    explicit_confirmation: false,
+                },
+            ],
+        };
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { ContextPreferenceDetected } from "./Types.js";
+export declare const extractPreferences: (request: string) => ContextPreferenceDetected[];
+//# sourceMappingURL=PreferenceExtraction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PreferenceExtraction.d.ts","sourceRoot":"","sources":["../../src/cognitive/PreferenceExtraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AA6F5D,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,KAAG,yBAAyB,EAK7E,CAAC"}

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

@@ -0,0 +1,85 @@
+import { scoreLearningConfidence } from "./LearningGovernance.js";
+const uniquePreferences = (entries) => {
+    const seen = new Set();
+    const result = [];
+    for (const entry of entries) {
+        const key = `${entry.category}:${entry.content}`.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(entry);
+    }
+    return result;
+};
+const toDetectedPreference = (candidate) => {
+    const confidence = scoreLearningConfidence({
+        source: candidate.source,
+        content: candidate.content,
+        explicit: candidate.explicit,
+        evidence_count: 1,
+        has_revert_signal: false,
+    });
+    return {
+        category: candidate.category,
+        content: candidate.content,
+        source: candidate.source,
+        scope: "profile_memory",
+        confidence_score: confidence.score,
+        confidence_band: confidence.band,
+        confidence_reasons: confidence.reasons,
+    };
+};
+const extractFromLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return [];
+    const matches = [];
+    const preferMatch = trimmed.match(/^(?:preference|prefer)\s*:?\s*(.+)$/i);
+    if (preferMatch?.[1]) {
+        matches.push({
+            category: "preference",
+            content: preferMatch[1].trim(),
+            source: "request_directive_explicit_preference",
+            explicit: true,
+        });
+    }
+    const mustUseMatch = trimmed.match(/^(?:always use|must use)\s*:?\s*(.+)$/i);
+    if (mustUseMatch?.[1]) {
+        matches.push({
+            category: "constraint",
+            content: mustUseMatch[1].trim(),
+            source: "request_directive_explicit_constraint",
+            explicit: true,
+        });
+    }
+    const avoidMatch = trimmed.match(/^(?:avoid|do not use|don't use|never use)\s*:?\s*(.+)$/i);
+    if (avoidMatch?.[1]) {
+        matches.push({
+            category: "constraint",
+            content: avoidMatch[1].trim(),
+            source: "request_directive_explicit_constraint",
+            explicit: true,
+        });
+    }
+    if (!avoidMatch) {
+        const inlineAvoid = trimmed.match(/(?:do not use|don't use|avoid)\s+([^.;]+)/i);
+        if (inlineAvoid?.[1]) {
+            matches.push({
+                category: "constraint",
+                content: inlineAvoid[1].trim(),
+                source: "request_directive_inline_constraint",
+                explicit: false,
+            });
+        }
+    }
+    return matches
+        .filter((entry) => entry.content.length > 0)
+        .map((entry) => toDetectedPreference(entry));
+};
+export const extractPreferences = (request) => {
+    if (!request.trim())
+        return [];
+    const lines = request.split(/\r?\n/);
+    const entries = lines.flatMap(extractFromLine).filter((entry) => entry.content.length > 0);
+    return uniquePreferences(entries);
+};

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

@@ -0,0 +1,15 @@
+export declare const ARCHITECT_PROMPT: string;
+export declare const ARCHITECT_GBNF: string;
+export declare const ARCHITECT_REVIEW_PROMPT: string;
+export declare const ARCHITECT_REVIEW_GBNF: string;
+export declare const ARCHITECT_VALIDATE_PROMPT: string;
+export declare const ARCHITECT_VALIDATE_GBNF: string;
+export declare const BUILDER_PATCH_GBNF_SEARCH_REPLACE: string;
+export declare const BUILDER_PATCH_GBNF_FILE_WRITES: string;
+export declare const buildBuilderPrompt: (mode: "tool_calls" | "patch_json" | "freeform", patchFormat?: "search_replace" | "file_writes") => string;
+export declare const buildInterpreterPrompt: (patchFormat?: "search_replace" | "file_writes") => string;
+export declare const buildInterpreterRetryPrompt: (patchFormat?: "search_replace" | "file_writes") => string;
+export declare const BUILDER_PROMPT: string;
+export declare const CRITIC_PROMPT: string;
+export declare const CONTEXT_SUMMARY_PROMPT: string;
+//# sourceMappingURL=Prompts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Prompts.d.ts","sourceRoot":"","sources":["../../src/cognitive/Prompts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,QAiEjB,CAAC;AAEb,eAAO,MAAM,cAAc,QAWf,CAAC;AAEb,eAAO,MAAM,uBAAuB,QAgBxB,CAAC;AAEb,eAAO,MAAM,qBAAqB,QAQtB,CAAC;AAEb,eAAO,MAAM,yBAAyB,QA4B1B,CAAC;AAEb,eAAO,MAAM,uBAAuB,QAAiB,CAAC;AAEtD,eAAO,MAAM,iCAAiC,QAalC,CAAC;AAEb,eAAO,MAAM,8BAA8B,QAW/B,CAAC;AA6Fb,eAAO,MAAM,kBAAkB,GAC7B,MAAM,YAAY,GAAG,YAAY,GAAG,UAAU,EAC9C,cAAa,gBAAgB,GAAG,aAAgC,KAC/D,MAUF,CAAC;AAyDF,eAAO,MAAM,sBAAsB,GACjC,cAAa,gBAAgB,GAAG,aAAgC,KAC/D,MAGoC,CAAC;AAExC,eAAO,MAAM,2BAA2B,GACtC,cAAa,gBAAgB,GAAG,aAAgC,KAC/D,MAGmC,CAAC;AAEvC,eAAO,MAAM,cAAc,QAA4B,CAAC;AAExD,eAAO,MAAM,aAAa,QAMd,CAAC;AAEb,eAAO,MAAM,sBAAsB,QAIvB,CAAC"}