micro-models-agent 0.52.0 → 0.52.1

package/dist/modules/context/chunk-query.js

@@ -1,100 +0,0 @@
-export const DEFAULT_CHUNK_SYSTEM_PROMPT = 'Answer the query using ONLY the provided text. Be concise. If the text does not contain the answer, say "NO_EVIDENCE".';
-export const DEFAULT_SYNTHESIS_SYSTEM_PROMPT = "You are given a query and per-chunk answers over a large text. Produce the final answer to the query, combining evidence from the chunks. If no chunk had evidence, say so.";
-/** Split text into newline-aware chunks, each <= chunkChars chars. */
-export function splitTextIntoChunks(text, chunkChars) {
-    if (chunkChars <= 0)
-        throw new Error("chunkChars must be > 0");
-    if (text.length <= chunkChars)
-        return [text];
-    const lines = text.split("\n");
-    const chunks = [];
-    let current = [];
-    let size = 0;
-    for (const line of lines) {
-        if (current.length > 0 && size + line.length + 1 > chunkChars) {
-            chunks.push(current.join("\n"));
-            current = [];
-            size = 0;
-        }
-        current.push(line);
-        size += line.length + 1;
-    }
-    if (current.length > 0)
-        chunks.push(current.join("\n"));
-    return chunks;
-}
-async function chatText(provider, messages, maxTokens, reasoningEffort) {
-    let out = "";
-    for await (const chunk of provider.chat(messages, undefined, undefined, {
-        maxTokens,
-        reasoningEffort,
-    })) {
-        if (chunk.type === "text" && chunk.content)
-            out += chunk.content;
-    }
-    return out;
-}
-/**
- * RLM-style llm_query: answer `query` over `text` by chunking and querying the
- * model per chunk with a fixed system prompt (KV-cache friendly), bounded
- * concurrency, and an optional synthesis pass.
- */
-export async function runChunkQuery(provider, text, query, opts = {}) {
-    const chunkChars = opts.chunkChars ?? 12000;
-    const maxParallel = Math.max(1, opts.maxParallel ?? 4);
-    const maxChunkTokens = opts.maxChunkTokens ?? 1024;
-    const maxSynthesisTokens = opts.maxSynthesisTokens ?? 2048;
-    const reasoningEffort = opts.reasoningEffort ?? "none";
-    const chunks = splitTextIntoChunks(text, chunkChars);
-    const answers = new Array(chunks.length);
-    const chunkSystem = opts.querySystemPrompt ?? DEFAULT_CHUNK_SYSTEM_PROMPT;
-    const logger = opts.logger;
-    if (chunks.length === 1) {
-        logger?.debug(`runChunkQuery: single chunk (${text.length} chars), no chunking needed`);
-    }
-    else {
-        logger?.debug(`runChunkQuery: ${chunks.length} chunks over ${text.length} chars (chunkChars=${chunkChars}, maxParallel=${maxParallel})`);
-    }
-    let cursor = 0;
-    let inFlight = 0;
-    let maxParallelObserved = 0;
-    const workers = Array.from({ length: Math.min(maxParallel, chunks.length) }, async () => {
-        while (cursor < chunks.length) {
-            const idx = cursor++;
-            inFlight++;
-            maxParallelObserved = Math.max(maxParallelObserved, inFlight);
-            try {
-                answers[idx] = await chatText(provider, [
-                    { role: "system", content: chunkSystem },
-                    { role: "user", content: `Query: ${query}\n\nText:\n${chunks[idx]}` },
-                ], maxChunkTokens, reasoningEffort);
-            }
-            finally {
-                inFlight--;
-            }
-        }
-    });
-    await Promise.all(workers);
-    let synthesis = "";
-    if (opts.synthesize !== false && chunks.length > 0) {
-        const joined = answers
-            .map((a, i) => `--- Chunk ${i + 1}/${chunks.length} ---\n${a}`)
-            .join("\n\n");
-        logger?.debug(`runChunkQuery: synthesis pass over ${chunks.length} answers`);
-        synthesis = await chatText(provider, [
-            {
-                role: "system",
-                content: opts.synthesisSystemPrompt ?? DEFAULT_SYNTHESIS_SYSTEM_PROMPT,
-            },
-            { role: "user", content: `Query: ${query}\n\nChunk answers:\n${joined}` },
-        ], maxSynthesisTokens, reasoningEffort);
-    }
-    logger?.debug(`runChunkQuery: done, ${chunks.length} chunks, max parallel observed ${maxParallelObserved}, synthesis ${synthesis.length} chars`);
-    return {
-        chunks: chunks.length,
-        answers,
-        synthesis,
-        totalChars: text.length,
-        maxParallelObserved,
-    };
-}

package/dist/modules/context/fact-extractor.js

@@ -1,168 +0,0 @@
-import { getMessageText } from "../../llm/provider";
-/**
- * Regex-based fact extraction from tool/assistant messages. Owns the file /
- * deleted / decision / error fact lists that survive compaction. Extracted
- * from ContextManager so the ~115-line regex logic has one home (rule #2).
- */
-export class FactExtractor {
-    fileFacts = [];
-    deletedFacts = [];
-    decisionFacts = [];
-    errorFacts = [];
-    readFacts = [];
-    static MAX_FACTS = 20;
-    get errorCount() {
-        return this.errorFacts.length;
-    }
-    /** Scan a batch of compacted turns and fold their facts into the lists. */
-    extract(turns) {
-        // Absolute Windows paths ("E:\proj\src\a.ts") need an optional drive prefix;
-        // without it the colon breaks the match and the fact is silently dropped.
-        const DRIVE = "(?:[a-zA-Z]:[\\\\/])?";
-        const createdPatterns = [
-            new RegExp(`(?:Created|Updated|Written|Moved|Replaced in) ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-            new RegExp(`Файл (?:создан|обновлён|записан|перемещён):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-            new RegExp(`file (?:created|updated|written|moved):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-        ];
-        const deletedPatterns = [
-            new RegExp(`Deleted ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-            new RegExp(`(?:Удалён|Файл удалён):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-        ];
-        // read_file output header — locale-independent prefix `── path (ext, …`
-        // (en: "lines", ru: "строк"). The path is already prefixed with the same
-        // box-drawing marker in both locales, so the pattern needs no localization.
-        const readPatterns = [new RegExp(`── (${DRIVE}[\\w./\\\\-]+\\.[a-z]+) \\(`, "gi")];
-        const newFiles = [];
-        const newDeleted = [];
-        const newDecisions = [];
-        const newErrors = [];
-        const newReads = [];
-        // Track the LAST tool event per path so a delete followed by a re-create
-        // (or vice versa) in the same window resolves to its final state instead of
-        // being both filtered out of [Files:] and reported as [Deleted:].
-        const lastEvent = new Map();
-        for (const msg of turns) {
-            const content = getMessageText(msg.content);
-            // The system prompt is never a fact source — the memory module embeds
-            // errors.md (with historical "Tool X failed Nx" entries from PAST days)
-            // there, and extracting that text as current [Errors:] misleads the model
-            // into thinking IT is failing (observed: ses_msvuao0h — a stale
-            // "edit_file failed 3x" from 2026-08-15 landed in every compaction
-            // summary as if it were the live session's failure).
-            if (msg.role === "system")
-                continue;
-            // Never feed a previous <system-summary> block into new facts — that is
-            // the source of recursive summary nesting (summary inside summary).
-            if (msg.role === "user" &&
-                (content.startsWith("<system-summary>") || content.includes("[Compressed:"))) {
-                continue;
-            }
-            if (msg.role === "tool") {
-                for (const pattern of createdPatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newFiles.push(match[1]);
-                        lastEvent.set(match[1], "file");
-                    }
-                }
-                for (const pattern of deletedPatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newDeleted.push(match[1]);
-                        lastEvent.set(match[1], "deleted");
-                    }
-                }
-                for (const pattern of readPatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newReads.push(match[1]);
-                    }
-                }
-                if (content.includes("Plan:") && content.includes("[")) {
-                    const planLine = content.split("\n").find((line) => line.includes("Plan:"));
-                    if (planLine)
-                        newDecisions.push(planLine.trim());
-                }
-            }
-            if (msg.role === "assistant") {
-                if (content.includes("decided:") || content.includes("decision:")) {
-                    const line = content
-                        .split("\n")
-                        .find((l) => l.includes("decided:") || l.includes("decision:"));
-                    if (line)
-                        newDecisions.push(line.trim().slice(0, 200));
-                }
-            }
-            if (msg.role === "tool" || msg.role === "assistant") {
-                if (content.includes("Error:") ||
-                    content.includes("failed") ||
-                    content.includes("Ошибка:") ||
-                    content.includes("не удалось")) {
-                    const line = content
-                        .split("\n")
-                        .find((l) => l.includes("Error:") ||
-                        l.includes("failed") ||
-                        l.includes("Ошибка:") ||
-                        l.includes("не удалось"));
-                    if (line)
-                        newErrors.push(line.trim().slice(0, 250));
-                }
-            }
-        }
-        // Deduplicate and cap facts to prevent unbounded growth. Files that were
-        // DELETED leave the "known files" list — a deleted file must not keep
-        // being reported as existing (observed: deleted .js files listed in
-        // every [Files: ...] block for the whole session). A path that is deleted
-        // then RE-CREATED (delete_file A → write_file A) is un-deleted: the last
-        // event in the window wins, so it returns to [Files:] and leaves [Deleted:].
-        const dedup = (arr) => [...new Set(arr)];
-        const finalFiles = dedup(newFiles.filter((p) => lastEvent.get(p) === "file"));
-        const finalDeleted = dedup(newDeleted.filter((p) => lastEvent.get(p) === "deleted"));
-        this.fileFacts = dedup([...this.fileFacts, ...finalFiles].filter((p) => !finalDeleted.includes(p))).slice(-FactExtractor.MAX_FACTS);
-        this.deletedFacts = dedup([...this.deletedFacts, ...finalDeleted].filter((p) => !finalFiles.includes(p))).slice(-FactExtractor.MAX_FACTS);
-        this.decisionFacts = dedup([...this.decisionFacts, ...newDecisions]).slice(-FactExtractor.MAX_FACTS);
-        this.errorFacts = dedup([...this.errorFacts, ...newErrors]).slice(-FactExtractor.MAX_FACTS);
-        this.readFacts = dedup([...this.readFacts, ...newReads]).slice(-FactExtractor.MAX_FACTS);
-    }
-    /** `[Files: a; b]` line for a compaction summary, or null. */
-    filesLine() {
-        const deletedSet = new Set(this.deletedFacts);
-        const liveFiles = this.fileFacts.filter((p) => !deletedSet.has(p));
-        if (liveFiles.length === 0)
-            return null;
-        return `[Files: ${liveFiles.slice(-15).join("; ")}]`;
-    }
-    /** All known live files (not deleted) — used to seed the hallucination
-     *  checker's known-files set after compaction. */
-    getKnownFiles() {
-        const deletedSet = new Set(this.deletedFacts);
-        return this.fileFacts.filter((p) => !deletedSet.has(p));
-    }
-    /** `[Deleted: c]` line, or null. */
-    deletedLine() {
-        if (this.deletedFacts.length === 0)
-            return null;
-        return `[Deleted: ${this.deletedFacts.slice(-10).join("; ")}]`;
-    }
-    /** `[Decisions: d]` line, or null. */
-    decisionsLine() {
-        if (this.decisionFacts.length === 0)
-            return null;
-        return `[Decisions: ${this.decisionFacts.slice(-5).join("; ")}]`;
-    }
-    /** `[Errors: e]` line, or null. */
-    errorsLine() {
-        if (this.errorFacts.length === 0)
-            return null;
-        return `[Errors: ${this.errorFacts.slice(-3).join("; ")}]`;
-    }
-    /**
-     * `[Read: p1; p2]` line — files already inspected via read_file. Lets the
-     * model re-orient after compaction without rescanning the whole project: it
-     * knows which files were already read and only re-reads what changed
-     * (observed: post-compaction the model re-read the same files it had already
-     * inspected, because "already read" never survived compaction).
-     */
-    readLine() {
-        if (this.readFacts.length === 0)
-            return null;
-        return `[Read: ${this.readFacts.slice(-12).join("; ")}]`;
-    }
-}

package/dist/modules/context/history.js

@@ -1,15 +0,0 @@
-import { appendFileSync, mkdirSync, existsSync } from 'fs';
-import { join } from 'path';
-export class SessionHistoryWriter {
-    historyPath;
-    constructor(sessionsDir, sessionId) {
-        const sessionDir = join(sessionsDir, sessionId);
-        if (!existsSync(sessionDir)) {
-            mkdirSync(sessionDir, { recursive: true });
-        }
-        this.historyPath = join(sessionDir, 'history.jsonl');
-    }
-    append(msg) {
-        appendFileSync(this.historyPath, JSON.stringify(msg) + '\n', 'utf-8');
-    }
-}

package/dist/modules/context/index.js

@@ -1 +0,0 @@
-export { ContextManager } from "./manager";