overarch-linux-arm64 0.8.0

package/dist/src/tools/diff.js

@@ -0,0 +1,124 @@
+/**
+ * Lightweight, zero-dependency line-by-line unified diff generator.
+ * Follows the Ponytail principle: efficient, standard library only, edge-case correct.
+ */
+/**
+ * Computes line-by-line diff between two text strings using standard LCS algorithm.
+ */
+export function computeLineDiff(oldText, newText, contextLines = 3) {
+    // Normalize line endings
+    const oldLines = oldText === '' ? [] : oldText.replace(/\r\n/g, '\n').split('\n');
+    const newLines = newText === '' ? [] : newText.replace(/\r\n/g, '\n').split('\n');
+    if (oldText === newText) {
+        return { additions: 0, deletions: 0, unifiedDiff: '', hasChanges: false };
+    }
+    // LCS matrix for line changes (bounded to prevent huge memory usage)
+    const maxLines = 1500;
+    if (oldLines.length > maxLines || newLines.length > maxLines) {
+        // Fast path for very large files: line count comparison
+        const additions = Math.max(0, newLines.length - oldLines.length);
+        const deletions = Math.max(0, oldLines.length - newLines.length);
+        return {
+            additions,
+            deletions,
+            unifiedDiff: `@@ Large file (${oldLines.length} -> ${newLines.length} lines) @@`,
+            hasChanges: true
+        };
+    }
+    const m = oldLines.length;
+    const n = newLines.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (oldLines[i] === newLines[j]) {
+                dp[i + 1][j + 1] = dp[i][j] + 1;
+            }
+            else {
+                dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+            }
+        }
+    }
+    const edits = [];
+    let i = m;
+    let j = n;
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+            edits.unshift({ type: 'same', line: oldLines[i - 1], oldNum: i, newNum: j });
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+            edits.unshift({ type: 'add', line: newLines[j - 1], newNum: j });
+            j--;
+        }
+        else if (i > 0) {
+            edits.unshift({ type: 'del', line: oldLines[i - 1], oldNum: i });
+            i--;
+        }
+    }
+    let additions = 0;
+    let deletions = 0;
+    const diffLines = [];
+    // Group into hunks with context
+    let inHunk = false;
+    let hunkBuffer = [];
+    for (let k = 0; k < edits.length; k++) {
+        const edit = edits[k];
+        if (edit.type === 'add')
+            additions++;
+        if (edit.type === 'del')
+            deletions++;
+        if (edit.type !== 'same') {
+            if (!inHunk) {
+                // Collect preceding context
+                inHunk = true;
+                const start = Math.max(0, k - contextLines);
+                hunkBuffer = edits.slice(start, k);
+            }
+            hunkBuffer.push(edit);
+        }
+        else if (inHunk) {
+            hunkBuffer.push(edit);
+            // Check if subsequent lines have changes within context window
+            const hasUpcomingChange = edits.slice(k + 1, k + 1 + contextLines * 2).some(e => e.type !== 'same');
+            if (!hasUpcomingChange) {
+                // Flush hunk
+                const trimmedHunk = hunkBuffer.slice(0, hunkBuffer.length);
+                const firstEdit = trimmedHunk[0];
+                const oldStart = firstEdit.oldNum || 1;
+                const newStart = firstEdit.newNum || 1;
+                diffLines.push(`@@ -${oldStart} +${newStart} @@`);
+                for (const h of trimmedHunk) {
+                    if (h.type === 'same')
+                        diffLines.push(`  ${h.line}`);
+                    else if (h.type === 'add')
+                        diffLines.push(`+ ${h.line}`);
+                    else if (h.type === 'del')
+                        diffLines.push(`- ${h.line}`);
+                }
+                hunkBuffer = [];
+                inHunk = false;
+            }
+        }
+    }
+    if (inHunk && hunkBuffer.length > 0) {
+        const firstEdit = hunkBuffer[0];
+        const oldStart = firstEdit.oldNum || 1;
+        const newStart = firstEdit.newNum || 1;
+        diffLines.push(`@@ -${oldStart} +${newStart} @@`);
+        for (const h of hunkBuffer) {
+            if (h.type === 'same')
+                diffLines.push(`  ${h.line}`);
+            else if (h.type === 'add')
+                diffLines.push(`+ ${h.line}`);
+            else if (h.type === 'del')
+                diffLines.push(`- ${h.line}`);
+        }
+    }
+    return {
+        additions,
+        deletions,
+        unifiedDiff: diffLines.join('\n'),
+        hasChanges: additions > 0 || deletions > 0
+    };
+}

package/dist/src/tools/filesystem.d.ts

@@ -0,0 +1,2 @@
+import { Tool } from './types.js';
+export declare function createFilesystemTools(): Tool[];

package/dist/src/tools/filesystem.js

@@ -0,0 +1,224 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { PermissionTier } from '../config/types.js';
+import { computeLineDiff } from './diff.js';
+export function createFilesystemTools() {
+    return [
+        {
+            definition: {
+                name: 'readFile',
+                description: 'Read contents of a file, optionally with line range',
+                tier: PermissionTier.ReadOnly,
+                parameters: [
+                    { name: 'path', type: 'string', description: 'File path', required: true },
+                    { name: 'startLine', type: 'number', description: '1-indexed starting line (optional)', required: false },
+                    { name: 'endLine', type: 'number', description: '1-indexed ending line (optional)', required: false }
+                ]
+            },
+            handler: async (params) => {
+                const filePath = path.resolve(process.cwd(), String(params.path));
+                try {
+                    const stats = await fs.stat(filePath);
+                    const content = await fs.readFile(filePath, 'utf8');
+                    const startLine = params.startLine ? Math.max(1, Number(params.startLine)) : undefined;
+                    const endLine = params.endLine ? Math.max(1, Number(params.endLine)) : undefined;
+                    if (startLine !== undefined || endLine !== undefined) {
+                        const lines = content.replace(/\r\n/g, '\n').split('\n');
+                        const start = (startLine ? startLine - 1 : 0);
+                        const end = (endLine ? Math.min(lines.length, endLine) : lines.length);
+                        const sliced = lines.slice(start, end);
+                        const numbered = sliced.map((line, idx) => `${start + idx + 1} | ${line}`).join('\n');
+                        return {
+                            success: true,
+                            output: numbered,
+                            metadata: { totalLines: lines.length, startLine: start + 1, endLine: end }
+                        };
+                    }
+                    if (stats.size > 100 * 1024) {
+                        const handle = await fs.open(filePath, 'r');
+                        const buffer = Buffer.alloc(100 * 1024);
+                        await handle.read(buffer, 0, 100 * 1024, 0);
+                        await handle.close();
+                        return {
+                            success: true,
+                            output: buffer.toString('utf8') + '\n... [TRUNCATED - use startLine/endLine for specific sections]',
+                        };
+                    }
+                    return { success: true, output: content };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'writeFile',
+                description: 'Write content to a file. Generates diff if overwriting existing file.',
+                tier: PermissionTier.StateMutating,
+                parameters: [
+                    { name: 'path', type: 'string', description: 'File path', required: true },
+                    { name: 'content', type: 'string', description: 'File content', required: true }
+                ]
+            },
+            handler: async (params) => {
+                const filePath = path.resolve(process.cwd(), String(params.path));
+                const newContent = String(params.content);
+                // Checkpoint before mutating file
+                const checkpointMgr = new (await import('../tools/checkpoint.js')).CheckpointManager();
+                await checkpointMgr.create(`writeFile:${params.path}`, [filePath]);
+                try {
+                    let existingContent = '';
+                    let fileExisted = false;
+                    try {
+                        existingContent = await fs.readFile(filePath, 'utf8');
+                        fileExisted = true;
+                    }
+                    catch { }
+                    await fs.mkdir(path.dirname(filePath), { recursive: true });
+                    await fs.writeFile(filePath, newContent, 'utf8');
+                    const diffResult = computeLineDiff(existingContent, newContent);
+                    const relPath = path.relative(process.cwd(), filePath);
+                    return {
+                        success: true,
+                        output: fileExisted ? `Updated ${relPath}` : `Created ${relPath}`,
+                        metadata: {
+                            path: relPath,
+                            existed: fileExisted,
+                            additions: diffResult.additions,
+                            deletions: diffResult.deletions,
+                            diff: diffResult.unifiedDiff
+                        }
+                    };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'editFile',
+                description: 'Replace search text with replace text in a file with diff tracking',
+                tier: PermissionTier.StateMutating,
+                parameters: [
+                    { name: 'path', type: 'string', description: 'File path', required: true },
+                    { name: 'search', type: 'string', description: 'Exact string to search for', required: true },
+                    { name: 'replace', type: 'string', description: 'Exact string to replace with', required: true }
+                ]
+            },
+            handler: async (params) => {
+                const filePath = path.resolve(process.cwd(), String(params.path));
+                try {
+                    const content = await fs.readFile(filePath, 'utf8');
+                    const searchStr = String(params.search);
+                    const replaceStr = String(params.replace);
+                    let targetFound = content.includes(searchStr);
+                    let actualSearch = searchStr;
+                    // If exact match not found, check with normalized line endings
+                    if (!targetFound) {
+                        const normalizedContent = content.replace(/\r\n/g, '\n');
+                        const normalizedSearch = searchStr.replace(/\r\n/g, '\n');
+                        if (normalizedContent.includes(normalizedSearch)) {
+                            actualSearch = normalizedSearch;
+                            targetFound = true;
+                        }
+                    }
+                    if (!targetFound) {
+                        return {
+                            success: false,
+                            output: '',
+                            error: `Search string not found in ${params.path}. Use readFile to verify the exact content.`
+                        };
+                    }
+                    const newContent = content.replace(actualSearch, replaceStr);
+                    await fs.writeFile(filePath, newContent, 'utf8');
+                    const diffResult = computeLineDiff(content, newContent);
+                    const relPath = path.relative(process.cwd(), filePath);
+                    return {
+                        success: true,
+                        output: `Replaced in ${relPath}`,
+                        metadata: {
+                            path: relPath,
+                            additions: diffResult.additions,
+                            deletions: diffResult.deletions,
+                            diff: diffResult.unifiedDiff
+                        }
+                    };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'listDirectory',
+                description: 'List contents of a directory with file sizes and types',
+                tier: PermissionTier.ReadOnly,
+                parameters: [
+                    { name: 'path', type: 'string', description: 'Directory path', required: true },
+                    { name: 'recursive', type: 'boolean', description: 'Recursive listing', required: false }
+                ]
+            },
+            handler: async (params) => {
+                const dirPath = path.resolve(process.cwd(), String(params.path));
+                const recursive = !!params.recursive;
+                const results = [];
+                let count = 0;
+                const ignore = new Set(['node_modules', '.git', 'dist', 'build', '.turbo', '.next']);
+                async function walk(currentPath, depth) {
+                    if (count >= 200 || depth > 3)
+                        return;
+                    try {
+                        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+                        for (const entry of entries) {
+                            if (count >= 200)
+                                break;
+                            if (ignore.has(entry.name))
+                                continue;
+                            const fullPath = path.join(currentPath, entry.name);
+                            const relPath = path.relative(dirPath, fullPath);
+                            if (entry.isDirectory()) {
+                                results.push(`DIR  ${relPath}`);
+                                count++;
+                                if (recursive)
+                                    await walk(fullPath, depth + 1);
+                            }
+                            else if (entry.isFile()) {
+                                const stats = await fs.stat(fullPath);
+                                results.push(`FILE ${relPath} (${stats.size} bytes)`);
+                                count++;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // ignore access errors
+                    }
+                }
+                await walk(dirPath, 1);
+                return { success: true, output: results.join('\n') || 'Empty directory' };
+            }
+        },
+        {
+            definition: {
+                name: 'createDirectory',
+                description: 'Create directory recursively',
+                tier: PermissionTier.SafeMutation,
+                parameters: [
+                    { name: 'path', type: 'string', description: 'Directory path', required: true }
+                ]
+            },
+            handler: async (params) => {
+                const dirPath = path.resolve(process.cwd(), String(params.path));
+                try {
+                    await fs.mkdir(dirPath, { recursive: true });
+                    return { success: true, output: `Directory created: ${params.path}` };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        }
+    ];
+}

package/dist/src/tools/git.d.ts

@@ -0,0 +1,2 @@
+import { Tool } from './types.js';
+export declare function createGitTools(): Tool[];

package/dist/src/tools/git.js

@@ -0,0 +1,138 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { PermissionTier } from '../config/types.js';
+const execFileAsync = promisify(execFile);
+export function createGitTools() {
+    return [
+        {
+            definition: {
+                name: 'gitStatus',
+                description: 'Get git branch, modified files, and staging status',
+                tier: PermissionTier.ReadOnly,
+                parameters: []
+            },
+            handler: async () => {
+                try {
+                    const { stdout: branch } = await execFileAsync('git', ['branch', '--show-current']);
+                    const { stdout: status } = await execFileAsync('git', ['status', '--porcelain']);
+                    return {
+                        success: true,
+                        output: `Branch: ${branch.trim()}\n\nStatus:\n${status || 'Clean working tree'}`
+                    };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'gitDiff',
+                description: 'Get git diff for working tree or staged changes',
+                tier: PermissionTier.ReadOnly,
+                parameters: [
+                    { name: 'staged', type: 'boolean', description: 'Diff staged files', required: false },
+                    { name: 'path', type: 'string', description: 'Specific path to diff', required: false }
+                ]
+            },
+            handler: async (params) => {
+                try {
+                    const args = ['diff'];
+                    if (params.staged)
+                        args.push('--staged');
+                    if (params.path)
+                        args.push('--', String(params.path));
+                    const { stdout } = await execFileAsync('git', args);
+                    return { success: true, output: stdout.slice(0, 20480) || 'No diff' };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'gitLog',
+                description: 'Get git commit log history',
+                tier: PermissionTier.ReadOnly,
+                parameters: [
+                    { name: 'count', type: 'number', description: 'Number of commits to show', required: false }
+                ]
+            },
+            handler: async (params) => {
+                try {
+                    const count = params.count ? Number(params.count) : 10;
+                    const { stdout } = await execFileAsync('git', ['log', '--oneline', `-n`, String(count)]);
+                    return { success: true, output: stdout || 'No commits yet.' };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'gitBranch',
+                description: 'List branches or create a new git branch',
+                tier: PermissionTier.SafeMutation,
+                parameters: [
+                    { name: 'create', type: 'string', description: 'New branch name to create and checkout', required: false }
+                ]
+            },
+            handler: async (params) => {
+                try {
+                    if (params.create) {
+                        const branchName = String(params.create).trim();
+                        const { stdout } = await execFileAsync('git', ['checkout', '-b', branchName]);
+                        return { success: true, output: stdout || `Created and switched to branch ${branchName}` };
+                    }
+                    const { stdout } = await execFileAsync('git', ['branch', '-a']);
+                    return { success: true, output: stdout };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'gitStage',
+                description: 'Stage files for commit (git add)',
+                tier: PermissionTier.SafeMutation,
+                parameters: [
+                    { name: 'path', type: 'string', description: 'File path to stage, or "." for all', required: false }
+                ]
+            },
+            handler: async (params) => {
+                try {
+                    const target = params.path ? String(params.path) : '.';
+                    await execFileAsync('git', ['add', target]);
+                    return { success: true, output: `Staged: ${target}` };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'gitCommit',
+                description: 'Commit staged changes with a descriptive message',
+                tier: PermissionTier.StateMutating,
+                parameters: [
+                    { name: 'message', type: 'string', description: 'Commit message', required: true }
+                ]
+            },
+            handler: async (params) => {
+                try {
+                    const msg = String(params.message);
+                    const { stdout } = await execFileAsync('git', ['commit', '-m', msg]);
+                    return { success: true, output: stdout };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        }
+    ];
+}

package/dist/src/tools/markdown.d.ts

@@ -0,0 +1,33 @@
+import { ToolResult } from './types.js';
+export interface MarkdownHeading {
+    level: number;
+    text: string;
+    line: number;
+}
+export interface MarkdownStructure {
+    frontMatter?: Record<string, string>;
+    headings: MarkdownHeading[];
+    codeBlocksCount: number;
+    tablesCount: number;
+    rawContent: string;
+}
+/**
+ * Parses markdown front matter (YAML-like key: value between --- fences)
+ */
+export declare function parseFrontMatter(content: string): {
+    frontMatter?: Record<string, string>;
+    body: string;
+};
+/**
+ * Parses markdown structural elements (headings, code blocks, tables)
+ */
+export declare function inspectMarkdown(content: string): MarkdownStructure;
+/**
+ * Non-destructive markdown section patcher.
+ * Replaces ONLY the target section under a specific heading without corrupting surrounding text.
+ */
+export declare function patchMarkdownSection(filePath: string, targetHeading: string, newSectionContent: string): Promise<ToolResult>;
+/**
+ * Terminal syntax renderer for markdown text
+ */
+export declare function renderMarkdown(content: string): string;