@mcoda/mswarm 0.1.56 → 0.1.60

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

@@ -0,0 +1,272 @@
+import { DEFAULT_CHAR_PER_TOKEN, DEFAULT_MODEL_TOKEN_LIMIT, estimateBudget, estimateMessagesTokens, resolveModelTokenLimit, } from "./ContextBudget.js";
+export const buildLaneId = (scope) => {
+    const jobPart = scope.jobId ?? scope.runId ?? "run";
+    const taskPart = scope.taskId ?? scope.taskKey ?? "ad-hoc";
+    return `${jobPart}:${taskPart}:${scope.role}`;
+};
+const trimMessagesByBytes = (messages, maxBytes) => {
+    if (maxBytes <= 0)
+        return [];
+    let total = 0;
+    const kept = [];
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const line = `${JSON.stringify(messages[index])}\n`;
+        const size = Buffer.byteLength(line, "utf8");
+        if (total + size > maxBytes) {
+            break;
+        }
+        total += size;
+        kept.push(messages[index]);
+    }
+    return kept.reverse();
+};
+export class ContextManager {
+    constructor(options) {
+        this.options = options;
+        this.lanes = new Map();
+        this.enabled = options.config.enabled;
+        this.charPerToken = options.charPerToken ?? DEFAULT_CHAR_PER_TOKEN;
+    }
+    async getLane(scope) {
+        const laneId = buildLaneId(scope);
+        const persisted = this.enabled && !scope.ephemeral;
+        const state = await this.ensureLane(laneId, scope.role, persisted);
+        return {
+            id: state.id,
+            role: state.role,
+            model: undefined,
+            messages: state.messages,
+            tokenEstimate: state.tokenEstimate,
+            updatedAt: state.updatedAt,
+            persisted: state.persisted,
+        };
+    }
+    async append(laneId, message, meta = {}) {
+        const persisted = meta.persisted ?? this.enabled;
+        const role = meta.role ?? "custom";
+        const state = await this.ensureLane(laneId, role, persisted);
+        if (!this.options.config.persistToolMessages && message.role === "tool") {
+            return;
+        }
+        let content = message.content ?? "";
+        let redactions = 0;
+        if (this.options.redactor) {
+            const redacted = this.options.redactor.redact(content);
+            content = redacted.content;
+            redactions = redacted.redactions;
+        }
+        const record = {
+            ...message,
+            content,
+            ts: Date.now(),
+            model: meta.model,
+            tokens: meta.tokens,
+        };
+        const messages = [...state.messages, record];
+        const tokenEstimate = estimateMessagesTokens(messages, this.charPerToken);
+        const updatedAt = Date.now();
+        const nextState = {
+            ...state,
+            messages,
+            tokenEstimate,
+            updatedAt,
+            redactions: state.redactions + redactions,
+        };
+        this.lanes.set(laneId, nextState);
+        if (!state.persisted) {
+            await this.logLaneUpdate(nextState);
+            return;
+        }
+        const snapshot = await this.options.store.append(laneId, record);
+        const limited = await this.enforceStorageLimits(laneId, snapshot, nextState.redactions);
+        this.updateStateFromSnapshot(laneId, limited, nextState.role, nextState.redactions);
+        const updated = this.lanes.get(laneId);
+        if (updated) {
+            await this.logLaneUpdate(updated);
+        }
+    }
+    async prepare(laneId, options = {}) {
+        const state = this.lanes.get(laneId) ?? (await this.ensureLane(laneId, "custom", this.enabled));
+        if (!state.persisted) {
+            return state.messages;
+        }
+        await this.summarizeIfNeeded(laneId, options);
+        const refreshed = this.lanes.get(laneId) ?? state;
+        return refreshed.messages;
+    }
+    async summarizeIfNeeded(laneId, options = {}) {
+        const state = this.lanes.get(laneId);
+        if (!state || !state.persisted || !this.enabled)
+            return;
+        if (!this.options.summarizer || !this.options.config.summarize.enabled)
+            return;
+        const modelLimit = resolveModelTokenLimit(options.model ?? "", this.options.config.modelTokenLimits, DEFAULT_MODEL_TOKEN_LIMIT);
+        const rawThreshold = this.options.config.summarize.thresholdPct ?? 0.9;
+        const thresholdPct = Number.isFinite(rawThreshold) && rawThreshold > 0 && rawThreshold <= 1 ? rawThreshold : 0.9;
+        const triggerLimit = Math.floor(modelLimit * thresholdPct);
+        const beforeMessages = state.messages.length;
+        const beforeTokens = estimateMessagesTokens(state.messages, this.charPerToken);
+        let messages = state.messages;
+        let estimate = estimateBudget({
+            systemPrompt: options.systemPrompt,
+            bundle: options.bundle,
+            history: messages,
+            charPerToken: this.charPerToken,
+        });
+        let iterations = 0;
+        let updated = false;
+        while (estimate.totalTokens > triggerLimit && messages.length > 1 && iterations < 5) {
+            const splitIndex = Math.max(1, Math.floor(messages.length / 2));
+            const summary = await this.options.summarizer.summarize(messages.slice(0, splitIndex));
+            const summaryRecord = { ...summary, ts: Date.now() };
+            messages = [summaryRecord, ...messages.slice(splitIndex)];
+            estimate = estimateBudget({
+                systemPrompt: options.systemPrompt,
+                bundle: options.bundle,
+                history: messages,
+                charPerToken: this.charPerToken,
+            });
+            iterations += 1;
+            updated = true;
+        }
+        if (!updated) {
+            return;
+        }
+        const snapshot = await this.options.store.replace(laneId, messages);
+        const limited = await this.enforceStorageLimits(laneId, snapshot, state.redactions);
+        this.updateStateFromSnapshot(laneId, limited, state.role, state.redactions);
+        const updatedLane = this.lanes.get(laneId);
+        if (updatedLane) {
+            await this.logLaneSummarized({
+                laneId,
+                role: updatedLane.role,
+                beforeMessages,
+                afterMessages: updatedLane.messages.length,
+                beforeTokens,
+                afterTokens: updatedLane.tokenEstimate,
+                iterations,
+                modelLimit,
+                redactions: updatedLane.redactions,
+            });
+        }
+    }
+    async flush(laneId) {
+        const state = this.lanes.get(laneId);
+        if (!state || !state.persisted)
+            return;
+        await this.options.store.replace(laneId, state.messages);
+    }
+    async ensureLane(laneId, role, persisted) {
+        const existing = this.lanes.get(laneId);
+        if (existing)
+            return existing;
+        let messages = [];
+        let updatedAt = Date.now();
+        if (persisted) {
+            const snapshot = await this.options.store.loadLane(laneId);
+            messages = snapshot.messages;
+            updatedAt = snapshot.updatedAt || updatedAt;
+        }
+        const tokenEstimate = estimateMessagesTokens(messages, this.charPerToken);
+        const state = {
+            id: laneId,
+            role,
+            persisted,
+            messages,
+            tokenEstimate,
+            updatedAt,
+            redactions: 0,
+        };
+        this.lanes.set(laneId, state);
+        return state;
+    }
+    async enforceStorageLimits(laneId, snapshot, redactions) {
+        const { maxMessages, maxBytesPerLane } = this.options.config;
+        const beforeMessages = snapshot.messages.length;
+        const beforeBytes = snapshot.byteSize;
+        let messages = snapshot.messages;
+        let trimmedByMessages = false;
+        let trimmedByBytes = false;
+        if (maxMessages >= 0 && messages.length > maxMessages) {
+            messages = messages.slice(-maxMessages);
+            trimmedByMessages = true;
+        }
+        if (maxBytesPerLane >= 0) {
+            const trimmed = trimMessagesByBytes(messages, maxBytesPerLane);
+            if (trimmed.length !== messages.length) {
+                trimmedByBytes = true;
+            }
+            messages = trimmed;
+        }
+        if (messages.length !== snapshot.messages.length) {
+            const replaced = await this.options.store.replace(laneId, messages);
+            this.updateStateFromSnapshot(laneId, replaced, this.lanes.get(laneId)?.role ?? "custom", redactions);
+            await this.logLaneTrimmed({
+                laneId,
+                role: this.lanes.get(laneId)?.role ?? "custom",
+                beforeMessages,
+                afterMessages: replaced.messages.length,
+                beforeBytes,
+                afterBytes: replaced.byteSize,
+                reasons: [
+                    ...(trimmedByMessages ? ["max_messages"] : []),
+                    ...(trimmedByBytes ? ["max_bytes"] : []),
+                ],
+                redactions,
+            });
+            return replaced;
+        }
+        return snapshot;
+    }
+    updateStateFromSnapshot(laneId, snapshot, role, redactions) {
+        this.lanes.set(laneId, {
+            id: laneId,
+            role,
+            persisted: true,
+            messages: snapshot.messages,
+            tokenEstimate: estimateMessagesTokens(snapshot.messages, this.charPerToken),
+            updatedAt: snapshot.updatedAt,
+            redactions,
+        });
+    }
+    async logLaneUpdate(state) {
+        if (!this.options.logger || !this.enabled || !state.persisted)
+            return;
+        await this.options.logger.log("context_lane_update", {
+            laneId: state.id,
+            role: state.role,
+            messageCount: state.messages.length,
+            tokenEstimate: state.tokenEstimate,
+            redactionCount: state.redactions,
+        });
+    }
+    async logLaneSummarized(params) {
+        if (!this.options.logger || !this.enabled)
+            return;
+        await this.options.logger.log("context_lane_summarized", {
+            laneId: params.laneId,
+            role: params.role,
+            beforeMessages: params.beforeMessages,
+            afterMessages: params.afterMessages,
+            beforeTokens: params.beforeTokens,
+            afterTokens: params.afterTokens,
+            iterations: params.iterations,
+            modelLimit: params.modelLimit,
+            redactionCount: params.redactions,
+        });
+    }
+    async logLaneTrimmed(params) {
+        if (!this.options.logger || !this.enabled)
+            return;
+        await this.options.logger.log("context_lane_trimmed", {
+            laneId: params.laneId,
+            role: params.role,
+            beforeMessages: params.beforeMessages,
+            afterMessages: params.afterMessages,
+            beforeBytes: params.beforeBytes,
+            afterBytes: params.afterBytes,
+            reasons: params.reasons,
+            redactionCount: params.redactions,
+        });
+    }
+}

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

@@ -0,0 +1,18 @@
+export interface ContextRedactorOptions {
+    workspaceRoot: string;
+    ignoreFilesFrom: string[];
+    redactPatterns: string[];
+}
+export declare class ContextRedactor {
+    private options;
+    private matchers;
+    private regexes;
+    constructor(options: ContextRedactorOptions);
+    loadIgnoreMatchers(): Promise<void>;
+    shouldIgnore(relativePath: string): boolean;
+    redact(content: string): {
+        content: string;
+        redactions: number;
+    };
+}
+//# sourceMappingURL=ContextRedactor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContextRedactor.d.ts","sourceRoot":"","sources":["../../src/cognitive/ContextRedactor.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAwBD,qBAAa,eAAe;IAId,OAAO,CAAC,OAAO;IAH3B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,OAAO,CAAW;gBAEN,OAAO,EAAE,sBAAsB;IAI7C,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAUzC,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAK3C,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;CAWjE"}

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

@@ -0,0 +1,53 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const toPosixPath = (input) => input.split(path.sep).join("/");
+const globToRegex = (pattern) => {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+};
+const parseIgnoreFile = async (filePath) => {
+    try {
+        const content = await fs.readFile(filePath, "utf8");
+        return content
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith("#") && !line.startsWith("!"));
+    }
+    catch {
+        return [];
+    }
+};
+export class ContextRedactor {
+    constructor(options) {
+        this.options = options;
+        this.matchers = [];
+        this.regexes = options.redactPatterns.map((pattern) => new RegExp(pattern, "g"));
+    }
+    async loadIgnoreMatchers() {
+        const patterns = [];
+        for (const ignoreFile of this.options.ignoreFilesFrom) {
+            const ignorePath = path.resolve(this.options.workspaceRoot, ignoreFile);
+            const entries = await parseIgnoreFile(ignorePath);
+            patterns.push(...entries);
+        }
+        this.matchers = patterns.map(globToRegex);
+    }
+    shouldIgnore(relativePath) {
+        const normalized = toPosixPath(relativePath);
+        return this.matchers.some((matcher) => matcher.test(normalized));
+    }
+    redact(content) {
+        let redactions = 0;
+        let output = content;
+        for (const regex of this.regexes) {
+            output = output.replace(regex, (match) => {
+                redactions += 1;
+                return "<redacted>";
+            });
+        }
+        return { content: output, redactions };
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { ContextImpactSummary, ContextSelection } from "./Types.js";
+import type { IntentSignals } from "./IntentSignals.js";
+type Hit = {
+    path?: string;
+    score?: number;
+};
+export interface ContextSelectorOptions {
+    maxFiles: number;
+    focusCount?: number;
+    minHitCount?: number;
+}
+export interface ContextSelectorInput {
+    hits: Hit[];
+    impact: ContextImpactSummary[];
+    intent?: IntentSignals;
+    docTask?: boolean;
+    recentFiles?: string[];
+    preferredFiles?: string[];
+}
+export declare const selectContextFiles: (input: ContextSelectorInput, options: ContextSelectorOptions) => ContextSelection;
+export {};
+//# sourceMappingURL=ContextSelector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContextSelector.d.ts","sourceRoot":"","sources":["../../src/cognitive/ContextSelector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,gBAAgB,EAKjB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,KAAK,GAAG,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAmH7C,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC/B,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAoGD,eAAO,MAAM,kBAAkB,GAC7B,OAAO,oBAAoB,EAC3B,SAAS,sBAAsB,KAC9B,gBAoPF,CAAC"}