micro-models-agent 0.7.10 → 0.8.0

package/dist/modules/memory/store.js

@@ -0,0 +1,38 @@
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { MemorySearch } from './search';
+const MEMORY_FILES = ['conventions', 'decisions', 'errors'];
+export class MemoryStore {
+    memoryDir;
+    constructor(memoryDir) {
+        this.memoryDir = memoryDir;
+        this.ensureDir();
+        for (const name of MEMORY_FILES) {
+            const path = join(this.memoryDir, `${name}.md`);
+            if (!existsSync(path)) {
+                writeFileSync(path, `# ${name.charAt(0).toUpperCase() + name.slice(1)}\n\n`, 'utf-8');
+            }
+        }
+    }
+    ensureDir() {
+        if (!existsSync(this.memoryDir)) {
+            mkdirSync(this.memoryDir, { recursive: true });
+        }
+    }
+    read(name) {
+        const path = join(this.memoryDir, `${name}.md`);
+        if (!existsSync(path))
+            return '';
+        return readFileSync(path, 'utf-8');
+    }
+    append(name, entry) {
+        const path = join(this.memoryDir, `${name}.md`);
+        const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+        const formatted = `- **${timestamp}** — ${entry}\n`;
+        appendFileSync(path, formatted, 'utf-8');
+    }
+    search(query) {
+        const searchModule = new MemorySearch(this.memoryDir);
+        return searchModule.query(query);
+    }
+}

package/dist/modules/pipelines/engine.js

@@ -0,0 +1,60 @@
+import { t } from '../../i18n/index';
+export class PipelineEngine {
+    stepStatus = new Map();
+    resolveDependencies(steps) {
+        const visited = new Set();
+        const inStack = new Set();
+        const order = [];
+        function visit(stepId, stepMap) {
+            if (inStack.has(stepId))
+                throw new Error(t('pipeline.circular', { stepId }));
+            if (visited.has(stepId))
+                return;
+            inStack.add(stepId);
+            const step = stepMap.get(stepId);
+            if (step?.depends_on) {
+                for (const dep of step.depends_on) {
+                    visit(dep, stepMap);
+                }
+            }
+            inStack.delete(stepId);
+            visited.add(stepId);
+            order.push(stepId);
+        }
+        const stepMap = new Map(steps.map(s => [s.id, s]));
+        for (const step of steps) {
+            if (!visited.has(step.id)) {
+                visit(step.id, stepMap);
+            }
+        }
+        return order;
+    }
+    getReadySteps(steps, completed) {
+        return steps.filter(s => {
+            if (completed.has(s.id))
+                return false;
+            if (this.stepStatus.get(s.id) === 'running')
+                return false;
+            if (this.stepStatus.get(s.id) === 'failed')
+                return false;
+            if (!s.depends_on || s.depends_on.length === 0)
+                return true;
+            return s.depends_on.every(d => completed.has(d));
+        });
+    }
+    setStepStatus(stepId, status) {
+        this.stepStatus.set(stepId, status);
+    }
+    getStepStatus(stepId) {
+        return this.stepStatus.get(stepId) || 'pending';
+    }
+    isComplete(stepIds) {
+        return stepIds.every(id => {
+            const s = this.stepStatus.get(id);
+            return s === 'done' || s === 'skipped';
+        });
+    }
+    reset() {
+        this.stepStatus.clear();
+    }
+}

package/dist/modules/pipelines/index.js

@@ -0,0 +1,3 @@
+export { PipelineParser } from './parser';
+export { PipelineEngine } from './engine';
+export { TemplateEngine } from './template';

package/dist/modules/pipelines/parser.js

@@ -0,0 +1,53 @@
+import { t } from '../../i18n/index';
+export class PipelineParser {
+    static parse(yaml) {
+        const lines = yaml.split('\n').filter(l => l.trim());
+        const result = {};
+        let currentSection = null;
+        let currentSteps = [];
+        for (const line of lines) {
+            if (line.match(/^\w+:/) && !line.startsWith(' ') && !line.startsWith('  -')) {
+                const [key, ...valParts] = line.split(':');
+                const val = valParts.join(':').trim();
+                if (key === 'steps') {
+                    currentSection = 'steps';
+                }
+                else {
+                    result[key] = val;
+                    currentSection = null;
+                }
+            }
+            else if (currentSection === 'steps') {
+                const stepMatch = line.match(/^\s+- id:\s*(\S+)/);
+                if (stepMatch) {
+                    currentSteps.push({ id: stepMatch[1] });
+                }
+                else if (currentSteps.length > 0) {
+                    const lastStep = currentSteps[currentSteps.length - 1];
+                    const kvMatch = line.match(/^\s+(\w+):\s*(.+)$/);
+                    if (kvMatch) {
+                        const key = kvMatch[1];
+                        let val = kvMatch[2].trim();
+                        if (val === 'true')
+                            val = true;
+                        else if (val === 'false')
+                            val = false;
+                        else if (val.startsWith('[') && val.endsWith(']')) {
+                            val = val.slice(1, -1).split(',').map((s) => s.trim().replace(/^['"]|['"]$/g, ''));
+                        }
+                        lastStep[key] = val;
+                    }
+                }
+            }
+        }
+        if (!result.name || currentSteps.length === 0) {
+            throw new Error(t('pipeline.invalid'));
+        }
+        for (const step of currentSteps) {
+            if (!step.id || !step.agent || !step.prompt) {
+                throw new Error(t('pipeline.step_missing_fields', { step: JSON.stringify(step) }));
+            }
+        }
+        return { name: result.name, steps: currentSteps };
+    }
+}

package/dist/modules/pipelines/template.js

@@ -0,0 +1,14 @@
+export class TemplateEngine {
+    static render(template, params, stepOutputs) {
+        let result = template;
+        for (const [key, val] of Object.entries(params)) {
+            result = result.replace(new RegExp(`\\{${key}\\}`, 'g'), val);
+        }
+        if (stepOutputs) {
+            result = result.replace(/\{\{steps\.(\w+)\.output\}\}/g, (_, stepId) => {
+                return stepOutputs[stepId]?.output || `{{steps.${stepId}.output}}`;
+            });
+        }
+        return result;
+    }
+}

package/dist/modules/plugins/builtin/lint-on-write.js

@@ -0,0 +1,121 @@
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { resolve, extname, join } from 'path';
+let projectTypeCheckPromise = null;
+let projectTypeCheckTimestamp = 0;
+const TYPE_CHECK_DEBOUNCE_MS = 2000;
+export class LintOnWritePlugin {
+    name = 'lint-on-write';
+    priority = 10;
+    async onAfterTool(ctx, call, result) {
+        if (call.name !== 'write_file' && call.name !== 'edit_file') {
+            return;
+        }
+        if (!result.success) {
+            return;
+        }
+        const path = String(call.arguments.path || '');
+        if (!path)
+            return;
+        const fullPath = resolve(ctx.baseDir, path);
+        if (!existsSync(fullPath))
+            return;
+        const ext = extname(fullPath);
+        const syntaxError = this.checkSyntax(fullPath, ext, ctx.baseDir);
+        if (syntaxError) {
+            result.output += `\n\n[Syntax check failed]: ${syntaxError}`;
+            return;
+        }
+        await this.runProjectLint(ctx, result);
+        await this.runProjectTypeCheck(ctx, result);
+    }
+    checkSyntax(filePath, ext, baseDir) {
+        if (ext === '.ts' || ext === '.tsx') {
+            try {
+                execSync(`npx tsc --noEmit --skipLibCheck "${filePath}"`, { cwd: baseDir, stdio: 'pipe', timeout: 10000 });
+                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 syntax error';
+                    return firstError.trim();
+                }
+                return null;
+            }
+        }
+        if (ext === '.js' || ext === '.jsx') {
+            try {
+                execSync(`node --check "${filePath}"`, { cwd: baseDir, stdio: 'pipe', timeout: 5000 });
+                return null;
+            }
+            catch (err) {
+                const stderr = err.stderr?.toString() || '';
+                const firstError = stderr.split('\n').find((line) => line.trim()) || 'JavaScript syntax error';
+                return firstError.trim();
+            }
+        }
+        return null;
+    }
+    async runProjectLint(ctx, result) {
+        try {
+            const packageJsonPath = join(ctx.baseDir, 'package.json');
+            if (!existsSync(packageJsonPath)) {
+                return;
+            }
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            const lintScript = packageJson.scripts?.lint;
+            if (!lintScript) {
+                return;
+            }
+            ctx.logger.debug(`Running lint: ${lintScript}`);
+            execSync(lintScript, { cwd: ctx.baseDir, stdio: 'pipe' });
+            ctx.logger.debug('Lint passed');
+        }
+        catch (err) {
+            ctx.logger.warn(`Lint failed: ${err.message}`);
+            result.output += `\n\n[Project lint failed]: ${err.message}`;
+        }
+    }
+    async runProjectTypeCheck(ctx, result) {
+        const tsconfigPath = join(ctx.baseDir, 'tsconfig.json');
+        if (!existsSync(tsconfigPath)) {
+            return;
+        }
+        const now = Date.now();
+        if (projectTypeCheckPromise && now - projectTypeCheckTimestamp < TYPE_CHECK_DEBOUNCE_MS) {
+            const error = await projectTypeCheckPromise;
+            if (error) {
+                result.output += `\n\n[Project typecheck failed]: ${error}`;
+            }
+            return;
+        }
+        projectTypeCheckTimestamp = now;
+        projectTypeCheckPromise = this.runTscCheck(ctx.baseDir);
+        const error = await projectTypeCheckPromise;
+        if (error) {
+            result.output += `\n\n[Project typecheck failed]: ${error}`;
+        }
+    }
+    async runTscCheck(baseDir) {
+        try {
+            execSync(`npx tsc --noEmit --skipLibCheck`, { cwd: 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;
+        }
+    }
+}
+export const plugin = new LintOnWritePlugin();

package/dist/modules/plugins/builtin/notify.js

@@ -0,0 +1,8 @@
+export class NotifyPlugin {
+    name = 'notify';
+    priority = 5;
+    onSessionEnd(ctx) {
+        ctx.logger.info('Session ended');
+    }
+}
+export const plugin = new NotifyPlugin();

package/dist/modules/plugins/index.js

@@ -0,0 +1 @@
+export { PluginManager } from './manager';

package/dist/modules/plugins/loader.js

@@ -0,0 +1,28 @@
+import { readdirSync, existsSync, statSync } from 'fs';
+import { join } from 'path';
+import { t } from '../../i18n/index';
+export class PluginLoader {
+    loadFromDir(dirPath, pluginManager, logger) {
+        if (!existsSync(dirPath))
+            return;
+        const entries = readdirSync(dirPath);
+        for (const entry of entries) {
+            const fullPath = join(dirPath, entry);
+            if (!statSync(fullPath).isFile())
+                continue;
+            if (!entry.endsWith('.ts') && !entry.endsWith('.js'))
+                continue;
+            try {
+                const mod = require(fullPath);
+                const plugin = mod.default || mod.plugin;
+                if (plugin && plugin.name) {
+                    pluginManager.register(plugin);
+                    logger?.warn(t('plugin.loaded', { name: plugin.name }));
+                }
+            }
+            catch (e) {
+                logger?.warn(t('plugin.skipped', { entry, message: e.message }));
+            }
+        }
+    }
+}

package/dist/modules/plugins/manager.js

@@ -0,0 +1,161 @@
+export class PluginManager {
+    plugins = [];
+    register(plugin) {
+        this.plugins.push(plugin);
+        this.plugins.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    }
+    getAllPlugins() {
+        return [...this.plugins];
+    }
+    runOnBuildPrompt() {
+        return this.plugins.map(p => {
+            try {
+                return p.onBuildPrompt?.() ?? null;
+            }
+            catch {
+                return null;
+            }
+        });
+    }
+    async runOnBeforeTool(ctx, call) {
+        for (const plugin of this.plugins) {
+            if (plugin.onBeforeTool) {
+                try {
+                    const result = await plugin.onBeforeTool(ctx, call);
+                    if (result === false)
+                        return false;
+                }
+                catch { /* error isolation */ }
+            }
+        }
+        return true;
+    }
+    async runOnAfterTool(ctx, call, result) {
+        for (const plugin of this.plugins) {
+            if (plugin.onAfterTool) {
+                try {
+                    await plugin.onAfterTool(ctx, call, result);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    async runOnError(ctx, error) {
+        for (const plugin of this.plugins) {
+            if (plugin.onError) {
+                try {
+                    await plugin.onError(ctx, error);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnSessionStart(ctx) {
+        for (const plugin of this.plugins) {
+            if (plugin.onSessionStart) {
+                try {
+                    plugin.onSessionStart(ctx);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnBeforeThink(ctx) {
+        for (const plugin of this.plugins) {
+            if (plugin.onBeforeThink) {
+                try {
+                    plugin.onBeforeThink(ctx);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnAfterThink(ctx, response) {
+        for (const plugin of this.plugins) {
+            if (plugin.onAfterThink) {
+                try {
+                    plugin.onAfterThink(ctx, response);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnSessionEnd(ctx) {
+        for (const plugin of this.plugins) {
+            if (plugin.onSessionEnd) {
+                try {
+                    plugin.onSessionEnd(ctx);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnToolCall(ctx) {
+        for (const plugin of this.plugins) {
+            if (plugin.onToolCall) {
+                try {
+                    plugin.onToolCall(ctx);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnPhase(ctx, phase) {
+        for (const plugin of this.plugins) {
+            if (plugin.onPhase) {
+                try {
+                    plugin.onPhase(ctx, phase);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnToolStart(ctx, call) {
+        for (const plugin of this.plugins) {
+            if (plugin.onToolStart) {
+                try {
+                    plugin.onToolStart(ctx, call);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnToolEnd(ctx, call, result, durationMs) {
+        for (const plugin of this.plugins) {
+            if (plugin.onToolEnd) {
+                try {
+                    plugin.onToolEnd(ctx, call, result, durationMs);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    /** Pipe a text chunk through plugin transforms; returns the (possibly replaced) chunk. */
+    runOnText(ctx, chunk) {
+        for (const plugin of this.plugins) {
+            if (plugin.onText) {
+                try {
+                    const out = plugin.onText(ctx, chunk);
+                    if (typeof out === 'string')
+                        chunk = out;
+                }
+                catch { /* error isolation */ }
+            }
+        }
+        return chunk;
+    }
+    /** Pipe a meta chunk through plugin transforms; returns the (possibly replaced) chunk. */
+    runOnMeta(ctx, chunk) {
+        for (const plugin of this.plugins) {
+            if (plugin.onMeta) {
+                try {
+                    const out = plugin.onMeta(ctx, chunk);
+                    if (typeof out === 'string')
+                        chunk = out;
+                }
+                catch { /* error isolation */ }
+            }
+        }
+        return chunk;
+    }
+}

package/dist/modules/plugins/types.js

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

package/dist/modules/registry.js

@@ -0,0 +1,45 @@
+export class ModuleRegistry {
+    modules = new Map();
+    register(mod) {
+        this.modules.set(mod.name, mod);
+    }
+    get(name) {
+        return this.modules.get(name);
+    }
+    listModules() {
+        return Array.from(this.modules.keys()).sort();
+    }
+    collectPromptBlocks() {
+        const blocks = [];
+        for (const mod of this.modules.values()) {
+            if (mod.getSystemPromptBlock) {
+                const block = mod.getSystemPromptBlock();
+                if (block)
+                    blocks.push(block);
+            }
+        }
+        return blocks;
+    }
+    collectToolDefinitions() {
+        const tools = [];
+        for (const mod of this.modules.values()) {
+            if (mod.getToolDefinitions) {
+                const defs = mod.getToolDefinitions();
+                if (defs)
+                    tools.push(...defs);
+            }
+        }
+        return tools;
+    }
+    collectPlugins() {
+        const plugins = [];
+        for (const mod of this.modules.values()) {
+            if (mod.getPlugin) {
+                const plugin = mod.getPlugin();
+                if (plugin)
+                    plugins.push(plugin);
+            }
+        }
+        return plugins;
+    }
+}

package/dist/modules/security/audit-log.js

@@ -0,0 +1,108 @@
+import { existsSync, mkdirSync, appendFileSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+/**
+ * Directory and file path for audit logs
+ */
+const AUDIT_LOG_DIR = resolve(homedir(), ".mma", "logs");
+const AUDIT_LOG_PATH = resolve(AUDIT_LOG_DIR, "audit.jsonl");
+/**
+ * Ensure audit log directory exists
+ */
+function ensureAuditLogDir() {
+    if (!existsSync(AUDIT_LOG_DIR)) {
+        mkdirSync(AUDIT_LOG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Write an audit log entry
+ */
+export function logAudit(entry) {
+    ensureAuditLogDir();
+    try {
+        const logEntry = JSON.stringify(entry);
+        appendFileSync(AUDIT_LOG_PATH, logEntry + "\n", "utf8");
+    }
+    catch {
+        // Silently fail if we can't write to audit log
+        // This shouldn't break the agent
+    }
+}
+/**
+ * Log a tool call
+ */
+export function logToolCall(sessionId, tool, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "tool_call",
+        tool,
+        success,
+        details,
+    });
+}
+/**
+ * Log a file write operation
+ */
+export function logFileWrite(sessionId, path, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "file_write",
+        path,
+        success,
+        details,
+    });
+}
+/**
+ * Log a file delete operation
+ */
+export function logFileDelete(sessionId, path, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "file_delete",
+        path,
+        success,
+        details,
+    });
+}
+/**
+ * Log a bash command execution
+ */
+export function logBashCommand(sessionId, command, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "bash_command",
+        command,
+        success,
+        details,
+    });
+}
+/**
+ * Log a network request
+ */
+export function logNetworkRequest(sessionId, url, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "network_request",
+        url,
+        success,
+        details,
+    });
+}
+/**
+ * Log a security block event
+ */
+export function logSecurityBlock(sessionId, action, reason, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "security_block",
+        success: false,
+        reason,
+        details,
+    });
+}