jawere 1.0.13

package/dist/system-prompt.js

@@ -0,0 +1,115 @@
+export const SYSTEM_PROMPT = `You are a coding agent running in a terminal. You help users by reading files, running shell commands, editing code, and writing files. You do NOT introduce yourself, describe your capabilities, or make small talk — just work.
+
+── Critical: Be Extremely Concise ──
+
+The user pays per token. Wasting tokens is unacceptable.
+  • Your text responses should be 2-6 lines MAX unless the user explicitly asks for detail.
+  • Never greet, never say "Sure!", "Here you go!", "Let me help you with that!" — just do the work.
+  • Don't explain what you're about to do. Just do it and report the result.
+  • Don't summarize unless asked. The user can see what happened.
+  • Skip all pleasantries, acknowledgements, and filler.
+
+── Working Memory (Critical for Efficiency) ──
+
+You have a working memory file at .codebase/state.md that persists across turns.
+Use it to avoid redundant work — this is your MOST IMPORTANT efficiency tool.
+
+  AT THE START of every turn (before any other action):
+    1. Read .codebase/state.md to recall what you already know
+    2. Read .codebase/tree.yaml if you haven't already (check state.md)
+
+  DURING work:
+    • After reading a file, update state.md with the file path + summary
+    • After editing a file, update state.md with what you changed
+    • Track your current task and progress in state.md
+
+  RULE: Never re-read a file you've already read this session UNLESS:
+    • You modified it since reading
+    • The tree.yaml hash changed (indicating external modification)
+    • You need a specific section you didn't read before (use offset)
+
+── Codebase Context ──
+
+A pre-scan of the project is available. Before doing anything else:
+  1. Read .codebase/state.md to check what's already known
+  2. Read .codebase/tree.yaml to understand the project structure
+  3. Read .codebase/meta.json for scan metadata
+  4. Use this knowledge to navigate efficiently — don't re-scan what's already documented
+
+── Your Capabilities ──
+
+You have access to a set of tools that let you interact with the filesystem:
+
+  bash   Execute shell commands in the working directory. Run scripts, install
+         dependencies, list files, search with grep/find, git operations,
+         compilers, linters, and tests.
+  read   Read file contents. Use offset/limit for large files. Continue with
+         offset until you have the full file.
+  edit   Precise file edits via exact-text replacement. oldText must match
+         exactly once. Merge nearby changes into one edit. Keep oldText as
+         small as possible while still unique.
+  write  Create new files or completely overwrite existing ones. Creates
+         parent directories automatically. For new files or full rewrites only.
+  ls     List directory contents with sizes (dirs first, then files alphabetical).
+  find   Find files by fuzzy name or glob (e.g. "agentloop" or "*.ts").
+         Skips hidden dirs and node_modules, .git, dist, etc.
+  grep   Search file contents with regex. Returns file paths with line numbers.
+         Skips binary files and files over 500KB.
+
+── Parallel Tool Execution ──
+
+You can call multiple tools simultaneously in a single response when they are
+independent of each other. This is faster and saves tokens — use it whenever possible.
+
+  GOOD — read 3 files in parallel:
+    • Call read(fileA), read(fileB), read(fileC) all at once
+
+  GOOD — run independent commands in parallel:
+    • Call ls(src/), find("*.test.ts"), grep("TODO", "src/") all at once
+
+  GOOD — read a file AND list a directory at the same time:
+    • Call read(config.ts) + ls(src/) together
+
+  BAD — these depend on each other, so must be sequential:
+    • grep then read (grep finds a file, then you read it)
+    • bash then read (you run a command, then read its output file)
+    • write then bash (you create a file, then run it)
+
+  Rule of thumb: if tool B's input depends on tool A's output, they must be
+  sequential. Otherwise, batch them together in one response.
+
+── Response Style ──
+
+You are running in a terminal. Use clean plain text — never markdown.
+  • No **bold**, no ## headings, no [links](url), no \`code spans\`
+  • Use ── section separators for structure
+  • Use indentation for lists and code blocks
+  • Show file paths like this: path/to/file.ts
+  • Wrap code snippets with 2-space indent, not triple backticks
+  • Keep responses tight — skip filler and pleasantries
+
+── Rules ──
+
+  1. Think before acting. Reason internally about the best approach.
+  2. Use bash first for exploration (ls, find, grep) before editing.
+  3. Edit precisely — minimal oldText, unique matches only.
+  4. Merge nearby edits into a single call.
+  5. Write for new files or complete rewrites only.
+  6. Stay safe. Never run rm -rf, force-push to main, etc. without confirmation.
+  7. Work in the current directory. Use relative paths.
+  8. When done, give a short summary (1-3 lines) of what you changed.
+
+── Final Output Format ──
+
+Your final message (when all tool calls are complete) MUST be a brief summary:
+
+  ── Changes Made ──
+  • file/path.ts — what you changed (one line)
+  ──
+
+Only include files you actually modified. Do NOT include:
+  - Markdown formatting, long explanations, or step-by-step walkthroughs
+  - Tool-by-tool recaps of what commands you ran
+  - Pleasantries, filler, or "let me know if you need anything else"
+
+Keep it tight. The user sees tool calls live — they just want the summary.`;

package/dist/tools.d.ts

@@ -0,0 +1,22 @@
+export interface ToolCall {
+    id: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolResult {
+    tool_call_id: string;
+    role: 'tool';
+    content: string;
+}
+export type OpenAITool = {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+};
+export declare const TOOL_DEFS: OpenAITool[];
+export declare function executeTool(call: ToolCall, workDir: string): Promise<ToolResult>;

package/dist/tools.js

@@ -0,0 +1,551 @@
+import { exec } from 'child_process';
+import { readFile, writeFile, mkdir, access } from 'fs/promises';
+import { constants } from 'fs';
+import { resolve, dirname } from 'path';
+// ── Tool definitions ────────────────────────────────────────────────
+export const TOOL_DEFS = [
+    {
+        type: 'function',
+        function: {
+            name: 'bash',
+            description: 'Execute a bash command in the working directory. Returns stdout and stderr. ' +
+                'Output is truncated to 2000 lines or 50KB (whichever is hit first). ' +
+                'Optionally provide a timeout in seconds (max 300s).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: {
+                        type: 'string',
+                        description: 'Bash command to execute',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Timeout in seconds (optional, max 300)',
+                    },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'read',
+            description: 'Read the contents of a file. Supports text files. ' +
+                'Output is truncated to 2000 lines or 50KB (whichever is hit first). ' +
+                'Use offset/limit for large files. When you need the full file, continue with offset until complete.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Path to the file to read (relative or absolute)',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Line number to start reading from (1-indexed)',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of lines to read',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'edit',
+            description: 'Edit a file using exact text replacement. Every edits[].oldText must match a unique, ' +
+                'non-overlapping region of the original file. If two changes affect the same block or ' +
+                'nearby lines, merge them into one edit. Do not include large unchanged regions.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Path to the file to edit (relative or absolute)',
+                    },
+                    edits: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                oldText: {
+                                    type: 'string',
+                                    description: 'Exact text to replace (must be unique in file)',
+                                },
+                                newText: {
+                                    type: 'string',
+                                    description: 'Replacement text',
+                                },
+                            },
+                            required: ['oldText', 'newText'],
+                        },
+                        description: 'One or more targeted replacements',
+                    },
+                },
+                required: ['path', 'edits'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'write',
+            description: 'Write content to a file. Creates the file if it doesn\'t exist, overwrites if it does. ' +
+                'Automatically creates parent directories.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Path to the file to write (relative or absolute)',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Content to write to the file',
+                    },
+                },
+                required: ['path', 'content'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'ls',
+            description: 'List directory contents. Shows files and directories with sizes, sorted (dirs first, then files alphabetically).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Directory to list (defaults to working directory)',
+                    },
+                },
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'find',
+            description: 'Find files by name. Supports fuzzy matching (e.g. "agentloop" matches "agent-loop.ts") ' +
+                'and glob patterns (e.g. "*.ts"). Skips hidden dirs and common large directories ' +
+                '(node_modules, .git, dist, etc.).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: {
+                        type: 'string',
+                        description: 'Search query (fuzzy or glob like *.ts)',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'Directory to search in (defaults to working directory)',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'grep',
+            description: 'Search file contents with regex. Returns matching file paths with line numbers and content. ' +
+                'Skips binary files and files over 500KB.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: {
+                        type: 'string',
+                        description: 'Regex pattern to search for',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'Directory or file to search in (defaults to working directory)',
+                    },
+                    include: {
+                        type: 'string',
+                        description: 'File glob filter (e.g. *.ts)',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+];
+// ── Tool implementations ────────────────────────────────────────────
+const MAX_OUTPUT_LINES = 2000;
+const MAX_OUTPUT_BYTES = 50 * 1024; // 50KB
+function truncateOutput(text) {
+    const lines = text.split('\n');
+    const byteLen = Buffer.byteLength(text, 'utf-8');
+    if (lines.length <= MAX_OUTPUT_LINES && byteLen <= MAX_OUTPUT_BYTES) {
+        return text;
+    }
+    let truncated = '';
+    if (lines.length > MAX_OUTPUT_LINES) {
+        truncated = lines.slice(0, MAX_OUTPUT_LINES).join('\n');
+        truncated += `\n\n[Truncated: ${lines.length - MAX_OUTPUT_LINES} more lines]`;
+    }
+    else {
+        truncated = text;
+    }
+    if (Buffer.byteLength(truncated, 'utf-8') > MAX_OUTPUT_BYTES) {
+        const buf = Buffer.from(truncated, 'utf-8');
+        truncated = buf.subarray(0, MAX_OUTPUT_BYTES).toString('utf-8');
+        truncated += '\n\n[Truncated: output exceeded 50KB]';
+    }
+    return truncated;
+}
+async function execBash(command, workDir, timeoutSec) {
+    const timeout = Math.min(timeoutSec ?? 120, 300) * 1000;
+    return new Promise((resolve) => {
+        const child = exec(command, {
+            cwd: workDir,
+            maxBuffer: 10 * 1024 * 1024, // 10MB
+            timeout,
+            shell: '/bin/bash',
+        }, (error, stdout, stderr) => {
+            let result = '';
+            const outStr = typeof stdout === 'string' ? stdout : stdout?.toString() ?? '';
+            const errStr = typeof stderr === 'string' ? stderr : stderr?.toString() ?? '';
+            if (outStr.trim())
+                result += outStr.trim();
+            if (errStr.trim()) {
+                if (result)
+                    result += '\n';
+                result += errStr.trim();
+            }
+            if (error && !result) {
+                result = error.message;
+            }
+            resolve(truncateOutput(result) || '(no output)');
+        });
+    });
+}
+async function readFileTool(path, workDir, offset, limit) {
+    const fullPath = resolve(workDir, path);
+    // Safety: ensure path is within workDir or is a reasonable absolute path
+    try {
+        await access(fullPath, constants.R_OK);
+    }
+    catch {
+        return `Error: File not found or not readable: ${fullPath}`;
+    }
+    const content = await readFile(fullPath, 'utf-8');
+    let lines = content.split('\n');
+    const start = offset ? offset - 1 : 0;
+    const end = limit ? start + limit : undefined;
+    lines = lines.slice(start, end);
+    let result = lines.join('\n');
+    if (result.length === 0 && content.length > 0) {
+        result = content; // fallback for non-newline files
+    }
+    return truncateOutput(result);
+}
+async function editFileTool(path, edits, workDir) {
+    const fullPath = resolve(workDir, path);
+    let content;
+    try {
+        content = await readFile(fullPath, 'utf-8');
+    }
+    catch {
+        // If file doesn't exist, create it if we have exactly one "empty" edit
+        if (edits.length === 1 && edits[0].oldText === '') {
+            await mkdir(dirname(fullPath), { recursive: true });
+            await writeFile(fullPath, edits[0].newText, 'utf-8');
+            return `Created new file: ${fullPath}`;
+        }
+        return `Error: File not found: ${fullPath}`;
+    }
+    let modified = content;
+    const errors = [];
+    for (const edit of edits) {
+        const { oldText, newText } = edit;
+        if (oldText === '') {
+            errors.push(`Edit with empty oldText — use write tool for new files`);
+            continue;
+        }
+        const count = modified.split(oldText).length - 1;
+        if (count === 0) {
+            errors.push(`oldText not found in file: "${oldText.slice(0, 80)}..."`);
+            continue;
+        }
+        if (count > 1) {
+            errors.push(`oldText matches ${count} times (must be unique): "${oldText.slice(0, 80)}..."`);
+            continue;
+        }
+        modified = modified.replace(oldText, newText);
+    }
+    if (errors.length > 0 && modified === content) {
+        return `Edit failed:\n${errors.map((e) => `  - ${e}`).join('\n')}`;
+    }
+    await writeFile(fullPath, modified, 'utf-8');
+    const result = errors.length > 0
+        ? `File edited with warnings:\n${errors.map((e) => `  - ${e}`).join('\n')}`
+        : `File edited successfully: ${fullPath}`;
+    return result;
+}
+async function writeFileTool(path, content, workDir) {
+    const fullPath = resolve(workDir, path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content, 'utf-8');
+    return `Successfully wrote ${Buffer.byteLength(content, 'utf-8')} bytes to ${fullPath}`;
+}
+// ── New tools: ls, find, grep ──────────────────────────────────────
+async function lsTool(path, workDir) {
+    const dir = resolve(workDir, path || '.');
+    const { readdir, stat } = await import('fs/promises');
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        if (entries.length === 0)
+            return `(empty directory: ${dir})`;
+        // Get sizes and sort: dirs first, then files alphabetically
+        const withMeta = await Promise.all(entries.map(async (e) => {
+            const full = resolve(dir, e.name);
+            let size = '';
+            try {
+                const s = await stat(full);
+                if (s.isFile()) {
+                    const kb = s.size / 1024;
+                    size = kb >= 1000 ? `${(kb / 1024).toFixed(1)}M` : kb >= 1 ? `${kb.toFixed(0)}K` : `${s.size}B`;
+                }
+            }
+            catch { /* skip */ }
+            return {
+                name: e.name,
+                isDir: e.isDirectory(),
+                size,
+            };
+        }));
+        withMeta.sort((a, b) => {
+            if (a.isDir !== b.isDir)
+                return a.isDir ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        const lines = withMeta.map((e) => {
+            const type = e.isDir ? '/' : '';
+            const sizeStr = e.size ? ` (${e.size})` : '';
+            return `${e.name}${type}${sizeStr}`;
+        });
+        return truncateOutput(`${dir}:\n${lines.join('\n')}`);
+    }
+    catch (err) {
+        return `Error listing ${dir}: ${err.message}`;
+    }
+}
+async function findTool(pattern, searchPath, workDir) {
+    const base = resolve(workDir, searchPath || '.');
+    const SKIP_DIRS = new Set([
+        'node_modules', '.git', 'dist', 'build', '__pycache__', '.venv', 'venv',
+        '.next', '.cache', 'coverage', '.convex', '_generated',
+    ]);
+    // Detect if pattern looks like a glob
+    const isGlob = /[*?[\]{}]/.test(pattern);
+    const results = [];
+    const MAX_RESULTS = 200;
+    async function walk(dir, depth) {
+        if (depth > 8 || results.length >= MAX_RESULTS)
+            return;
+        let entries;
+        try {
+            const { readdir } = await import('fs/promises');
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (results.length >= MAX_RESULTS)
+                break;
+            if (e.isDirectory()) {
+                if (SKIP_DIRS.has(e.name) || e.name.startsWith('.'))
+                    continue;
+                await walk(resolve(dir, e.name), depth + 1);
+            }
+            else {
+                if (isGlob) {
+                    // Simple glob matching
+                    const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+                    if (regex.test(e.name)) {
+                        results.push(resolve(dir, e.name).replace(base + '/', ''));
+                    }
+                }
+                else {
+                    // Fuzzy matching: all pattern chars appear in order in filename
+                    const lower = e.name.toLowerCase();
+                    const pat = pattern.toLowerCase();
+                    let pi = 0;
+                    for (let i = 0; i < lower.length && pi < pat.length; i++) {
+                        if (lower[i] === pat[pi])
+                            pi++;
+                    }
+                    if (pi === pat.length) {
+                        results.push(resolve(dir, e.name).replace(base + '/', ''));
+                    }
+                }
+            }
+        }
+    }
+    try {
+        await walk(base, 0);
+    }
+    catch (err) {
+        return `Error finding files: ${err.message}`;
+    }
+    if (results.length === 0)
+        return `No files matching "${pattern}" found.`;
+    return truncateOutput(`Found ${results.length} file${results.length !== 1 ? 's' : ''} matching "${pattern}":\n${results.join('\n')}`);
+}
+async function grepTool(pattern, searchPath, include, workDir) {
+    const base = resolve(workDir, searchPath || '.');
+    const SKIP_DIRS = new Set([
+        'node_modules', '.git', 'dist', 'build', '__pycache__', '.venv', 'venv',
+        '.next', '.cache', '.convex', '_generated',
+    ]);
+    const MAX_FILE_SIZE = 500 * 1024;
+    const MAX_MATCHES = 100;
+    let regex;
+    try {
+        regex = new RegExp(pattern, 'gi');
+    }
+    catch (err) {
+        return `Error: Invalid regex pattern: ${err.message}`;
+    }
+    const results = [];
+    async function walk(dir, depth) {
+        if (depth > 8 || results.length >= MAX_MATCHES)
+            return;
+        let entries;
+        try {
+            const { readdir, stat } = await import('fs/promises');
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (results.length >= MAX_MATCHES)
+                break;
+            const full = resolve(dir, e.name);
+            if (e.isDirectory()) {
+                if (SKIP_DIRS.has(e.name) || e.name.startsWith('.'))
+                    continue;
+                await walk(full, depth + 1);
+            }
+            else {
+                // Include filter
+                if (include) {
+                    const incRegex = new RegExp('^' + include.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+                    if (!incRegex.test(e.name))
+                        continue;
+                }
+                // Size check
+                try {
+                    const { stat } = await import('fs/promises');
+                    const s = await stat(full);
+                    if (s.size > MAX_FILE_SIZE)
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                // Read and search
+                try {
+                    const content = await readFile(full, 'utf-8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length && results.length < MAX_MATCHES; i++) {
+                        if (regex.test(lines[i])) {
+                            regex.lastIndex = 0;
+                            const relPath = full.replace(base + '/', '');
+                            results.push(`${relPath}:${i + 1}: ${lines[i].trim().slice(0, 120)}`);
+                        }
+                    }
+                }
+                catch {
+                    // Skip binary/unreadable files
+                }
+            }
+        }
+    }
+    try {
+        const s = await (await import('fs/promises')).stat(base);
+        if (s.isFile()) {
+            // Single file mode
+            const content = await readFile(base, 'utf-8');
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length && results.length < MAX_MATCHES; i++) {
+                if (regex.test(lines[i])) {
+                    regex.lastIndex = 0;
+                    results.push(`L${i + 1}: ${lines[i].trim().slice(0, 120)}`);
+                }
+            }
+        }
+        else {
+            await walk(base, 0);
+        }
+    }
+    catch (err) {
+        return `Error searching: ${err.message}`;
+    }
+    if (results.length === 0)
+        return `No matches for "${pattern}" found.`;
+    return truncateOutput(`${results.length} match${results.length !== 1 ? 'es' : ''} for "${pattern}":\n${results.join('\n')}`);
+}
+// ── Tool dispatcher ─────────────────────────────────────────────────
+export async function executeTool(call, workDir) {
+    const { id, function: fn } = call;
+    let args;
+    try {
+        args = JSON.parse(fn.arguments);
+    }
+    catch {
+        return {
+            tool_call_id: id,
+            role: 'tool',
+            content: `Error: Invalid JSON arguments: ${fn.arguments}`,
+        };
+    }
+    let result;
+    try {
+        switch (fn.name) {
+            case 'bash':
+                result = await execBash(args.command, workDir, args.timeout);
+                break;
+            case 'read':
+                result = await readFileTool(args.path, workDir, args.offset, args.limit);
+                break;
+            case 'edit':
+                result = await editFileTool(args.path, args.edits, workDir);
+                break;
+            case 'write':
+                result = await writeFileTool(args.path, args.content, workDir);
+                break;
+            case 'ls':
+                result = await lsTool(args.path, workDir);
+                break;
+            case 'find':
+                result = await findTool(args.pattern, args.path, workDir);
+                break;
+            case 'grep':
+                result = await grepTool(args.pattern, args.path, args.include, workDir);
+                break;
+            default:
+                result = `Error: Unknown tool: ${fn.name}`;
+        }
+    }
+    catch (err) {
+        result = `Error executing ${fn.name}: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    return {
+        tool_call_id: id,
+        role: 'tool',
+        content: result,
+    };
+}