overarch-linux-arm64 0.8.0

package/dist/src/tools/markdown.js

@@ -0,0 +1,190 @@
+import * as fs from 'node:fs/promises';
+import { styleText } from 'node:util';
+/**
+ * Parses markdown front matter (YAML-like key: value between --- fences)
+ */
+export function parseFrontMatter(content) {
+    if (!content.startsWith('---')) {
+        return { body: content };
+    }
+    const endIdx = content.indexOf('\n---', 3);
+    if (endIdx === -1) {
+        return { body: content };
+    }
+    const fmLines = content.slice(3, endIdx).trim().split('\n');
+    const frontMatter = {};
+    for (const line of fmLines) {
+        const colon = line.indexOf(':');
+        if (colon > 0) {
+            const key = line.slice(0, colon).trim();
+            const val = line.slice(colon + 1).trim();
+            frontMatter[key] = val;
+        }
+    }
+    const body = content.slice(endIdx + 4).trimStart();
+    return { frontMatter, body };
+}
+/**
+ * Parses markdown structural elements (headings, code blocks, tables)
+ */
+export function inspectMarkdown(content) {
+    const { frontMatter } = parseFrontMatter(content);
+    const lines = content.split('\n');
+    const headings = [];
+    let inCodeBlock = false;
+    let codeBlocksCount = 0;
+    let tablesCount = 0;
+    let inTable = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim().startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            if (inCodeBlock)
+                codeBlocksCount++;
+            continue;
+        }
+        if (!inCodeBlock) {
+            const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
+            if (headingMatch) {
+                headings.push({
+                    level: headingMatch[1].length,
+                    text: headingMatch[2].trim(),
+                    line: i + 1
+                });
+            }
+            else if (line.trim().startsWith('|') && line.trim().endsWith('|')) {
+                if (!inTable) {
+                    tablesCount++;
+                    inTable = true;
+                }
+            }
+            else {
+                inTable = false;
+            }
+        }
+    }
+    return {
+        frontMatter,
+        headings,
+        codeBlocksCount,
+        tablesCount,
+        rawContent: content
+    };
+}
+/**
+ * Non-destructive markdown section patcher.
+ * Replaces ONLY the target section under a specific heading without corrupting surrounding text.
+ */
+export async function patchMarkdownSection(filePath, targetHeading, newSectionContent) {
+    let content;
+    try {
+        content = await fs.readFile(filePath, 'utf8');
+    }
+    catch (err) {
+        return { success: false, output: '', error: `Cannot read markdown file: ${err.message}` };
+    }
+    const lines = content.split('\n');
+    const targetClean = targetHeading.replace(/^#+\s*/, '').trim().toLowerCase();
+    let targetIndex = -1;
+    let targetLevel = 1;
+    let inCodeBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim().startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (!inCodeBlock) {
+            const match = line.match(/^(#{1,6})\s+(.*)$/);
+            if (match) {
+                const text = match[2].trim().toLowerCase();
+                if (text === targetClean) {
+                    targetIndex = i;
+                    targetLevel = match[1].length;
+                    break;
+                }
+            }
+        }
+    }
+    if (targetIndex === -1) {
+        return {
+            success: false,
+            output: '',
+            error: `Heading '${targetHeading}' not found in ${filePath}`
+        };
+    }
+    // Find where this section ends (next heading of <= targetLevel, or EOF)
+    let nextSectionIndex = lines.length;
+    inCodeBlock = false;
+    for (let i = targetIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim().startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (!inCodeBlock) {
+            const match = line.match(/^(#{1,6})\s+(.*)$/);
+            if (match && match[1].length <= targetLevel) {
+                nextSectionIndex = i;
+                break;
+            }
+        }
+    }
+    // Preserve the heading line itself, replace lines between targetIndex + 1 and nextSectionIndex
+    const headingLine = lines[targetIndex];
+    const before = lines.slice(0, targetIndex + 1);
+    const after = lines.slice(nextSectionIndex);
+    const cleanNewContent = newSectionContent.trim();
+    const assembled = [...before, cleanNewContent, '', ...after].join('\n');
+    try {
+        await fs.writeFile(filePath, assembled, 'utf8');
+        return {
+            success: true,
+            output: `Successfully updated section '${headingLine}' in ${filePath}`,
+            metadata: { targetHeading, modifiedLines: nextSectionIndex - targetIndex }
+        };
+    }
+    catch (err) {
+        return { success: false, output: '', error: `Failed to write file: ${err.message}` };
+    }
+}
+/**
+ * Terminal syntax renderer for markdown text
+ */
+export function renderMarkdown(content) {
+    const lines = content.split('\n');
+    const rendered = [];
+    let inCodeBlock = false;
+    for (const line of lines) {
+        if (line.trim().startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            rendered.push(styleText('dim', line));
+            continue;
+        }
+        if (inCodeBlock) {
+            rendered.push(styleText('cyan', `  ${line}`));
+            continue;
+        }
+        const h1 = line.match(/^#\s+(.*)/);
+        if (h1) {
+            rendered.push(`\n${styleText(['bold', 'underline'], h1[1])}\n`);
+            continue;
+        }
+        const h2 = line.match(/^##\s+(.*)/);
+        if (h2) {
+            rendered.push(`\n${styleText(['bold', 'cyan'], h2[1])}`);
+            continue;
+        }
+        const h3 = line.match(/^###\s+(.*)/);
+        if (h3) {
+            rendered.push(`${styleText('bold', h3[1])}`);
+            continue;
+        }
+        if (line.trim().startsWith('- ') || line.trim().startsWith('* ')) {
+            rendered.push(`  ${styleText('cyan', '•')} ${line.trim().slice(2)}`);
+            continue;
+        }
+        rendered.push(line);
+    }
+    return rendered.join('\n');
+}

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

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

package/dist/src/tools/project.js

@@ -0,0 +1,63 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { PermissionTier } from '../config/types.js';
+export function createProjectTools() {
+    return [
+        {
+            definition: {
+                name: 'inspectProject',
+                description: 'Inspect project type and details',
+                tier: PermissionTier.ReadOnly,
+                parameters: []
+            },
+            handler: async () => {
+                const cwd = process.cwd();
+                const info = { type: 'unknown' };
+                try {
+                    const pkgJson = await fs.readFile(path.join(cwd, 'package.json'), 'utf8');
+                    const pkg = JSON.parse(pkgJson);
+                    info.type = 'Node.js';
+                    info.name = pkg.name;
+                    info.scripts = pkg.scripts || {};
+                    info.dependencies = Object.keys(pkg.dependencies || {});
+                    const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+                    if (allDeps['react'])
+                        info.framework = 'React';
+                    if (allDeps['next'])
+                        info.framework = 'Next.js';
+                    if (allDeps['vue'])
+                        info.framework = 'Vue';
+                    if (allDeps['express'])
+                        info.framework = 'Express';
+                    return { success: true, output: JSON.stringify(info, null, 2) };
+                }
+                catch (e) { }
+                try {
+                    await fs.readFile(path.join(cwd, 'Cargo.toml'));
+                    info.type = 'Rust';
+                    return { success: true, output: JSON.stringify(info, null, 2) };
+                }
+                catch (e) { }
+                try {
+                    await fs.readFile(path.join(cwd, 'pyproject.toml'));
+                    info.type = 'Python';
+                    return { success: true, output: JSON.stringify(info, null, 2) };
+                }
+                catch (e) { }
+                try {
+                    await fs.readFile(path.join(cwd, 'requirements.txt'));
+                    info.type = 'Python';
+                    return { success: true, output: JSON.stringify(info, null, 2) };
+                }
+                catch (e) { }
+                try {
+                    await fs.readFile(path.join(cwd, 'go.mod'));
+                    info.type = 'Go';
+                    return { success: true, output: JSON.stringify(info, null, 2) };
+                }
+                catch (e) { }
+                return { success: true, output: JSON.stringify(info, null, 2) };
+            }
+        }
+    ];
+}

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

@@ -0,0 +1,14 @@
+import { Tool, ToolDefinition, ToolResult } from './types.js';
+export declare function createWebSearchTools(): Tool[];
+export declare function createMarkdownTools(): Tool[];
+export declare function createSymbolAndImpactTools(): Tool[];
+export declare function createCheckpointTools(): Tool[];
+export declare class ToolRegistry {
+    private tools;
+    register(tool: Tool): void;
+    get(name: string): Tool | undefined;
+    list(): ToolDefinition[];
+    execute(name: string, params: Record<string, unknown>): Promise<ToolResult>;
+    toOpenAITools(): any[];
+    static createDefault(): ToolRegistry;
+}

package/dist/src/tools/registry.js

@@ -0,0 +1,230 @@
+import * as fs from 'node:fs/promises';
+import { PermissionTier } from '../config/types.js';
+import { createFilesystemTools } from './filesystem.js';
+import { createSearchTools } from './search.js';
+import { createShellTools } from './shell.js';
+import { createGitTools } from './git.js';
+import { createProjectTools } from './project.js';
+import { createDiagnosticTools } from './diagnostics.js';
+import { inspectMarkdown, patchMarkdownSection } from './markdown.js';
+import { analyzeChangeImpact } from './symbols.js';
+import { CheckpointManager } from './checkpoint.js';
+import { mcpRegistry } from '../mcp/registry.js';
+import { searchWeb } from './web_search.js';
+export function createWebSearchTools() {
+    return [
+        {
+            definition: {
+                name: 'web_search',
+                description: 'Performs an online web search for technical documentation, error resolutions, APIs, or libraries without external dependencies.',
+                parameters: [
+                    { name: 'query', type: 'string', description: 'The search query to look up on the web', required: true },
+                    { name: 'maxResults', type: 'number', description: 'Maximum number of search results to return (default: 5)', required: false }
+                ],
+                tier: PermissionTier.ReadOnly
+            },
+            handler: async ({ query, maxResults }) => {
+                try {
+                    const res = await searchWeb(String(query), maxResults ? Number(maxResults) : 5);
+                    return {
+                        success: true,
+                        output: JSON.stringify(res, null, 2)
+                    };
+                }
+                catch (err) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `Web search failed: ${err.message}`
+                    };
+                }
+            }
+        }
+    ];
+}
+export function createMarkdownTools() {
+    return [
+        {
+            definition: {
+                name: 'markdown_inspect',
+                description: 'Parses a markdown file and returns its front matter, section heading outline, code blocks count, and tables.',
+                parameters: [
+                    { name: 'filePath', type: 'string', description: 'Path to the markdown file to inspect', required: true }
+                ],
+                tier: PermissionTier.ReadOnly
+            },
+            handler: async ({ filePath }) => {
+                try {
+                    const content = await fs.readFile(String(filePath), 'utf8');
+                    const structure = inspectMarkdown(content);
+                    return {
+                        success: true,
+                        output: JSON.stringify({
+                            frontMatter: structure.frontMatter,
+                            headings: structure.headings,
+                            codeBlocksCount: structure.codeBlocksCount,
+                            tablesCount: structure.tablesCount
+                        }, null, 2)
+                    };
+                }
+                catch (err) {
+                    return { success: false, output: '', error: err.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'markdown_patch_section',
+                description: 'Surgically replaces only the content under a specific heading in a markdown document, preserving all surrounding headings, formatting, and tables.',
+                parameters: [
+                    { name: 'filePath', type: 'string', description: 'Path to markdown file', required: true },
+                    { name: 'heading', type: 'string', description: 'Target heading to update (e.g. "Installation" or "## Overview")', required: true },
+                    { name: 'newContent', type: 'string', description: 'New content for this section', required: true }
+                ],
+                tier: PermissionTier.SafeMutation
+            },
+            handler: async ({ filePath, heading, newContent }) => {
+                return await patchMarkdownSection(String(filePath), String(heading), String(newContent));
+            }
+        }
+    ];
+}
+export function createSymbolAndImpactTools() {
+    return [
+        {
+            definition: {
+                name: 'analyze_change_impact',
+                description: 'Analyzes the blast radius of changing a file: extracts its symbols, finds referencing files, and discovers relevant test files.',
+                parameters: [
+                    { name: 'filePath', type: 'string', description: 'Relative path to the file to analyze', required: true }
+                ],
+                tier: PermissionTier.ReadOnly
+            },
+            handler: async ({ filePath }) => {
+                const impact = await analyzeChangeImpact(process.cwd(), String(filePath));
+                return {
+                    success: true,
+                    output: JSON.stringify(impact, null, 2)
+                };
+            }
+        }
+    ];
+}
+export function createCheckpointTools() {
+    const chk = new CheckpointManager();
+    return [
+        {
+            definition: {
+                name: 'create_checkpoint',
+                description: 'Creates a safe recovery checkpoint of current workspace state before risky modifications.',
+                parameters: [
+                    { name: 'name', type: 'string', description: 'Short label for the checkpoint', required: false }
+                ],
+                tier: PermissionTier.SafeMutation
+            },
+            handler: async ({ name }) => {
+                const info = await chk.create(name ? String(name) : 'checkpoint');
+                return {
+                    success: true,
+                    output: `Checkpoint created: ${info.name} (${info.id})`
+                };
+            }
+        },
+        {
+            definition: {
+                name: 'rollback_checkpoint',
+                description: 'Reverts workspace to a previous checkpoint.',
+                parameters: [
+                    { name: 'checkpointId', type: 'string', description: 'Optional ID of checkpoint to revert to (defaults to latest)', required: false }
+                ],
+                tier: PermissionTier.StateMutating
+            },
+            handler: async ({ checkpointId }) => {
+                return await chk.rollback(checkpointId ? String(checkpointId) : undefined);
+            }
+        }
+    ];
+}
+export class ToolRegistry {
+    tools = new Map();
+    register(tool) {
+        this.tools.set(tool.definition.name, tool);
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    list() {
+        return Array.from(this.tools.values()).map(tool => tool.definition);
+    }
+    async execute(name, params) {
+        const tool = this.get(name);
+        if (!tool) {
+            return {
+                success: false,
+                output: '',
+                error: `Tool not found: ${name}`
+            };
+        }
+        try {
+            return await tool.handler(params);
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: '',
+                error: `Execution error: ${err.message}`
+            };
+        }
+    }
+    toOpenAITools() {
+        return Array.from(this.tools.values()).map(tool => {
+            const properties = {};
+            const required = [];
+            for (const param of tool.definition.parameters) {
+                properties[param.name] = {
+                    type: param.type,
+                    description: param.description,
+                };
+                if (param.enum)
+                    properties[param.name].enum = param.enum;
+                if (param.items)
+                    properties[param.name].items = param.items;
+                if (param.required) {
+                    required.push(param.name);
+                }
+            }
+            return {
+                type: 'function',
+                function: {
+                    name: tool.definition.name,
+                    description: tool.definition.description,
+                    parameters: {
+                        type: 'object',
+                        properties,
+                        required
+                    }
+                }
+            };
+        });
+    }
+    static createDefault() {
+        const registry = new ToolRegistry();
+        const allTools = [
+            ...createFilesystemTools(),
+            ...createSearchTools(),
+            ...createShellTools(),
+            ...createGitTools(),
+            ...createProjectTools(),
+            ...createDiagnosticTools(),
+            ...createWebSearchTools(),
+            ...createMarkdownTools(),
+            ...createSymbolAndImpactTools(),
+            ...createCheckpointTools(),
+            ...mcpRegistry.toOverarchTools(),
+        ];
+        for (const tool of allTools) {
+            registry.register(tool);
+        }
+        return registry;
+    }
+}

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

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

package/dist/src/tools/search.js

@@ -0,0 +1,136 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { PermissionTier } from '../config/types.js';
+const execFileAsync = promisify(execFile);
+function simpleGlobMatch(pattern, text) {
+    if (!pattern)
+        return true;
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(text);
+}
+export function createSearchTools() {
+    return [
+        {
+            definition: {
+                name: 'grepSearch',
+                description: 'Search for text in files',
+                tier: PermissionTier.ReadOnly,
+                parameters: [
+                    { name: 'pattern', type: 'string', description: 'Text to search for', required: true },
+                    { name: 'path', type: 'string', description: 'Path to search in', required: false },
+                    { name: 'include', type: 'string', description: 'Glob pattern to include', required: false },
+                    { name: 'caseSensitive', type: 'boolean', description: 'Case sensitive search', required: false }
+                ]
+            },
+            handler: async (params) => {
+                const targetPath = params.path ? String(params.path) : '.';
+                const pattern = String(params.pattern);
+                const isWindows = process.platform === 'win32';
+                try {
+                    let output = '';
+                    if (isWindows) {
+                        const args = ['/s', '/n'];
+                        if (!params.caseSensitive)
+                            args.push('/i');
+                        args.push(pattern);
+                        const searchPath = path.join(targetPath, params.include ? String(params.include) : '*.*');
+                        args.push(searchPath);
+                        try {
+                            const { stdout } = await execFileAsync('findstr', args);
+                            output = stdout;
+                        }
+                        catch (e) {
+                            if (e.stdout)
+                                output = e.stdout;
+                            else
+                                throw e;
+                        }
+                    }
+                    else {
+                        const args = ['-rn'];
+                        if (!params.caseSensitive)
+                            args.push('-i');
+                        if (params.include) {
+                            args.push('--include');
+                            args.push(String(params.include));
+                        }
+                        args.push(pattern);
+                        args.push(targetPath);
+                        try {
+                            const { stdout } = await execFileAsync('grep', args);
+                            output = stdout;
+                        }
+                        catch (e) {
+                            if (e.stdout)
+                                output = e.stdout;
+                            else
+                                throw e;
+                        }
+                    }
+                    const lines = output.split('\n').filter(Boolean).slice(0, 50);
+                    return { success: true, output: lines.join('\n') || 'No matches found.' };
+                }
+                catch (e) {
+                    return { success: false, output: '', error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'findFiles',
+                description: 'Find files by pattern',
+                tier: PermissionTier.ReadOnly,
+                parameters: [
+                    { name: 'pattern', type: 'string', description: 'Glob pattern', required: true },
+                    { name: 'path', type: 'string', description: 'Search path', required: false },
+                    { name: 'type', type: 'string', description: 'file, directory, or any', required: false, enum: ['file', 'directory', 'any'] }
+                ]
+            },
+            handler: async (params) => {
+                const root = params.path ? String(params.path) : '.';
+                const pattern = String(params.pattern);
+                const type = params.type || 'any';
+                const results = [];
+                const ignoreDirs = ['node_modules', '.git', 'dist', 'build'];
+                let count = 0;
+                async function walk(currentPath) {
+                    if (count >= 50)
+                        return;
+                    try {
+                        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+                        for (const entry of entries) {
+                            if (count >= 50)
+                                break;
+                            if (entry.isDirectory() && ignoreDirs.includes(entry.name))
+                                continue;
+                            const fullPath = path.join(currentPath, entry.name);
+                            let matchType = false;
+                            if (type === 'any')
+                                matchType = true;
+                            else if (type === 'file' && entry.isFile())
+                                matchType = true;
+                            else if (type === 'directory' && entry.isDirectory())
+                                matchType = true;
+                            if (matchType && simpleGlobMatch(pattern, entry.name)) {
+                                results.push(fullPath);
+                                count++;
+                            }
+                            if (entry.isDirectory()) {
+                                await walk(fullPath);
+                            }
+                        }
+                    }
+                    catch (e) { }
+                }
+                await walk(root);
+                return { success: true, output: results.join('\n') || 'No files found.' };
+            }
+        }
+    ];
+}

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

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