micro-models-agent 0.56.5 → 0.57.1

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/skills/builtin/git.md

@@ -1,36 +1,36 @@
----
-name: git-expert
-description: Git branching, merge conflicts, rebasing, workflow strategies
-keywords: [git, branch, merge, rebase, commit, conflict, workflow]
-mma_version: 2
----
-
-# Git Expert
-
-## Branching Strategies
-
-- **Feature branches**: `feature/xxx` from `main`, merge via PR
-- **Hotfix**: `hotfix/xxx` from `main`, merge to both `main` and `develop`
-- **Release**: `release/xxx` from `develop`, merge to `main` + `develop`
-
-## Conflict Resolution
-
-1. `git fetch origin` — get latest
-2. `git checkout your-branch`
-3. `git rebase origin/main` — apply your commits on top
-4. Resolve conflicts file by file
-5. `git add <files>` then `git rebase --continue`
-
-## Useful Commands
-
-- `git log --oneline --graph --all` — visualize history
-- `git diff --stat` — summary of changes
-- `git stash pop` — restore stashed changes
-- `git cherry-pick <commit>` — apply specific commit
-
-## Best Practices
-
-- Commit often with clear messages
-- Keep commits atomic (one logical change)
-- Never force push to shared branches
-- Use `git rebase -i` to clean up before PR
+---
+name: git-expert
+description: Git branching, merge conflicts, rebasing, workflow strategies
+keywords: [git, branch, merge, rebase, commit, conflict, workflow]
+mma_version: 2
+---
+
+# Git Expert
+
+## Branching Strategies
+
+- **Feature branches**: `feature/xxx` from `main`, merge via PR
+- **Hotfix**: `hotfix/xxx` from `main`, merge to both `main` and `develop`
+- **Release**: `release/xxx` from `develop`, merge to `main` + `develop`
+
+## Conflict Resolution
+
+1. `git fetch origin` — get latest
+2. `git checkout your-branch`
+3. `git rebase origin/main` — apply your commits on top
+4. Resolve conflicts file by file
+5. `git add <files>` then `git rebase --continue`
+
+## Useful Commands
+
+- `git log --oneline --graph --all` — visualize history
+- `git diff --stat` — summary of changes
+- `git stash pop` — restore stashed changes
+- `git cherry-pick <commit>` — apply specific commit
+
+## Best Practices
+
+- Commit often with clear messages
+- Keep commits atomic (one logical change)
+- Never force push to shared branches
+- Use `git rebase -i` to clean up before PR

package/dist/skills/builtin/typescript.md

@@ -1,35 +1,35 @@
----
-name: typescript-expert
-description: TypeScript type system, generics, advanced patterns, compiler API
-keywords: [typescript, types, generics, tsconfig, compiler, interface, type]
-mma_version: 2
----
-
-# TypeScript Expert
-
-## Key Patterns
-
-- Use `readonly` for immutable properties
-- Prefer `interface` over `type` for object shapes
-- Use `as const` for literal types
-- Prefer `unknown` over `any` for type safety
-
-## Common Pitfalls
-
-- Avoid `any` — use `unknown` + type guards
-- Don't use `enum` — use `const` objects or union types
-- Avoid `namespace` — use ES modules
-
-## Type Guards
-
-```ts
-function isString(val: unknown): val is string {
-  return typeof val === 'string'
-}
-```
-
-## Generics
-
-- Use `extends` for constraints
-- Use `infer` for conditional type extraction
-- Prefer explicit over implicit for complex cases
+---
+name: typescript-expert
+description: TypeScript type system, generics, advanced patterns, compiler API
+keywords: [typescript, types, generics, tsconfig, compiler, interface, type]
+mma_version: 2
+---
+
+# TypeScript Expert
+
+## Key Patterns
+
+- Use `readonly` for immutable properties
+- Prefer `interface` over `type` for object shapes
+- Use `as const` for literal types
+- Prefer `unknown` over `any` for type safety
+
+## Common Pitfalls
+
+- Avoid `any` — use `unknown` + type guards
+- Don't use `enum` — use `const` objects or union types
+- Avoid `namespace` — use ES modules
+
+## Type Guards
+
+```ts
+function isString(val: unknown): val is string {
+  return typeof val === 'string'
+}
+```
+
+## Generics
+
+- Use `extends` for constraints
+- Use `infer` for conditional type extraction
+- Prefer explicit over implicit for complex cases

package/dist/tools/approve.js

@@ -0,0 +1,33 @@
+import { t } from "../i18n/index";
+import { askChoice } from "./user-input";
+export const approveTool = {
+    name: "approve",
+    icon: "🙋",
+    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,101 @@
+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",
+    icon: "🖼️",
+    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://")) {
+                // Security: validate URL against the network policy (SSRF).
+                const { isUrlAllowed } = await import("../modules/security/network-validator");
+                const { getSessionSecurityConfig } = await import("../modules/security/session-isolation");
+                const networkConfig = ctx.sessionContext
+                    ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
+                    : ctx.config?.security?.network;
+                const urlCheck = isUrlAllowed(source, networkConfig);
+                if (!urlCheck.allowed) {
+                    logSecurityBlock(ctx.sessionId, "network_request", urlCheck.reason ?? "attach_image URL blocked", source);
+                    return { success: false, output: `[SECURITY BLOCKED] ${urlCheck.reason}` };
+                }
+                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 }),
+            };
+        }
+    },
+};