micro-models-agent 0.28.9 → 0.28.17

package/dist/modules/session/store.js

@@ -0,0 +1,228 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, appendFileSync, } from "fs";
+import { join } from "path";
+import { gzipSync } from "zlib";
+import { SessionFileEncryptor } from "../security/session-encryption";
+export class SessionStore {
+    baseDir;
+    encryptor = null;
+    // In-memory meta cache to avoid O(N²) disk reads on appendMessage.
+    _metaCache = new Map();
+    constructor(baseDir, encryptionConfig) {
+        this.baseDir = baseDir;
+        if (encryptionConfig?.enabled) {
+            this.encryptor = new SessionFileEncryptor(encryptionConfig);
+        }
+    }
+    getSessionDir(id) {
+        return join(this.baseDir, id);
+    }
+    /**
+     * Update encryption configuration
+     */
+    updateEncryption(config) {
+        if (config?.enabled) {
+            this.encryptor = new SessionFileEncryptor(config);
+        }
+        else {
+            this.encryptor = null;
+        }
+    }
+    /**
+     * Check if encryption is enabled
+     */
+    isEncryptionEnabled() {
+        return this.encryptor?.isEnabled() ?? false;
+    }
+    init() {
+        mkdirSync(this.baseDir, { recursive: true });
+    }
+    sessionDir(id) {
+        return join(this.baseDir, id);
+    }
+    metaPath(id) {
+        return join(this.sessionDir(id), "meta.json");
+    }
+    historyPath(id) {
+        return join(this.sessionDir(id), "history.jsonl");
+    }
+    sessionLogPath(id) {
+        return join(this.sessionDir(id), "session.jsonl");
+    }
+    sessionExists(id) {
+        return existsSync(this.metaPath(id));
+    }
+    saveMeta(id, meta) {
+        this._metaCache.set(id, meta);
+        const dir = this.sessionDir(id);
+        mkdirSync(dir, { recursive: true });
+        const content = JSON.stringify(meta, null, 2);
+        if (this.encryptor) {
+            writeFileSync(this.metaPath(id), this.encryptor.encryptFileContent(content), "utf-8");
+        }
+        else {
+            writeFileSync(this.metaPath(id), content, "utf-8");
+        }
+    }
+    loadMeta(id) {
+        const cached = this._metaCache.get(id);
+        if (cached)
+            return cached;
+        const path = this.metaPath(id);
+        if (!existsSync(path))
+            return null;
+        try {
+            const raw = readFileSync(path, "utf-8");
+            const content = this.encryptor
+                ? this.encryptor.decryptFileContent(raw)
+                : raw;
+            const meta = JSON.parse(content);
+            this._metaCache.set(id, meta);
+            return meta;
+        }
+        catch {
+            return null;
+        }
+    }
+    appendMessage(id, msg) {
+        const dir = this.sessionDir(id);
+        mkdirSync(dir, { recursive: true });
+        const line = JSON.stringify(msg);
+        if (this.encryptor?.isEnabled()) {
+            appendFileSync(this.historyPath(id), this.encryptor.encryptFileContent(line) + "\n", "utf-8");
+        }
+        else {
+            appendFileSync(this.historyPath(id), line + "\n", "utf-8");
+        }
+        const meta = this.loadMeta(id);
+        if (meta) {
+            meta.messageCount = (meta.messageCount || 0) + 1;
+            meta.updatedAt = msg.timestamp || new Date().toISOString();
+            this.saveMeta(id, meta);
+        }
+    }
+    loadHistory(id) {
+        const path = this.historyPath(id);
+        if (!existsSync(path))
+            return [];
+        try {
+            const raw = readFileSync(path, "utf-8");
+            const lines = raw.split("\n").filter(Boolean);
+            const parseLine = (line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            };
+            if (this.encryptor?.isEnabled()) {
+                return lines
+                    .map((line) => {
+                    try {
+                        return this.encryptor.decryptFileContent(line);
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter((l) => l !== null)
+                    .map(parseLine)
+                    .filter((m) => m !== null);
+            }
+            return lines
+                .map(parseLine)
+                .filter((m) => m !== null);
+        }
+        catch {
+            return [];
+        }
+    }
+    appendSessionLog(id, entry) {
+        const dir = this.sessionDir(id);
+        mkdirSync(dir, { recursive: true });
+        const line = JSON.stringify(entry);
+        if (this.encryptor?.isEnabled()) {
+            appendFileSync(this.sessionLogPath(id), this.encryptor.encryptFileContent(line) + "\n", "utf-8");
+        }
+        else {
+            appendFileSync(this.sessionLogPath(id), line + "\n", "utf-8");
+        }
+    }
+    loadSessionLog(id) {
+        const path = this.sessionLogPath(id);
+        if (!existsSync(path))
+            return [];
+        try {
+            const raw = readFileSync(path, "utf-8");
+            const lines = raw.split("\n").filter(Boolean);
+            const parseLine = (line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            };
+            if (this.encryptor?.isEnabled()) {
+                return lines
+                    .map((line) => {
+                    try {
+                        return this.encryptor.decryptFileContent(line);
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter((l) => l !== null)
+                    .map(parseLine)
+                    .filter((e) => e !== null);
+            }
+            return lines
+                .map(parseLine)
+                .filter((e) => e !== null);
+        }
+        catch {
+            return [];
+        }
+    }
+    listSessions() {
+        if (!existsSync(this.baseDir))
+            return [];
+        const entries = readdirSync(this.baseDir, { withFileTypes: true });
+        const sessions = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const meta = this.loadMeta(entry.name);
+                if (meta)
+                    sessions.push(meta);
+            }
+        }
+        sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        return sessions;
+    }
+    deleteSession(id) {
+        this._metaCache.delete(id);
+        const dir = this.sessionDir(id);
+        if (existsSync(dir)) {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    }
+    rotateOldSessions() {
+        const thirtyDaysAgo = new Date();
+        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+        const sessions = this.listSessions();
+        for (const session of sessions) {
+            const updatedAt = new Date(session.updatedAt);
+            if (updatedAt < thirtyDaysAgo) {
+                const historyPath = this.historyPath(session.id);
+                if (existsSync(historyPath)) {
+                    const content = readFileSync(historyPath, "utf-8");
+                    const compressed = gzipSync(content);
+                    const gzPath = join(this.baseDir, `${session.id}.jsonl.gz`);
+                    writeFileSync(gzPath, compressed);
+                    rmSync(historyPath);
+                }
+            }
+        }
+    }
+}

package/dist/modules/session/types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/skills/index.js

@@ -0,0 +1,2 @@
+export { SkillsLoader } from "./loader";
+export { SkillsModule } from "./module";

package/dist/modules/skills/loader.js

@@ -0,0 +1,72 @@
+import { readdirSync, readFileSync, existsSync, statSync } from "fs";
+import { join } from "path";
+export class SkillsLoader {
+    loadFromDir(dirPath) {
+        if (!existsSync(dirPath))
+            return [];
+        const skills = [];
+        this.scanDir(dirPath, skills);
+        return skills;
+    }
+    scanDir(dirPath, skills) {
+        const entries = readdirSync(dirPath);
+        for (const entry of entries) {
+            const fullPath = join(dirPath, entry);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                this.scanDir(fullPath, skills);
+                continue;
+            }
+            if (!entry.endsWith(".md") && !entry.endsWith(".skill.md"))
+                continue;
+            const content = readFileSync(fullPath, "utf-8");
+            const parsed = this.parseSkillFile(content, fullPath);
+            if (parsed)
+                skills.push(parsed);
+        }
+    }
+    parseSkillFile(content, sourcePath) {
+        const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        if (!match)
+            return null;
+        const frontmatter = this.parseFrontmatter(match[1]);
+        if (!frontmatter.name)
+            return null;
+        if (frontmatter.mma_version && String(frontmatter.mma_version) !== "2") {
+            return null;
+        }
+        return {
+            name: frontmatter.name,
+            description: frontmatter.description || "",
+            keywords: frontmatter.keywords || [],
+            content: match[2].trim(),
+            sourcePath,
+        };
+    }
+    parseFrontmatter(yaml) {
+        const result = {};
+        for (const line of yaml.split("\n")) {
+            const kvMatch = line.match(/^(\w+):\s*(.+)$/);
+            if (kvMatch) {
+                const val = kvMatch[2].trim();
+                if (val.startsWith("[") && val.endsWith("]")) {
+                    result[kvMatch[1]] = val
+                        .slice(1, -1)
+                        .split(",")
+                        .map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+                }
+                else {
+                    result[kvMatch[1]] = val.replace(/^['"]|['"]$/g, "");
+                }
+            }
+        }
+        return result;
+    }
+    loadFromAllSources(builtinDir, globalDir, projectDir) {
+        return [
+            ...this.loadFromDir(builtinDir),
+            ...this.loadFromDir(globalDir),
+            ...this.loadFromDir(projectDir),
+        ];
+    }
+}

package/dist/modules/skills/module.js

@@ -0,0 +1,130 @@
+import { t } from "../../i18n/index";
+export class SkillsModule {
+    name = "skills";
+    availableSkills;
+    loadedSkills = new Map();
+    budget;
+    currentTokens = 0;
+    constructor(availableSkills, budget) {
+        this.availableSkills = availableSkills;
+        this.budget = budget;
+    }
+    loadByName(name) {
+        if (this.loadedSkills.has(name)) {
+            return { success: false, message: t("skill.already_loaded", { name }) };
+        }
+        const skill = this.availableSkills.find((s) => s.name === name);
+        if (!skill) {
+            return { success: false, message: t("skill.not_found", { name }) };
+        }
+        return this.tryLoad(skill);
+    }
+    unload(name) {
+        const skill = this.loadedSkills.get(name);
+        if (!skill)
+            return false;
+        this.loadedSkills.delete(name);
+        this.currentTokens -= this.estimateTokens(skill.content);
+        return true;
+    }
+    getLoaded() {
+        return Array.from(this.loadedSkills.values());
+    }
+    getAvailable() {
+        return this.availableSkills;
+    }
+    findByName(name) {
+        return this.availableSkills.find((s) => s.name === name);
+    }
+    search(query) {
+        const q = query.toLowerCase();
+        return this.availableSkills.filter((s) => s.name.toLowerCase().includes(q) ||
+            s.description.toLowerCase().includes(q));
+    }
+    getBudget() {
+        return {
+            used: this.currentTokens,
+            total: this.budget,
+            remaining: this.budget - this.currentTokens,
+        };
+    }
+    getSkillContent(name) {
+        const skill = this.loadedSkills.get(name);
+        return skill ? skill.content : null;
+    }
+    getSystemPromptBlock() {
+        const lines = [];
+        if (this.availableSkills.length > 0) {
+            lines.push("[Available Skills]");
+            lines.push(t("skill.prompt_hint"));
+            for (const skill of this.availableSkills) {
+                const desc = skill.description.slice(0, 80);
+                lines.push(`- ${skill.name}: ${desc}`);
+            }
+        }
+        if (this.loadedSkills.size > 0) {
+            lines.push("");
+            lines.push("[Loaded Skills]");
+            for (const skill of this.loadedSkills.values()) {
+                lines.push(`--- ${skill.name} (${this.estimateTokens(skill.content)} tokens) ---`);
+                lines.push(skill.content);
+                lines.push("");
+            }
+        }
+        if (lines.length === 0)
+            return null;
+        const content = lines.join("\n");
+        const tokens = this.estimateTokens(content);
+        return {
+            content,
+            priority: "high",
+            essential: false,
+            estimatedTokens: tokens,
+        };
+    }
+    getPlugin() {
+        return {
+            name: "skills",
+            onSessionStart: (_ctx) => { },
+            onBeforeThink: (_ctx) => { },
+        };
+    }
+    tryLoad(skill) {
+        const tokens = this.estimateTokens(skill.content);
+        if (tokens > this.budget) {
+            return {
+                success: false,
+                message: t("skill.too_large", {
+                    name: skill.name,
+                    tokens,
+                    budget: this.budget,
+                }),
+            };
+        }
+        if (this.currentTokens + tokens > this.budget) {
+            const remaining = this.budget - this.currentTokens;
+            return {
+                success: false,
+                message: t("skill.exceeds_budget", {
+                    name: skill.name,
+                    tokens,
+                    remaining,
+                }),
+            };
+        }
+        this.loadedSkills.set(skill.name, skill);
+        this.currentTokens += tokens;
+        return {
+            success: true,
+            message: t("skill.loaded", {
+                name: skill.name,
+                tokens,
+                remaining: this.budget - this.currentTokens,
+            }),
+            skill,
+        };
+    }
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+}

package/dist/modules/types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/updater/checker.js

@@ -0,0 +1,32 @@
+export class Updater {
+    currentVersion;
+    packageName;
+    constructor(currentVersion, packageName) {
+        this.currentVersion = currentVersion;
+        this.packageName = packageName;
+    }
+    getCurrentVersion() {
+        return this.currentVersion;
+    }
+    async check() {
+        try {
+            const response = await fetch(`https://registry.npmjs.org/${this.packageName}`, {
+                headers: { Accept: 'application/vnd.npm.install-v1+json' },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok) {
+                return { updateAvailable: false, current: this.currentVersion, error: `HTTP ${response.status}` };
+            }
+            const data = await response.json();
+            const latest = data['dist-tags']?.latest;
+            if (!latest) {
+                return { updateAvailable: false, current: this.currentVersion, error: 'No latest tag' };
+            }
+            const updateAvailable = latest !== this.currentVersion;
+            return { updateAvailable, current: this.currentVersion, latest };
+        }
+        catch (e) {
+            return { updateAvailable: false, current: this.currentVersion, error: e.message };
+        }
+    }
+}

package/dist/modules/updater/index.js

@@ -0,0 +1 @@
+export { Updater } from './checker';

package/dist/modules/user-profile/compressor.js

@@ -0,0 +1,16 @@
+export class ProfileCompressor {
+    compress(info) {
+        const parts = [
+            `OS: ${info.os}`,
+            `Shell: ${info.shell}`,
+            `Platform: ${info.platform}`,
+        ];
+        if (Object.keys(info.preferences).length > 0) {
+            const prefs = Object.entries(info.preferences)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(',');
+            parts.push(`Prefs: ${prefs}`);
+        }
+        return parts.join(', ');
+    }
+}

package/dist/modules/user-profile/index.js

@@ -0,0 +1 @@
+export { UserProfile } from './profile';

package/dist/modules/user-profile/profile.js

@@ -0,0 +1,68 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir, hostname, platform, type } from 'os';
+import { env } from 'process';
+import { ProfileCompressor } from './compressor';
+export class UserProfile {
+    profileDir;
+    info = null;
+    preferences = {};
+    constructor(profileDir) {
+        this.profileDir = profileDir;
+    }
+    collect() {
+        this.info = {
+            platform: platform(),
+            os: `${type()} ${hostname()}`,
+            hostname: hostname(),
+            shell: env.SHELL || env.ComSpec || 'unknown',
+            home: homedir(),
+            nodeVersion: process.version,
+            preferences: { ...this.preferences },
+        };
+        return this.info;
+    }
+    save() {
+        if (!existsSync(this.profileDir)) {
+            mkdirSync(this.profileDir, { recursive: true });
+        }
+        writeFileSync(join(this.profileDir, 'profile.json'), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), 'utf-8');
+    }
+    load() {
+        const path = join(this.profileDir, 'profile.json');
+        if (!existsSync(path))
+            return null;
+        try {
+            const data = JSON.parse(readFileSync(path, 'utf-8'));
+            this.info = {
+                platform: data.platform,
+                os: data.os,
+                hostname: data.hostname,
+                shell: data.shell,
+                home: data.home,
+                nodeVersion: data.nodeVersion,
+                preferences: data.preferences || {},
+            };
+            this.preferences = data.preferences || {};
+            return this.info;
+        }
+        catch {
+            return null;
+        }
+    }
+    getInfo() {
+        return this.info;
+    }
+    setPreference(key, value) {
+        this.preferences[key] = value;
+    }
+    getPreference(key) {
+        return this.preferences[key];
+    }
+    compress() {
+        if (!this.info)
+            this.collect();
+        const compressor = new ProfileCompressor();
+        return compressor.compress(this.info);
+    }
+}

package/dist/tools/approve.js

@@ -0,0 +1,32 @@
+import { t } from "../i18n/index";
+import { askChoice } from "./user-input";
+export const approveTool = {
+    name: "approve",
+    description: "Request user approval for an action. The user picks Yes or No from a menu.",
+    tags: ["core"],
+    interactive: true,
+    parameters: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                description: "Description of the action requiring approval",
+            },
+        },
+        required: ["action"],
+    },
+    handler: async (ctx, args) => {
+        if (ctx.exitOnComplete) {
+            return { success: false, output: t("tool.interactive_disabled") };
+        }
+        const action = String(args.action || "");
+        const indexes = await askChoice(t("tool.approve_prompt", { action }), [
+            { label: t("tool.approve_yes"), description: t("tool.approve_yes_desc") },
+            { label: t("tool.approve_no"), description: t("tool.approve_no_desc") },
+        ]);
+        if (indexes[0] === 0) {
+            return { success: true, output: t("tool.approved") };
+        }
+        return { success: false, output: t("tool.rejected") };
+    },
+};

package/dist/tools/attach-image.js

@@ -0,0 +1,89 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { t } from "../i18n/index";
+import { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage, bufferToDataUrl } from "../llm/image-utils";
+import { logSecurityBlock } from "../modules/security/audit-log";
+export const attachImageTool = {
+    name: "attach_image",
+    description: "Attach an image to the conversation from a file path, URL, or clipboard. The image will be included in the next message sent to the model. Supports PNG, JPEG, GIF, WebP.",
+    tags: ["vision", "image"],
+    parameters: {
+        type: "object",
+        properties: {
+            source: {
+                type: "string",
+                description: 'Image source: file path (e.g. "./screenshot.png"), URL (e.g. "https://example.com/img.png"), or "clipboard" to read from system clipboard.',
+            },
+        },
+        required: ["source"],
+    },
+    handler: async (ctx, args) => {
+        const source = String(args.source ?? "").trim();
+        if (!source) {
+            return { success: false, output: t("image.source_required") };
+        }
+        try {
+            let dataUrl;
+            if (source.toLowerCase() === "clipboard") {
+                const clipBuf = await readClipboardImage();
+                if (!clipBuf) {
+                    return {
+                        success: false,
+                        output: t("image.clipboard_empty"),
+                    };
+                }
+                const result = await bufferToDataUrl(clipBuf);
+                dataUrl = result.dataUrl;
+            }
+            else if (source.startsWith("http://") || source.startsWith("https://")) {
+                const result = await loadUrlAsDataUrl(source);
+                dataUrl = result.dataUrl;
+            }
+            else {
+                const absPath = resolve(ctx.baseDir, source);
+                if (!existsSync(absPath)) {
+                    return {
+                        success: false,
+                        output: t("image.not_found", { path: source }),
+                    };
+                }
+                // Security: check path scope
+                if (ctx.scope) {
+                    const { isPathInScope } = await import("../modules/security/path-validator");
+                    const validation = isPathInScope(ctx.baseDir, absPath, ctx.scope);
+                    if (!validation.allowed) {
+                        logSecurityBlock(ctx.sessionId, "file_read", validation.reason ?? "attach_image out of scope", absPath);
+                        return {
+                            success: false,
+                            output: t("file.path_not_allowed", { path: source }),
+                        };
+                    }
+                }
+                const result = await loadFileAsDataUrl(absPath);
+                dataUrl = result.dataUrl;
+            }
+            // Add the image as a pending content part on the context manager
+            if (!ctx.contextManager) {
+                return {
+                    success: false,
+                    output: t("image.no_context"),
+                };
+            }
+            ctx.contextManager.addPendingImage({
+                type: "image_url",
+                image_url: { url: dataUrl },
+            });
+            const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
+            return {
+                success: true,
+                output: t("image.attached", { source, size: `${sizeKb} KB` }),
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: t("image.error", { message: err.message }),
+            };
+        }
+    },
+};