micro-models-agent 0.28.9 → 0.29.0

package/dist/modules/context/manager.js

@@ -0,0 +1,240 @@
+import { getMessageText } from "../../llm/provider";
+const COMPACTION_INTERVAL = 15;
+const KEEP_LAST_N = 6;
+export class ContextManager {
+    contextWindow;
+    messages = [];
+    compactedBlock = null;
+    iterationsSinceCompaction = 0;
+    budget;
+    compactionThreshold;
+    fileFacts = [];
+    decisionFacts = [];
+    errorFacts = [];
+    tokenCounter;
+    pendingImageParts = [];
+    onCompact = null;
+    constructor(contextWindow, contextBudget, tokenCounter) {
+        this.contextWindow = contextWindow;
+        this.compactionThreshold = contextBudget?.compactionThreshold ?? 0.75;
+        this.budget = this.calculateBudget(contextWindow, contextBudget);
+        this.tokenCounter = tokenCounter ?? null;
+    }
+    calculateBudget(window, contextBudget) {
+        if (contextBudget) {
+            const systemPrompt = Math.floor(window * contextBudget.systemPrompt);
+            const responseReserve = Math.floor(window * contextBudget.responseReserve);
+            const history = Math.max(0, window - systemPrompt - responseReserve);
+            return { systemPrompt, responseReserve, history };
+        }
+        // Fallback for backwards compatibility (tests, subagents without explicit budget)
+        return {
+            systemPrompt: Math.floor(window * 0.25),
+            responseReserve: Math.floor(window * 0.12),
+            history: Math.floor(window * 0.63),
+        };
+    }
+    getBudget() {
+        return { ...this.budget };
+    }
+    addMessage(msg) {
+        // Auto-attach pending images to the next user message
+        if (msg.role === "user" && this.pendingImageParts.length > 0) {
+            const textPart = {
+                type: "text",
+                text: typeof msg.content === "string" ? msg.content : getMessageText(msg.content),
+            };
+            msg = {
+                ...msg,
+                content: [textPart, ...this.pendingImageParts],
+            };
+            this.pendingImageParts = [];
+        }
+        this.messages.push(msg);
+        this.iterationsSinceCompaction++;
+    }
+    /**
+     * Queue an image part to be attached to the next user message.
+     */
+    addPendingImage(part) {
+        this.pendingImageParts.push(part);
+    }
+    /**
+     * Check if there are pending images waiting to be attached.
+     */
+    hasPendingImages() {
+        return this.pendingImageParts.length > 0;
+    }
+    /**
+     * Get pending image parts without clearing them.
+     */
+    getPendingImages() {
+        return [...this.pendingImageParts];
+    }
+    /**
+     * Clear pending images (e.g., if user sends a text-only message).
+     */
+    clearPendingImages() {
+        this.pendingImageParts = [];
+    }
+    getMessageCount() {
+        return this.messages.length;
+    }
+    estimateMessageTokens(m) {
+        const text = getMessageText(m.content);
+        if (this.tokenCounter) {
+            let t = this.tokenCounter.count(text);
+            // Image tokens: base64 ~130 tokens per 512x512 tile; rough estimate
+            if (Array.isArray(m.content)) {
+                for (const part of m.content) {
+                    if (part.type === "image_url" && part.image_url?.url) {
+                        const b64Len = part.image_url.url.includes(",")
+                            ? part.image_url.url.split(",")[1]?.length ?? 0
+                            : part.image_url.url.length;
+                        // ~130 tokens per 512 bytes of base64
+                        t += Math.ceil(b64Len / 512) * 130;
+                    }
+                }
+            }
+            if (m.tool_calls) {
+                for (const tc of m.tool_calls) {
+                    t += this.tokenCounter.count(tc.id);
+                    t += this.tokenCounter.count(tc.function.name);
+                    t += this.tokenCounter.count(tc.function.arguments);
+                    t += 4;
+                }
+            }
+            return t;
+        }
+        let t = Math.ceil(text.length / 2);
+        if (Array.isArray(m.content)) {
+            for (const part of m.content) {
+                if (part.type === "image_url" && part.image_url?.url) {
+                    const b64Len = part.image_url.url.includes(",")
+                        ? part.image_url.url.split(",")[1]?.length ?? 0
+                        : part.image_url.url.length;
+                    t += Math.ceil(b64Len / 512) * 130;
+                }
+            }
+        }
+        if (m.tool_calls) {
+            for (const tc of m.tool_calls) {
+                t += Math.ceil(tc.id.length / 2);
+                t += Math.ceil(tc.function.name.length / 2);
+                t += Math.ceil(tc.function.arguments.length / 2);
+                t += 4;
+            }
+        }
+        return t;
+    }
+    needsCompaction() {
+        if (this.iterationsSinceCompaction >= COMPACTION_INTERVAL)
+            return true;
+        const totalTokens = this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0);
+        return totalTokens > this.budget.history * this.compactionThreshold;
+    }
+    compact() {
+        if (this.messages.length <= KEEP_LAST_N * 2)
+            return;
+        const cutoff = this.messages.length - KEEP_LAST_N * 2;
+        const oldTurns = this.messages.slice(0, cutoff);
+        const recentTurns = this.messages.slice(cutoff);
+        this.extractFacts(oldTurns);
+        const parts = [];
+        parts.push(`[Compressed: ${oldTurns.length} old turns removed]`);
+        if (this.fileFacts.length > 0) {
+            parts.push(`[Files: ${this.fileFacts.slice(-15).join("; ")}]`);
+        }
+        if (this.decisionFacts.length > 0) {
+            parts.push(`[Decisions: ${this.decisionFacts.slice(-5).join("; ")}]`);
+        }
+        if (this.errorFacts.length > 0) {
+            parts.push(`[Errors: ${this.errorFacts.slice(-3).join("; ")}]`);
+        }
+        this.compactedBlock = parts.join(" ");
+        const summary = {
+            role: "user",
+            content: `<system-summary>${this.compactedBlock}</system-summary>`,
+        };
+        const firstSystem = this.messages.find((m) => m.role === "system");
+        this.messages = [
+            ...(firstSystem ? [firstSystem] : []),
+            summary,
+            ...recentTurns,
+        ];
+        this.iterationsSinceCompaction = 0;
+        if (this.onCompact) {
+            this.onCompact(summary);
+        }
+    }
+    extractFacts(turns) {
+        const filePatterns = [
+            /(?:Created|Updated|Written|Deleted|Moved) ([\w./\\-]+\.[a-z]+)/gi,
+            /Файл (?:создан|обновлён|записан|удалён|перемещён):? ([\w./\\-]+\.[a-z]+)/gi,
+            /file (?:created|updated|written|deleted|moved):? ([\w./\\-]+\.[a-z]+)/gi,
+        ];
+        for (const msg of turns) {
+            const content = getMessageText(msg.content);
+            if (msg.role === "tool") {
+                for (const pattern of filePatterns) {
+                    for (const match of content.matchAll(pattern)) {
+                        this.fileFacts.push(match[1]);
+                    }
+                }
+                if (content.includes("Plan:") && content.includes("[")) {
+                    const planLine = content
+                        .split("\n")
+                        .find((line) => line.includes("Plan:"));
+                    if (planLine)
+                        this.decisionFacts.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)
+                        this.decisionFacts.push(line.trim().slice(0, 200));
+                }
+            }
+            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)
+                    this.errorFacts.push(line.trim().slice(0, 250));
+            }
+        }
+    }
+    /**
+     * Replace the system prompt in place (keeps it first) or prepend a new one.
+     * Used to refresh dynamic prompt blocks (e.g. the plan checklist) mid-run.
+     */
+    updateSystemPrompt(content) {
+        const idx = this.messages.findIndex((m) => m.role === "system");
+        if (idx >= 0) {
+            this.messages[idx] = { ...this.messages[idx], content };
+        }
+        else {
+            this.messages.unshift({ role: "system", content });
+        }
+    }
+    getActiveHistory() {
+        return [...this.messages];
+    }
+    clear() {
+        this.messages = [];
+        this.compactedBlock = null;
+        this.iterationsSinceCompaction = 0;
+    }
+    getEstimatedTokens() {
+        return this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0);
+    }
+}

package/dist/modules/execution/auditor.js

@@ -0,0 +1,72 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { resolve, join } from 'path';
+import { t } from '../../i18n/index';
+export class Auditor {
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    async audit(plan) {
+        const allStepText = plan.steps.map(s => s.description).join(' ');
+        const fileMatches = allStepText.match(/\b[\w./-]+\.[a-z]+/gi) || [];
+        const uniqueFiles = [...new Set(fileMatches)];
+        const missingFiles = [];
+        const existingFiles = [];
+        for (const filePath of uniqueFiles) {
+            const resolved = resolve(this.baseDir, filePath);
+            if (existsSync(resolved)) {
+                existingFiles.push(filePath);
+            }
+            else {
+                missingFiles.push(filePath);
+            }
+        }
+        const doneSteps = plan.steps.filter(s => s.status === 'done').length;
+        const totalSteps = plan.steps.length;
+        const typeCheckError = await this.runProjectTypeCheck();
+        const passed = missingFiles.length === 0 && !typeCheckError;
+        let summary;
+        if (passed) {
+            summary = t('exec.audit_pass', { done: doneSteps, total: totalSteps, files: existingFiles.length });
+        }
+        else {
+            const missingCount = missingFiles.length;
+            if (typeCheckError) {
+                summary = t('exec.audit_fail_typecheck', { done: doneSteps, total: totalSteps, missing: missingCount, typeError: typeCheckError });
+            }
+            else {
+                summary = t('exec.audit_fail', { done: doneSteps, total: totalSteps, files: missingCount });
+            }
+        }
+        return {
+            passed,
+            missingFiles,
+            createdFiles: existingFiles,
+            modifiedFiles: [],
+            summary,
+            typeCheckError,
+        };
+    }
+    async runProjectTypeCheck() {
+        const tsconfigPath = join(this.baseDir, 'tsconfig.json');
+        if (!existsSync(tsconfigPath)) {
+            return null;
+        }
+        try {
+            execSync(`npx tsc --noEmit --skipLibCheck`, { cwd: this.baseDir, stdio: 'pipe', timeout: 30000 });
+            return null;
+        }
+        catch (err) {
+            if (err.status === 127 || err.message.includes('not found') || err.message.includes('ENOENT')) {
+                return null;
+            }
+            const stderr = err.stderr?.toString() || err.stdout?.toString() || '';
+            if (stderr.includes('error TS')) {
+                const firstError = stderr.split('\n').find((line) => line.includes('error TS')) || 'TypeScript type error';
+                return firstError.trim();
+            }
+            return null;
+        }
+    }
+}

package/dist/modules/execution/index.js

@@ -0,0 +1,6 @@
+export { ExecutionModule } from './module';
+export { PlanCreator } from './planner';
+export { PlanTracker } from './tracker';
+export { StepVerifier } from './verifier';
+export { StuckDetector } from './stuck-detector';
+export { Auditor } from './auditor';

package/dist/modules/execution/module.js

@@ -0,0 +1,337 @@
+import { t } from "../../i18n/index";
+import { PlanCreator } from "./planner";
+import { PlanTracker } from "./tracker";
+import { StepVerifier } from "./verifier";
+import { StuckDetector } from "./stuck-detector";
+import { Auditor } from "./auditor";
+import { existsSync } from "fs";
+import { resolve } from "path";
+const STUCK_RECOVERY_COOLDOWN = 5;
+export class ExecutionModule {
+    name = "execution";
+    tracker = null;
+    verifier;
+    stuckDetector;
+    auditor;
+    baseDir;
+    lastRecoveryIteration = -STUCK_RECOVERY_COOLDOWN;
+    constructor(baseDir, stuckThreshold = 8) {
+        this.baseDir = baseDir;
+        this.verifier = new StepVerifier(baseDir);
+        this.stuckDetector = new StuckDetector(stuckThreshold);
+        this.auditor = new Auditor(baseDir);
+    }
+    setPlan(plan) {
+        this.tracker = new PlanTracker(plan);
+    }
+    getTracker() {
+        return this.tracker;
+    }
+    getStuckDetector() {
+        return this.stuckDetector;
+    }
+    /**
+     * Final audit before the agent may declare the task done. Returns null when
+     * no plan is active; otherwise checks plan completion + artifact existence.
+     */
+    async runFinalAudit() {
+        if (!this.tracker)
+            return null;
+        const plan = this.tracker.getPlan();
+        const audit = await this.auditor.audit(plan);
+        const pendingSteps = plan.steps
+            .filter((s) => s.status !== "done" && s.status !== "skipped")
+            .map((s) => `${s.id}. ${s.description}`);
+        const done = plan.steps.filter((s) => s.status === "done").length;
+        const passed = audit.passed && pendingSteps.length === 0;
+        return {
+            passed,
+            done,
+            total: plan.steps.length,
+            pendingSteps,
+            missingFiles: audit.missingFiles,
+            summary: audit.summary,
+        };
+    }
+    getSystemPromptBlock() {
+        if (!this.tracker)
+            return null;
+        return {
+            content: this.tracker.toPromptBlock(),
+            priority: "critical",
+            essential: true,
+            estimatedTokens: 200,
+        };
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: "plan",
+                description: 'Create, update, show, or abort a multi-step plan. Use "create" at the start of complex tasks. Use "update" after completing each step to track progress. Use "show" to re-print the current plan checklist.',
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: {
+                            type: "string",
+                            enum: ["create", "update", "show", "abort"],
+                        },
+                        title: { type: "string" },
+                        steps: { type: "array", items: { type: "string" } },
+                        step: { type: "number" },
+                        status: { type: "string", enum: ["done", "failed", "skipped"] },
+                        note: { type: "string" },
+                    },
+                    required: ["action"],
+                },
+                handler: async (_ctx, args) => {
+                    const action = String(args.action);
+                    if (action === "create") {
+                        const title = String(args.title || "Task Plan");
+                        const steps = Array.isArray(args.steps)
+                            ? args.steps.map(String)
+                            : [];
+                        if (steps.length === 0) {
+                            return { success: false, output: t("plan.no_steps") };
+                        }
+                        const plan = PlanCreator.createPlan(title, steps);
+                        this.setPlan(plan);
+                        const display = PlanCreator.toPromptBlock(plan, 0);
+                        return {
+                            success: true,
+                            output: t("plan.created", { title, steps: String(steps.length) }),
+                            display,
+                        };
+                    }
+                    if (action === "show") {
+                        if (!this.tracker) {
+                            return { success: false, output: t("plan.no_active") };
+                        }
+                        const display = this.tracker.toPromptBlock();
+                        return {
+                            success: true,
+                            output: `${t("plan.show_header")}\n${display}`,
+                            display,
+                        };
+                    }
+                    if (action === "update" && args.step && this.tracker) {
+                        this.tracker.updateStepStatus(Number(args.step), args.status || "done");
+                        if (args.note)
+                            this.tracker.addNote(Number(args.step), String(args.note));
+                        const progress = this.tracker.getProgressString();
+                        const display = this.tracker.toPromptBlock();
+                        return {
+                            success: true,
+                            output: `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })}\n${progress}`,
+                            display,
+                        };
+                    }
+                    if (action === "abort") {
+                        this.tracker = null;
+                        return { success: true, output: t("plan.aborted") };
+                    }
+                    if (!this.tracker) {
+                        return { success: false, output: t("plan.no_active") };
+                    }
+                    return {
+                        success: false,
+                        output: t("plan.unknown_action", { action }),
+                    };
+                },
+            },
+            {
+                name: "todo",
+                description: "Manage sub-tasks within current plan step. Use to break down complex steps into smaller tasks.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["add", "done", "list"] },
+                        items: { type: "array", items: { type: "string" } },
+                    },
+                    required: ["action"],
+                },
+                handler: async (_ctx, args) => {
+                    if (!this.tracker) {
+                        return { success: false, output: t("plan.no_active") };
+                    }
+                    const action = String(args.action);
+                    const currentStep = this.tracker.getCurrentStep();
+                    if (!currentStep) {
+                        return { success: false, output: t("plan.step_not_found") };
+                    }
+                    if (action === "add" && Array.isArray(args.items)) {
+                        const items = args.items.map(String);
+                        currentStep.note = currentStep.note
+                            ? `${currentStep.note}; ${items.join(", ")}`
+                            : items.join(", ");
+                        return {
+                            success: true,
+                            output: t("todo.added", {
+                                count: String(items.length),
+                                items: items.join(", "),
+                            }),
+                        };
+                    }
+                    if (action === "done") {
+                        return {
+                            success: true,
+                            output: t("todo.marked_done", { count: "1" }),
+                        };
+                    }
+                    if (action === "list") {
+                        const note = currentStep.note || "(no sub-tasks)";
+                        return {
+                            success: true,
+                            output: `Step ${currentStep.id}: ${currentStep.description}\nSub-tasks: ${note}`,
+                        };
+                    }
+                    return {
+                        success: false,
+                        output: t("todo.unknown_action", { action }),
+                    };
+                },
+            },
+            {
+                name: "verify",
+                description: "Run verification for the current step. Checks files mentioned in the step description.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        step: { type: "number", description: "Step number to verify" },
+                    },
+                },
+                handler: async (_ctx, args) => {
+                    if (!this.tracker)
+                        return { success: false, output: t("plan.no_active") };
+                    const step = args.step
+                        ? this.tracker.getStep(Number(args.step))
+                        : this.tracker.getCurrentStep();
+                    if (!step)
+                        return { success: false, output: t("plan.step_not_found") };
+                    const result = await this.verifier.verifyStep(step.description);
+                    return {
+                        success: result.passed,
+                        output: result.passed
+                            ? t("verify.passed")
+                            : t("verify.failed", {
+                                details: result.failed.map((f) => f.message).join("; "),
+                            }),
+                    };
+                },
+            },
+        ];
+    }
+    getPlugin() {
+        return {
+            name: "execution",
+            onBeforeThink: (ctx) => {
+                const step = this.tracker?.getCurrentStep();
+                if (this.tracker && step) {
+                    this.stuckDetector.setCurrentStep(step.id, step.description);
+                    this.stuckDetector.recordIteration(step.id);
+                }
+                else {
+                    this.stuckDetector.reset();
+                }
+                const stuckReason = this.stuckDetector.getStuckReason();
+                if (stuckReason) {
+                    ctx.logger?.warn(stuckReason);
+                }
+                if (this.stuckDetector.isStuck() ||
+                    this.stuckDetector.hasRepetitiveToolCalls()) {
+                    const currentIter = typeof ctx.iteration === "number" ? ctx.iteration : 0;
+                    if (currentIter - this.lastRecoveryIteration >=
+                        STUCK_RECOVERY_COOLDOWN) {
+                        const recovery = this.stuckDetector.getRecoveryMessage();
+                        if (recovery && ctx.contextManager) {
+                            ctx.contextManager.addMessage({
+                                role: "user",
+                                content: `<system-summary>${recovery}</system-summary>`,
+                            });
+                        }
+                        this.lastRecoveryIteration = currentIter;
+                    }
+                }
+            },
+            onBeforeTool: (ctx, call) => {
+                const warning = this.checkPlanAlignment(call);
+                if (warning && ctx.contextManager) {
+                    ctx.contextManager.addMessage({
+                        role: "user",
+                        content: `<system-summary>${warning}</system-summary>`,
+                    });
+                }
+                return true;
+            },
+            onToolCall: (ctx) => {
+                const toolName = ctx?.toolName;
+                const args = ctx?.args;
+                if (toolName && args) {
+                    this.stuckDetector.recordToolCall(toolName, args);
+                }
+            },
+            onAfterTool: (ctx, call, result) => {
+                if (!result.success) {
+                    this.stuckDetector.recordToolError(call.name);
+                }
+                else {
+                    this.stuckDetector.recordToolSuccess();
+                }
+                if (this.tracker &&
+                    result.success &&
+                    (call.name === "write_file" || call.name === "edit_file")) {
+                    this.advancePlanIfStepComplete();
+                }
+            },
+        };
+    }
+    checkPlanAlignment(call) {
+        if (!this.tracker)
+            return null;
+        const step = this.tracker.getCurrentStep();
+        if (!step)
+            return null;
+        const allowedAlways = [
+            "plan",
+            "todo",
+            "verify",
+            "list_dir",
+            "read_file",
+            "glob",
+            "grep",
+            "file_info",
+            "load_skill",
+            "question",
+            "approve",
+        ];
+        if (allowedAlways.includes(call.name))
+            return null;
+        const stepPaths = (step.description.match(/\b[\w./\\-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
+        if (stepPaths.length === 0)
+            return null;
+        const argStr = JSON.stringify(call.arguments).toLowerCase();
+        const callPaths = (argStr.match(/\b[\w./\\-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
+        if (callPaths.length === 0)
+            return null;
+        const offPath = callPaths.some((p) => !stepPaths.some((s) => p.includes(s) || s.includes(p)));
+        if (!offPath)
+            return null;
+        return t("exec.plan_warning", {
+            step: String(step.id),
+            description: step.description,
+            tool: call.name,
+        });
+    }
+    advancePlanIfStepComplete() {
+        const step = this.tracker?.getCurrentStep();
+        if (!step)
+            return;
+        const stepPaths = step.description.match(/\b[\w./\\-]+\.[a-z]+/gi) || [];
+        if (stepPaths.length === 0)
+            return;
+        const allExist = stepPaths.every((p) => existsSync(resolve(this.baseDir, p)));
+        if (allExist) {
+            this.tracker?.updateStepStatus(step.id, "done");
+            this.tracker?.advance();
+        }
+    }
+}