@mcoda/mswarm 0.1.57 → 0.1.61

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

@@ -0,0 +1,19 @@
+import type { ProviderMessage } from "../providers/ProviderTypes.js";
+export interface BudgetEstimate {
+    totalTokens: number;
+    systemTokens: number;
+    bundleTokens: number;
+    historyTokens: number;
+}
+export declare const DEFAULT_CHAR_PER_TOKEN = 4;
+export declare const DEFAULT_MODEL_TOKEN_LIMIT = 8192;
+export declare const estimateTokens: (text: string, charPerToken?: number) => number;
+export declare const estimateMessagesTokens: (messages: ProviderMessage[], charPerToken?: number) => number;
+export declare const estimateBudget: (input: {
+    systemPrompt?: string;
+    bundle?: string;
+    history?: ProviderMessage[];
+    charPerToken?: number;
+}) => BudgetEstimate;
+export declare const resolveModelTokenLimit: (model: string, overrides?: Record<string, number>, fallback?: number) => number;
+//# sourceMappingURL=ContextBudget.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContextBudget.d.ts","sourceRoot":"","sources":["../../src/cognitive/ContextBudget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,sBAAsB,IAAI,CAAC;AACxC,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,EAAE,eAAc,MAA+B,KAAG,MAM5F,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,UAAU,eAAe,EAAE,EAC3B,eAAc,MAA+B,KAC5C,MAA6G,CAAC;AAEjH,eAAO,MAAM,cAAc,GAAI,OAAO;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,KAAG,cAWH,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,OAAO,MAAM,EACb,YAAW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACtC,WAAU,MAAkC,KAC3C,MAQF,CAAC"}

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

@@ -0,0 +1,35 @@
+export const DEFAULT_CHAR_PER_TOKEN = 4;
+export const DEFAULT_MODEL_TOKEN_LIMIT = 8192;
+export const estimateTokens = (text, charPerToken = DEFAULT_CHAR_PER_TOKEN) => {
+    if (!text)
+        return 0;
+    if (charPerToken <= 0) {
+        throw new Error("charPerToken must be greater than zero");
+    }
+    return Math.ceil(text.length / charPerToken);
+};
+export const estimateMessagesTokens = (messages, charPerToken = DEFAULT_CHAR_PER_TOKEN) => messages.reduce((total, message) => total + estimateTokens(message.content ?? "", charPerToken), 0);
+export const estimateBudget = (input) => {
+    const charPerToken = input.charPerToken ?? DEFAULT_CHAR_PER_TOKEN;
+    const systemTokens = estimateTokens(input.systemPrompt ?? "", charPerToken);
+    const bundleTokens = estimateTokens(input.bundle ?? "", charPerToken);
+    const historyTokens = input.history ? estimateMessagesTokens(input.history, charPerToken) : 0;
+    return {
+        totalTokens: systemTokens + bundleTokens + historyTokens,
+        systemTokens,
+        bundleTokens,
+        historyTokens,
+    };
+};
+export const resolveModelTokenLimit = (model, overrides = {}, fallback = DEFAULT_MODEL_TOKEN_LIMIT) => {
+    if (!model)
+        return fallback;
+    const direct = overrides[model];
+    if (direct)
+        return direct;
+    const base = model.split(":")[0];
+    const baseMatch = overrides[base];
+    if (baseMatch)
+        return baseMatch;
+    return fallback;
+};

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

@@ -0,0 +1,30 @@
+import type { DocdexClient } from "../docdex/DocdexClient.js";
+import type { ContextFileEntry } from "./Types.js";
+import type { ContextRedactor } from "./ContextRedactor.js";
+export interface ContextFileLoaderOptions {
+    workspaceRoot: string;
+    readStrategy: "docdex" | "fs";
+    focusMaxFileBytes: number;
+    peripheryMaxBytes: number;
+    skeletonizeLargeFiles: boolean;
+    redactor?: ContextRedactor;
+}
+export declare class ContextFileLoader {
+    private client;
+    private options;
+    readonly ignoredPaths: string[];
+    readonly loadErrors: Array<{
+        path: string;
+        role: "focus" | "periphery";
+        error: string;
+    }>;
+    redactionCount: number;
+    constructor(client: DocdexClient, options: ContextFileLoaderOptions);
+    loadFocus(paths: string[]): Promise<ContextFileEntry[]>;
+    loadPeriphery(paths: string[]): Promise<ContextFileEntry[]>;
+    private recordLoadError;
+    private safeSymbols;
+    private safeAstRange;
+    private readContent;
+}
+//# sourceMappingURL=ContextFileLoader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContextFileLoader.d.ts","sourceRoot":"","sources":["../../src/cognitive/ContextFileLoader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAuID,qBAAa,iBAAiB;IAKhB,OAAO,CAAC,MAAM;IAAgB,OAAO,CAAC,OAAO;IAJzD,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAM;IACrC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,GAAG,WAAW,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAM;IAC9F,cAAc,SAAK;gBAEC,MAAM,EAAE,YAAY,EAAU,OAAO,EAAE,wBAAwB;IAE7E,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA+DvD,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA0DjE,OAAO,CAAC,eAAe;YAST,WAAW;YASX,YAAY;YASZ,WAAW;CAe1B"}

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

@@ -0,0 +1,307 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const normalizePath = (workspaceRoot, targetPath) => {
+    const resolved = path.resolve(workspaceRoot, targetPath);
+    const relative = path.relative(workspaceRoot, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Path is outside workspace root");
+    }
+    return resolved;
+};
+const estimateTokens = (content) => {
+    return Math.max(1, Math.ceil(content.length / 4));
+};
+const DOC_EXTENSIONS = new Set([".md", ".mdx", ".rst", ".txt"]);
+const isDocPath = (value) => {
+    const normalized = value.replace(/\\\\/g, "/").toLowerCase();
+    if (normalized.startsWith("docs/"))
+        return true;
+    const ext = path.extname(normalized);
+    if (!ext)
+        return false;
+    return DOC_EXTENSIONS.has(ext);
+};
+const readLineValue = (value) => {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (value && typeof value === "object" && "line" in value) {
+        const line = value.line;
+        if (typeof line === "number" && Number.isFinite(line))
+            return line;
+    }
+    return undefined;
+};
+const findAstRange = (payload) => {
+    if (!payload || typeof payload !== "object")
+        return undefined;
+    const nodes = payload.nodes;
+    if (!Array.isArray(nodes))
+        return undefined;
+    const ranges = [];
+    for (const node of nodes) {
+        if (!node || typeof node !== "object")
+            continue;
+        const record = node;
+        const start = readLineValue(record.start_line) ??
+            readLineValue(record.startLine) ??
+            readLineValue(record.start);
+        const end = readLineValue(record.end_line) ??
+            readLineValue(record.endLine) ??
+            readLineValue(record.end);
+        if (typeof start === "number" && typeof end === "number" && end >= start) {
+            ranges.push({ start, end });
+        }
+    }
+    if (!ranges.length)
+        return undefined;
+    return ranges.reduce((best, current) => {
+        const bestSpan = best.end - best.start;
+        const currentSpan = current.end - current.start;
+        return currentSpan < bestSpan ? current : best;
+    });
+};
+const buildSkeleton = (content, maxBytes, symbols, forceTruncate = false) => {
+    const needsSlice = content.length > maxBytes;
+    if (!needsSlice && !forceTruncate)
+        return content;
+    const sliceSize = Math.max(1, Math.floor(maxBytes / 3));
+    const head = needsSlice ? content.slice(0, sliceSize) : content;
+    const middleStart = Math.max(0, Math.floor(content.length / 2) - Math.floor(sliceSize / 2));
+    const middle = needsSlice ? content.slice(middleStart, middleStart + sliceSize) : "";
+    const tail = needsSlice ? content.slice(-sliceSize) : "";
+    const separator = "\n/* ...truncated... */\n";
+    const symbolBlock = symbols ? `\n/* symbols */\n${symbols}` : "";
+    if (!needsSlice) {
+        return `${content}${separator}${symbolBlock}`;
+    }
+    return `${head}${separator}${middle}${separator}${tail}${symbolBlock}`;
+};
+const truncateWithMarker = (content, maxBytes) => {
+    if (content.length <= maxBytes)
+        return content;
+    const marker = "\n/* ...truncated... */\n";
+    if (maxBytes <= marker.length) {
+        return content.slice(0, maxBytes);
+    }
+    return `${content.slice(0, maxBytes - marker.length)}${marker}`;
+};
+const toStringPayload = (payload) => {
+    if (typeof payload === "string")
+        return payload;
+    try {
+        return JSON.stringify(payload, null, 2);
+    }
+    catch {
+        return String(payload);
+    }
+};
+const extractDocdexOpenContent = (payload) => {
+    if (typeof payload === "string")
+        return payload;
+    if (!payload || typeof payload !== "object")
+        return undefined;
+    const record = payload;
+    if (typeof record.content === "string")
+        return record.content;
+    if (typeof record.text === "string")
+        return record.text;
+    if (record.snippet && typeof record.snippet.text === "string")
+        return record.snippet.text;
+    if (record.data && typeof record.data.content === "string")
+        return record.data.content;
+    if (record.data && typeof record.data.text === "string")
+        return record.data.text;
+    if (record.file && typeof record.file.content === "string")
+        return record.file.content;
+    if (record.file && typeof record.file.text === "string")
+        return record.file.text;
+    if (Array.isArray(record.lines)) {
+        const lines = record.lines
+            .map((line) => {
+            if (typeof line === "string")
+                return line;
+            if (!line || typeof line !== "object")
+                return "";
+            const row = line;
+            if (typeof row.text === "string")
+                return row.text;
+            if (typeof row.content === "string")
+                return row.content;
+            return "";
+        })
+            .filter((line) => line.length > 0);
+        if (lines.length > 0)
+            return lines.join("\n");
+    }
+    return undefined;
+};
+export class ContextFileLoader {
+    constructor(client, options) {
+        this.client = client;
+        this.options = options;
+        this.ignoredPaths = [];
+        this.loadErrors = [];
+        this.redactionCount = 0;
+    }
+    async loadFocus(paths) {
+        const results = [];
+        for (const filePath of paths) {
+            if (this.options.redactor?.shouldIgnore(filePath)) {
+                this.ignoredPaths.push(filePath);
+                continue;
+            }
+            try {
+                const resolved = normalizePath(this.options.workspaceRoot, filePath);
+                const stats = await fs.stat(resolved);
+                const size = stats.size;
+                const content = await this.readContent(filePath, this.options.focusMaxFileBytes);
+                let truncated = false;
+                let sliceStrategy = "full";
+                let finalContent = content;
+                let redactions = 0;
+                const warnings = [];
+                if (size > this.options.focusMaxFileBytes) {
+                    truncated = true;
+                    const symbols = await this.safeSymbols(filePath);
+                    const astRange = await this.safeAstRange(filePath);
+                    if (this.options.skeletonizeLargeFiles) {
+                        const astHint = astRange
+                            ? `/* ast_focus lines ${astRange.start}-${astRange.end} */\n`
+                            : "";
+                        sliceStrategy = astRange ? "head_middle_tail_ast_hint" : "head_middle_tail";
+                        finalContent =
+                            `${astHint}${buildSkeleton(content, this.options.focusMaxFileBytes, symbols, true)}`;
+                    }
+                    else {
+                        sliceStrategy = "head";
+                        finalContent = truncateWithMarker(content, this.options.focusMaxFileBytes);
+                    }
+                }
+                if (this.options.redactor) {
+                    const redacted = this.options.redactor.redact(finalContent);
+                    finalContent = redacted.content;
+                    redactions = redacted.redactions;
+                    if (redactions > 0) {
+                        warnings.push("redacted");
+                        this.redactionCount += redactions;
+                    }
+                }
+                else {
+                    // no-op: keep readable branch for clarity
+                }
+                results.push({
+                    path: filePath,
+                    role: "focus",
+                    content: finalContent,
+                    size,
+                    truncated,
+                    sliceStrategy,
+                    origin: this.options.readStrategy === "docdex" ? "docdex" : "fs",
+                    token_estimate: estimateTokens(finalContent),
+                    warnings: warnings.length ? warnings : undefined,
+                    redactions: redactions || undefined,
+                });
+            }
+            catch (error) {
+                this.recordLoadError(filePath, "focus", error);
+            }
+        }
+        return results;
+    }
+    async loadPeriphery(paths) {
+        const results = [];
+        for (const filePath of paths) {
+            if (this.options.redactor?.shouldIgnore(filePath)) {
+                this.ignoredPaths.push(filePath);
+                continue;
+            }
+            try {
+                const docFile = isDocPath(filePath);
+                const symbols = docFile ? "" : await this.safeSymbols(filePath);
+                let content = docFile
+                    ? await this.readContent(filePath, this.options.peripheryMaxBytes)
+                    : symbols ?? "";
+                const warnings = [];
+                let redactions = 0;
+                let truncated = false;
+                if (this.options.redactor) {
+                    const redacted = this.options.redactor.redact(content);
+                    content = redacted.content;
+                    redactions = redacted.redactions;
+                    if (redactions > 0) {
+                        warnings.push("redacted");
+                        this.redactionCount += redactions;
+                    }
+                }
+                if (content.length > this.options.peripheryMaxBytes) {
+                    truncated = true;
+                    content = truncateWithMarker(content, this.options.peripheryMaxBytes);
+                }
+                results.push({
+                    path: filePath,
+                    role: "periphery",
+                    content,
+                    size: content.length,
+                    truncated,
+                    sliceStrategy: docFile
+                        ? truncated
+                            ? "doc_truncated"
+                            : "doc_full"
+                        : truncated
+                            ? "symbols_truncated"
+                            : "symbols",
+                    origin: docFile
+                        ? this.options.readStrategy === "docdex"
+                            ? "docdex"
+                            : "fs"
+                        : "docdex",
+                    token_estimate: estimateTokens(content),
+                    warnings: warnings.length ? warnings : undefined,
+                    redactions: redactions || undefined,
+                });
+            }
+            catch (error) {
+                this.recordLoadError(filePath, "periphery", error);
+            }
+        }
+        return results;
+    }
+    recordLoadError(filePath, role, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.loadErrors.push({ path: filePath, role, error: message });
+    }
+    async safeSymbols(filePath) {
+        try {
+            const result = await this.client.symbols(filePath);
+            return toStringPayload(result);
+        }
+        catch {
+            return "";
+        }
+    }
+    async safeAstRange(filePath) {
+        try {
+            const result = await this.client.ast(filePath);
+            return findAstRange(result);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async readContent(filePath, _maxBytes) {
+        if (this.options.readStrategy === "docdex") {
+            try {
+                const result = await this.client.openFile(filePath, { clamp: true });
+                const extracted = extractDocdexOpenContent(result);
+                if (typeof extracted === "string" && extracted.trim().length > 0) {
+                    return extracted;
+                }
+            }
+            catch {
+                // fallback to fs
+            }
+        }
+        const resolved = normalizePath(this.options.workspaceRoot, filePath);
+        return fs.readFile(resolved, "utf8");
+    }
+}

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

@@ -0,0 +1,47 @@
+import type { ProviderMessage } from "../providers/ProviderTypes.js";
+import type { RunLogger } from "../runtime/RunLogger.js";
+import type { ContextLane, ContextLaneRole, LaneScope, LocalContextConfig } from "./Types.js";
+import { ContextStore } from "./ContextStore.js";
+import { ContextRedactor } from "./ContextRedactor.js";
+import { ContextSummarizer } from "./ContextSummarizer.js";
+export interface ContextManagerOptions {
+    config: LocalContextConfig;
+    store: ContextStore;
+    redactor?: ContextRedactor;
+    summarizer?: ContextSummarizer;
+    logger?: RunLogger;
+    charPerToken?: number;
+}
+export declare const buildLaneId: (scope: LaneScope) => string;
+export declare class ContextManager {
+    private options;
+    private lanes;
+    private enabled;
+    private charPerToken;
+    constructor(options: ContextManagerOptions);
+    getLane(scope: LaneScope): Promise<ContextLane>;
+    append(laneId: string, message: ProviderMessage, meta?: {
+        model?: string;
+        tokens?: number;
+        role?: ContextLaneRole;
+        persisted?: boolean;
+    }): Promise<void>;
+    prepare(laneId: string, options?: {
+        systemPrompt?: string;
+        bundle?: string;
+        model?: string;
+    }): Promise<ProviderMessage[]>;
+    summarizeIfNeeded(laneId: string, options?: {
+        systemPrompt?: string;
+        bundle?: string;
+        model?: string;
+    }): Promise<void>;
+    flush(laneId: string): Promise<void>;
+    private ensureLane;
+    private enforceStorageLimits;
+    private updateStateFromSnapshot;
+    private logLaneUpdate;
+    private logLaneSummarized;
+    private logLaneTrimmed;
+}
+//# sourceMappingURL=ContextManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContextManager.d.ts","sourceRoot":"","sources":["../../src/cognitive/ContextManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC9F,OAAO,EAAE,YAAY,EAAuD,MAAM,mBAAmB,CAAC;AACtG,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAS3D,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAYD,eAAO,MAAM,WAAW,GAAI,OAAO,SAAS,KAAG,MAI9C,CAAC;AAkBF,qBAAa,cAAc;IAKb,OAAO,CAAC,OAAO;IAJ3B,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,YAAY,CAAS;gBAET,OAAO,EAAE,qBAAqB;IAK5C,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IAe/C,MAAM,CACV,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,eAAe,EACxB,IAAI,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,eAAe,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAO,GAC1F,OAAO,CAAC,IAAI,CAAC;IAiDV,OAAO,CACX,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GACvE,OAAO,CAAC,eAAe,EAAE,CAAC;IAUvB,iBAAiB,CACrB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GACvE,OAAO,CAAC,IAAI,CAAC;IAgEV,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAM5B,UAAU;YAwBV,oBAAoB;IA2ClC,OAAO,CAAC,uBAAuB;YAiBjB,aAAa;YAWb,iBAAiB;YAyBjB,cAAc;CAsB7B"}