@musashishao/folderforge 1.2.0

package/dist/tools/build-tools.js

@@ -0,0 +1,78 @@
+import { execa } from 'execa';
+import { defineTool } from './registry.js';
+import { detectCommands } from '../workspace/project-detector.js';
+import { parseErrors } from './error-parser.js';
+import { RUN_SCRIPT_OUTPUT_SCHEMA } from './output-schemas.js';
+async function runScript(ctx, key) {
+    const cmds = detectCommands(ctx.projectRoot);
+    const command = cmds.scripts[key];
+    if (!command)
+        return { ok: false, error: `No ${key} command detected for this project.` };
+    const sub = await execa(ctx.config.terminal.shell, ['-lc', command], {
+        cwd: ctx.projectRoot,
+        timeout: ctx.config.terminal.defaultTimeoutMs,
+        reject: false,
+        maxBuffer: ctx.config.terminal.maxOutputBytes * 4,
+    });
+    const max = ctx.config.terminal.maxOutputBytes;
+    const stdout = ctx.container.policy.secret.redact((sub.stdout ?? '').slice(0, max));
+    const stderr = ctx.container.policy.secret.redact((sub.stderr ?? '').slice(0, max));
+    const errors = parseErrors(stdout + '\n' + stderr);
+    return {
+        ok: sub.exitCode === 0,
+        data: { command, exitCode: sub.exitCode, stdout, stderr, errors },
+    };
+}
+export function buildTools() {
+    return [
+        defineTool({
+            name: 'project_detect_commands',
+            description: 'Detect package manager and dev/test/build/lint commands from project manifests.',
+            group: 'build',
+            mutates: false,
+            inputSchema: { type: 'object', properties: {} },
+            handler: async (_a, ctx) => ({ ok: true, data: detectCommands(ctx.projectRoot) }),
+        }),
+        defineTool({
+            name: 'run_test',
+            description: 'Run the project test suite and parse failures.',
+            group: 'build',
+            mutates: false,
+            inputSchema: { type: 'object', properties: {} },
+            outputSchema: RUN_SCRIPT_OUTPUT_SCHEMA,
+            handler: async (_a, ctx) => runScript(ctx, 'test'),
+        }),
+        defineTool({
+            name: 'run_lint',
+            description: 'Run the project linter.',
+            group: 'build',
+            mutates: false,
+            inputSchema: { type: 'object', properties: {} },
+            handler: async (_a, ctx) => runScript(ctx, 'lint'),
+        }),
+        defineTool({
+            name: 'run_typecheck',
+            description: 'Run the project type checker.',
+            group: 'build',
+            mutates: false,
+            inputSchema: { type: 'object', properties: {} },
+            handler: async (_a, ctx) => runScript(ctx, 'typecheck'),
+        }),
+        defineTool({
+            name: 'run_build',
+            description: 'Run the project build.',
+            group: 'build',
+            mutates: true,
+            inputSchema: { type: 'object', properties: {} },
+            handler: async (_a, ctx) => runScript(ctx, 'build'),
+        }),
+        defineTool({
+            name: 'parse_errors',
+            description: 'Parse a build/test output string into structured errors.',
+            group: 'build',
+            mutates: false,
+            inputSchema: { type: 'object', properties: { output: { type: 'string' } }, required: ['output'] },
+            handler: async (args) => ({ ok: true, data: { errors: parseErrors(String(args.output)) } }),
+        }),
+    ];
+}

package/dist/tools/code-tools.js

@@ -0,0 +1,250 @@
+import { readFileSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { defineTool } from './registry.js';
+import { flattenSymbols, normalizeLocation, normalizeDiagnostics, } from '../managers/lsp-manager.js';
+import { DIAGNOSTICS_OUTPUT_SCHEMA } from './output-schemas.js';
+/**
+ * Semantic code tools. Resolution order (Gap 1, hybrid):
+ *   1. Native LSP  - spawn the project's language server and speak JSON-RPC
+ *      directly (LspManager). Authoritative, no external MCP needed.
+ *   2. Serena child-MCP - if the LSP binary is unavailable but the Serena
+ *      adapter is enabled, route there.
+ *   3. Regex fallback - `search_ast` / `search_text` style structural search,
+ *      always available, lower fidelity.
+ *
+ * Each tool reports `source` in its data so callers know which backend answered.
+ */
+const SERENA_MAP = {
+    code_symbols_overview: 'get_symbols_overview',
+    code_find_symbol: 'find_symbol',
+    code_find_references: 'find_referencing_symbols',
+    code_find_definition: 'find_symbol',
+    code_find_implementations: 'find_symbol',
+    code_diagnostics: 'get_diagnostics',
+    code_replace_symbol_body: 'replace_symbol_body',
+    code_insert_before_symbol: 'insert_before_symbol',
+    code_insert_after_symbol: 'insert_after_symbol',
+    code_rename_symbol: 'rename_symbol',
+};
+async function routeToSerena(ctx, toolName, args) {
+    if (!ctx.container.adapters.isEnabled('serena'))
+        return null;
+    try {
+        const client = await ctx.container.adapters.ensure('serena');
+        const serenaTool = SERENA_MAP[toolName] ?? toolName;
+        const result = await client.callTool(serenaTool, args);
+        return { ok: true, data: { source: 'serena', result } };
+    }
+    catch (err) {
+        return { ok: false, error: `Serena call failed: ${String(err)}` };
+    }
+}
+/** Resolve a usable LSP connection for a file, or null if unavailable. */
+async function lspForFile(ctx, relativePath) {
+    const mgr = ctx.container.lsp;
+    if (!mgr?.isEnabled?.())
+        return null;
+    const def = mgr.serverForPath(relativePath);
+    if (!def)
+        return null;
+    return mgr.ensure(def, ctx.projectRoot);
+}
+/** 0-based {line, character} position from a 1-based {line, column} request. */
+function toLspPosition(args) {
+    const line = Math.max(0, Number(args.line ?? 1) - 1);
+    const character = Math.max(0, Number(args.column ?? 1) - 1);
+    return { line, character };
+}
+/**
+ * Find the first declaration line of a named symbol in a file, so callers can
+ * use the simpler `namePath` ergonomics (Serena-style) instead of supplying raw
+ * line/column. Returns a 0-based position or null.
+ */
+function locateSymbol(absPath, name) {
+    let text;
+    try {
+        text = readFileSync(absPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const leaf = name.includes('/') ? name.slice(name.lastIndexOf('/') + 1) : name;
+    const re = new RegExp(`\\b${leaf.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&')}\\b`);
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const m = re.exec(lines[i]);
+        if (m)
+            return { line: i, character: m.index };
+    }
+    return null;
+}
+function absOf(ctx, relativePath) {
+    return isAbsolute(relativePath) ? relativePath : join(ctx.projectRoot, relativePath);
+}
+/** Standard "no backend" failure when native + Serena both decline. */
+function noBackend(extra = '') {
+    return {
+        ok: false,
+        error: 'No semantic backend available. Install a language server (e.g. ' +
+            'typescript-language-server, pyright) or enable adapters.serena. ' +
+            'Fallback: use search_ast / search_text.' +
+            (extra ? ` ${extra}` : ''),
+    };
+}
+// --- handlers -------------------------------------------------------------
+async function symbolsOverview(args, ctx) {
+    const rel = String(args.relativePath ?? '');
+    if (!rel)
+        return { ok: false, error: 'relativePath is required.' };
+    const conn = await lspForFile(ctx, rel);
+    if (conn) {
+        const uri = conn.ensureOpen(rel);
+        const result = await conn.request('textDocument/documentSymbol', {
+            textDocument: { uri },
+        });
+        return { ok: true, data: { source: 'lsp', symbols: flattenSymbols(result) } };
+    }
+    const serena = await routeToSerena(ctx, 'code_symbols_overview', args);
+    return serena ?? noBackend();
+}
+async function findSymbol(args, ctx) {
+    const name = String(args.namePath ?? '');
+    if (!name)
+        return { ok: false, error: 'namePath is required.' };
+    const mgr = ctx.container.lsp;
+    if (mgr?.isEnabled?.()) {
+        // workspace/symbol needs a live server; pick any configured one we can start.
+        const def = mgr.serverForPath('x.ts') ?? mgr.serverById('typescript');
+        const conn = def ? await mgr.ensure(def, ctx.projectRoot) : null;
+        if (conn) {
+            const leaf = name.includes('/') ? name.slice(name.lastIndexOf('/') + 1) : name;
+            const result = await conn.request('workspace/symbol', { query: leaf });
+            const matches = (Array.isArray(result) ? result : [])
+                .map((s) => {
+                const x = s;
+                const loc = normalizeLocation(x.location);
+                return x.name && loc ? { name: x.name, ...loc } : null;
+            })
+                .filter(Boolean);
+            return { ok: true, data: { source: 'lsp', matches } };
+        }
+    }
+    const serena = await routeToSerena(ctx, 'code_find_symbol', args);
+    return serena ?? noBackend();
+}
+/** definition / references / implementations all share the position dance. */
+function positionalTool(lspMethod, serenaName) {
+    return async (args, ctx) => {
+        const rel = String(args.relativePath ?? args.file ?? '');
+        if (rel) {
+            const conn = await lspForFile(ctx, rel);
+            if (conn) {
+                const uri = conn.ensureOpen(rel);
+                // Allow either explicit line/column or a symbol name to locate.
+                let pos = toLspPosition(args);
+                if (args.line === undefined && args.namePath) {
+                    const found = locateSymbol(absOf(ctx, rel), String(args.namePath));
+                    if (found)
+                        pos = found;
+                }
+                const params = {
+                    textDocument: { uri },
+                    position: pos,
+                };
+                if (lspMethod === 'textDocument/references') {
+                    params.context = { includeDeclaration: true };
+                }
+                const result = await conn.request(lspMethod, params);
+                const arr = Array.isArray(result) ? result : result ? [result] : [];
+                const locations = arr.map(normalizeLocation).filter(Boolean);
+                return { ok: true, data: { source: 'lsp', locations } };
+            }
+        }
+        const serena = await routeToSerena(ctx, serenaName, args);
+        return serena ?? noBackend('This tool needs a file (relativePath) for native LSP.');
+    };
+}
+async function diagnostics(_args, ctx) {
+    const rel = String(_args.relativePath ?? '');
+    const mgr = ctx.container.lsp;
+    if (rel && mgr?.isEnabled?.()) {
+        const conn = await lspForFile(ctx, rel);
+        if (conn) {
+            const uri = conn.ensureOpen(rel);
+            // publishDiagnostics is push-based; give the server a brief moment.
+            await new Promise((r) => setTimeout(r, 400));
+            const diags = conn.diagnostics.get(uri) ?? [];
+            const normalized = normalizeDiagnostics(uri, diags);
+            return {
+                ok: true,
+                data: { source: 'lsp', diagnostics: normalized, count: normalized.length },
+            };
+        }
+    }
+    const serena = await routeToSerena(ctx, 'code_diagnostics', _args);
+    return serena ?? { ok: true, data: { source: 'none', diagnostics: [], count: 0 } };
+}
+async function mutatingSymbol(toolName, args, ctx) {
+    // Native LSP rename is supported; body insert/replace are delegated to Serena
+    // (which performs the AST edit). Native rename uses textDocument/rename.
+    if (toolName === 'code_rename_symbol') {
+        const rel = String(args.relativePath ?? args.file ?? '');
+        const newName = String(args.newName ?? '');
+        if (rel && newName) {
+            const conn = await lspForFile(ctx, rel);
+            if (conn) {
+                const uri = conn.ensureOpen(rel);
+                let pos = toLspPosition(args);
+                if (args.line === undefined && args.namePath) {
+                    const found = locateSymbol(absOf(ctx, rel), String(args.namePath));
+                    if (found)
+                        pos = found;
+                }
+                const edit = await conn.request('textDocument/rename', {
+                    textDocument: { uri },
+                    position: pos,
+                    newName,
+                });
+                return { ok: true, data: { source: 'lsp', workspaceEdit: edit } };
+            }
+        }
+    }
+    const serena = await routeToSerena(ctx, toolName, args);
+    return serena ?? noBackend('Body edits require the Serena adapter.');
+}
+// --- registration ---------------------------------------------------------
+function readTool(name, description, props, handler, outputSchema) {
+    return defineTool({
+        name,
+        description,
+        group: 'code',
+        mutates: false,
+        inputSchema: { type: 'object', properties: props },
+        ...(outputSchema ? { outputSchema } : {}),
+        handler,
+    });
+}
+function writeTool(name, description, props, handler) {
+    return defineTool({
+        name,
+        description,
+        group: 'code',
+        mutates: true,
+        inputSchema: { type: 'object', properties: props },
+        handler,
+    });
+}
+export function codeTools() {
+    return [
+        readTool('code_symbols_overview', 'List symbols declared in a file (native LSP, Serena fallback).', { relativePath: { type: 'string' } }, symbolsOverview),
+        readTool('code_find_symbol', 'Find a class/function/method/interface by name across the workspace (native LSP, Serena fallback).', { namePath: { type: 'string' } }, findSymbol),
+        readTool('code_find_references', 'Find references to a symbol at a file position or by name (native LSP, Serena fallback).', { relativePath: { type: 'string' }, namePath: { type: 'string' }, line: { type: 'number' }, column: { type: 'number' } }, positionalTool('textDocument/references', 'code_find_references')),
+        readTool('code_find_definition', 'Jump to a symbol definition at a file position or by name (native LSP, Serena fallback).', { relativePath: { type: 'string' }, namePath: { type: 'string' }, line: { type: 'number' }, column: { type: 'number' } }, positionalTool('textDocument/definition', 'code_find_definition')),
+        readTool('code_find_implementations', 'Find implementations of an interface/abstract symbol (native LSP, Serena fallback).', { relativePath: { type: 'string' }, namePath: { type: 'string' }, line: { type: 'number' }, column: { type: 'number' } }, positionalTool('textDocument/implementation', 'code_find_implementations')),
+        readTool('code_diagnostics', 'Get language-server diagnostics for a file (native LSP, Serena fallback).', { relativePath: { type: 'string' } }, diagnostics, DIAGNOSTICS_OUTPUT_SCHEMA),
+        writeTool('code_replace_symbol_body', 'Replace the body of a symbol (via Serena adapter).', { namePath: { type: 'string' }, body: { type: 'string' } }, (a, c) => mutatingSymbol('code_replace_symbol_body', a, c)),
+        writeTool('code_insert_before_symbol', 'Insert code before a symbol (via Serena adapter).', { namePath: { type: 'string' }, body: { type: 'string' } }, (a, c) => mutatingSymbol('code_insert_before_symbol', a, c)),
+        writeTool('code_insert_after_symbol', 'Insert code after a symbol (via Serena adapter).', { namePath: { type: 'string' }, body: { type: 'string' } }, (a, c) => mutatingSymbol('code_insert_after_symbol', a, c)),
+        writeTool('code_rename_symbol', 'Rename a symbol across the project (native LSP rename, Serena fallback). Returns a WorkspaceEdit.', { relativePath: { type: 'string' }, namePath: { type: 'string' }, line: { type: 'number' }, column: { type: 'number' }, newName: { type: 'string' } }, (a, c) => mutatingSymbol('code_rename_symbol', a, c)),
+    ];
+}

package/dist/tools/coverage-tools.js

@@ -0,0 +1,135 @@
+import { execa } from 'execa';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { defineTool } from './registry.js';
+import { detectProject } from '../workspace/project-detector.js';
+import { parseErrors } from './error-parser.js';
+import { COVERAGE_OUTPUT_SCHEMA } from './output-schemas.js';
+export function detectCoverageCommand(root) {
+    const proj = detectProject(root);
+    const has = (f) => existsSync(join(root, f));
+    if (proj.languageHints.includes('typescript')) {
+        const deps = readPkgDeps(root);
+        if (deps.vitest) {
+            return {
+                argv: ['npx', 'vitest', 'run', '--coverage', '--coverage.reporter=json-summary'],
+                report: { kind: 'istanbul-json', path: 'coverage/coverage-summary.json' },
+            };
+        }
+        if (deps.jest) {
+            return {
+                argv: ['npx', 'jest', '--coverage', '--coverageReporters=json-summary'],
+                report: { kind: 'istanbul-json', path: 'coverage/coverage-summary.json' },
+            };
+        }
+    }
+    if (has('pyproject.toml') || has('requirements.txt')) {
+        return {
+            argv: ['pytest', '--cov', '--cov-report=xml'],
+            report: { kind: 'cobertura-xml', path: 'coverage.xml' },
+        };
+    }
+    if (has('go.mod')) {
+        return { argv: ['go', 'test', '-cover', './...'] };
+    }
+    if (has('Cargo.toml')) {
+        return { argv: ['cargo', 'tarpaulin', '--out', 'Stdout'] };
+    }
+    return null;
+}
+function readPkgDeps(root) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+        return { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    catch {
+        return {};
+    }
+}
+/** Parse an Istanbul json-summary into a flat total-percentage object. */
+export function parseIstanbulSummary(json) {
+    try {
+        const data = JSON.parse(json);
+        const total = data.total;
+        if (!total)
+            return null;
+        const out = {};
+        for (const key of ['lines', 'statements', 'functions', 'branches']) {
+            const pct = total[key]?.pct;
+            if (typeof pct === 'number')
+                out[key] = pct;
+        }
+        return Object.keys(out).length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Parse Cobertura XML (pytest-cov) line-rate into a lines percentage. */
+export function parseCoberturaXml(xml) {
+    const m = /line-rate="([0-9.]+)"/.exec(xml);
+    if (!m)
+        return null;
+    const lines = Math.round(parseFloat(m[1]) * 1000) / 10; // one decimal place
+    const bm = /branch-rate="([0-9.]+)"/.exec(xml);
+    const out = { lines };
+    if (bm)
+        out.branches = Math.round(parseFloat(bm[1]) * 1000) / 10;
+    return out;
+}
+export function coverageTools() {
+    return [
+        defineTool({
+            name: 'run_coverage',
+            description: 'Run the test suite with coverage enabled and return a structured ' +
+                'coverage summary (lines/branches/functions %) plus parsed failures.',
+            group: 'build',
+            mutates: false,
+            inputSchema: { type: 'object', properties: {} },
+            outputSchema: COVERAGE_OUTPUT_SCHEMA,
+            handler: async (_a, ctx) => {
+                const cmd = detectCoverageCommand(ctx.projectRoot);
+                if (!cmd)
+                    return { ok: false, error: 'No coverage-capable test runner detected.' };
+                const [bin, ...rest] = cmd.argv;
+                const sub = await execa(bin, rest, {
+                    cwd: ctx.projectRoot,
+                    timeout: ctx.config.terminal.defaultTimeoutMs,
+                    reject: false,
+                    maxBuffer: ctx.config.terminal.maxOutputBytes * 4,
+                });
+                const max = ctx.config.terminal.maxOutputBytes;
+                const redact = ctx.container.policy.secret.redact;
+                const stdout = redact((sub.stdout ?? '').slice(0, max));
+                const stderr = redact((sub.stderr ?? '').slice(0, max));
+                let summary = null;
+                if (cmd.report) {
+                    const reportPath = join(ctx.projectRoot, cmd.report.path);
+                    if (existsSync(reportPath)) {
+                        try {
+                            const raw = readFileSync(reportPath, 'utf8');
+                            summary =
+                                cmd.report.kind === 'istanbul-json'
+                                    ? parseIstanbulSummary(raw)
+                                    : parseCoberturaXml(raw);
+                        }
+                        catch {
+                            summary = null;
+                        }
+                    }
+                }
+                return {
+                    ok: sub.exitCode === 0,
+                    data: {
+                        command: cmd.argv.join(' '),
+                        exitCode: sub.exitCode ?? null,
+                        summary,
+                        errors: parseErrors(`${stdout}\n${stderr}`),
+                        stdout,
+                        stderr,
+                    },
+                };
+            },
+        }),
+    ];
+}

package/dist/tools/db-tools.js

@@ -0,0 +1,130 @@
+import { defineTool } from './registry.js';
+import { DB_QUERY_OUTPUT_SCHEMA } from './output-schemas.js';
+export function dbTools() {
+    return [
+        defineTool({
+            name: 'db_connect',
+            description: 'Register a read-only dev database connection (sqlite or postgres). Production targets are refused.',
+            group: 'db',
+            mutates: true,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    kind: { type: 'string', enum: ['sqlite', 'postgres'] },
+                    target: { type: 'string', description: 'SQLite file path or Postgres connection string.' },
+                },
+                required: ['id', 'kind', 'target'],
+            },
+            handler: async (args, ctx) => {
+                try {
+                    const conn = await ctx.container.db.connect(String(args.id), args.kind, String(args.target));
+                    return { ok: true, data: conn };
+                }
+                catch (err) {
+                    return { ok: false, error: String(err) };
+                }
+            },
+        }),
+        defineTool({
+            name: 'db_list_connections',
+            description: 'List registered database connections.',
+            group: 'db',
+            mutates: false,
+            inputSchema: { type: 'object', properties: {} },
+            handler: async (_a, ctx) => ({ ok: true, data: { connections: ctx.container.db.list() } }),
+        }),
+        defineTool({
+            name: 'db_list_tables',
+            description: 'List tables in a connected database.',
+            group: 'db',
+            mutates: false,
+            inputSchema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] },
+            handler: async (args, ctx) => ({ ok: true, data: { tables: await ctx.container.db.listTables(String(args.id)) } }),
+        }),
+        defineTool({
+            name: 'db_describe_table',
+            description: 'Describe a table schema.',
+            group: 'db',
+            mutates: false,
+            inputSchema: {
+                type: 'object',
+                properties: { id: { type: 'string' }, table: { type: 'string' } },
+                required: ['id', 'table'],
+            },
+            handler: async (args, ctx) => ({
+                ok: true,
+                data: { schema: await ctx.container.db.describeTable(String(args.id), String(args.table)) },
+            }),
+        }),
+        defineTool({
+            name: 'db_query_readonly',
+            description: 'Run a read-only query (SELECT/EXPLAIN/WITH). Write queries are rejected; secret columns masked.',
+            group: 'db',
+            mutates: false,
+            inputSchema: {
+                type: 'object',
+                properties: { id: { type: 'string' }, sql: { type: 'string' }, limit: { type: 'number' } },
+                required: ['id', 'sql'],
+            },
+            outputSchema: DB_QUERY_OUTPUT_SCHEMA,
+            handler: async (args, ctx) => ({
+                ok: true,
+                data: { rows: await ctx.container.db.queryReadonly(String(args.id), String(args.sql), Number(args.limit ?? 200)) },
+            }),
+        }),
+        defineTool({
+            name: 'db_explain',
+            description: 'Explain a query plan (read-only).',
+            group: 'db',
+            mutates: false,
+            inputSchema: {
+                type: 'object',
+                properties: { id: { type: 'string' }, sql: { type: 'string' } },
+                required: ['id', 'sql'],
+            },
+            handler: async (args, ctx) => ({
+                ok: true,
+                data: { plan: await ctx.container.db.explain(String(args.id), String(args.sql)) },
+            }),
+        }),
+        defineTool({
+            name: 'db_write',
+            description: 'Execute a single write statement (INSERT/UPDATE/DELETE) on a dev connection. HIGH risk; requires approval.',
+            group: 'db',
+            mutates: true,
+            inputSchema: {
+                type: 'object',
+                properties: { id: { type: 'string' }, sql: { type: 'string' } },
+                required: ['id', 'sql'],
+            },
+            handler: async (args, ctx) => {
+                try {
+                    return { ok: true, data: await ctx.container.db.write(String(args.id), String(args.sql)) };
+                }
+                catch (err) {
+                    return { ok: false, error: String(err) };
+                }
+            },
+        }),
+        defineTool({
+            name: 'db_run_migration',
+            description: 'Run a migration script in a single transaction on a dev connection. HIGH risk; requires approval.',
+            group: 'db',
+            mutates: true,
+            inputSchema: {
+                type: 'object',
+                properties: { id: { type: 'string' }, sql: { type: 'string' } },
+                required: ['id', 'sql'],
+            },
+            handler: async (args, ctx) => {
+                try {
+                    return { ok: true, data: await ctx.container.db.runMigration(String(args.id), String(args.sql)) };
+                }
+                catch (err) {
+                    return { ok: false, error: String(err) };
+                }
+            },
+        }),
+    ];
+}

package/dist/tools/diff-util.js

@@ -0,0 +1,45 @@
+/**
+ * A compact, dependency-free line-based diff for previews (LCS).
+ */
+export function simpleDiff(before, after, label = 'file') {
+    if (before === after)
+        return `--- ${label}\n(no changes)`;
+    const a = before.split('\n');
+    const b = after.split('\n');
+    const n = a.length;
+    const m = b.length;
+    // LCS table (kept small enough for typical files)
+    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const lines = [`--- ${label} (before)`, `+++ ${label} (after)`];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            lines.push(`  ${a[i]}`);
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            lines.push(`- ${a[i]}`);
+            i++;
+        }
+        else {
+            lines.push(`+ ${b[j]}`);
+            j++;
+        }
+    }
+    while (i < n)
+        lines.push(`- ${a[i++]}`);
+    while (j < m)
+        lines.push(`+ ${b[j++]}`);
+    // Trim very large diffs.
+    if (lines.length > 400) {
+        return lines.slice(0, 400).join('\n') + `\n... (${lines.length - 400} more lines)`;
+    }
+    return lines.join('\n');
+}