micro-models-agent 0.28.0 → 0.28.2

package/dist/modules/memory/store.js

@@ -1,65 +0,0 @@
-import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { MemorySearch } from './search';
-const MEMORY_FILES = ['conventions', 'decisions', 'errors', 'facts'];
-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);
-    }
-    prefsPath() {
-        return join(this.memoryDir, 'preferences.json');
-    }
-    getPreferences() {
-        const path = this.prefsPath();
-        if (!existsSync(path))
-            return {};
-        try {
-            return JSON.parse(readFileSync(path, 'utf-8'));
-        }
-        catch {
-            return {};
-        }
-    }
-    setPreference(key, value) {
-        const prefs = this.getPreferences();
-        prefs[key] = value;
-        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), 'utf-8');
-    }
-    deletePreference(key) {
-        const prefs = this.getPreferences();
-        if (!(key in prefs))
-            return false;
-        delete prefs[key];
-        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), 'utf-8');
-        return true;
-    }
-}

package/dist/modules/pipelines/engine.js

@@ -1,60 +0,0 @@
-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

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

package/dist/modules/pipelines/parser.js

@@ -1,53 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/dist/modules/plugins/loader.js

@@ -1,28 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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

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

package/dist/modules/processes/detect.js

@@ -1,34 +0,0 @@
-/**
- * Heuristic detection of long-running (server/watch) commands.
- *
- * The explicit `background: true` bash parameter always wins; this list is a
- * convenience so dev servers don't block the agent. It only inspects the raw
- * shell command (a technical process-type decision, not task classification).
- */
-const LONG_RUNNING_PATTERNS = [
-    /\b(npm|pnpm|yarn|bun|npx)\s+(run\s+)?(dev|start|serve|preview|watch|server)\b/i,
-    /\b(deno|node)\s+.*\b(run\s+)?(dev|serve|watch|server)\b/i,
-    /(^|\s)--watch\b/i,
-    /(^|\s)-w\b/i,
-    /\bnodemon\b/i,
-    /\btsx watch\b/i,
-    /\b(ts-node|tsc)\s+.*--watch\b/i,
-    /\bvite(?!\s+(build|create))\b/i,
-    /\bwebpack(-dev-server|\s+serve)\b/i,
-    /\bastro dev\b/i,
-    /\bnext (dev|start)\b/i,
-    /\bnuxt (dev|start)\b/i,
-    /\bsvelte-kit (dev|preview)\b/i,
-    /\bgatsby develop\b/i,
-    /\bdocker(-compose)?\s+.*\bup\b/i,
-    /\buvicorn\b|\bgunicorn\b/i,
-    /\bpython\s+-m\s+http\.server\b/i,
-    /\bflask run\b/i,
-    /\bphp artisan serve\b/i,
-    /\brails (server|s)\b/i,
-    /\bvitest watch\b/i,
-    /\bjest --watch\b/i,
-];
-export function isLongRunningCommand(command) {
-    return LONG_RUNNING_PATTERNS.some((pattern) => pattern.test(command));
-}

package/dist/modules/processes/index.js

@@ -1,3 +0,0 @@
-export { runCommand, killByCallId } from "./runner";
-export { processRegistry } from "./registry";
-export { isLongRunningCommand } from "./detect";