@compilr-dev/agents 0.2.1 → 0.3.1

package/dist/tools/builtin/backlog.js

@@ -0,0 +1,368 @@
+/**
+ * Backlog Tools - File-based project backlog management
+ *
+ * Provides backlog_read and backlog_write tools for managing project backlogs.
+ * Uses a JSON file stored in .compilr/backlog.json (or backlog.json in project root).
+ *
+ * Features:
+ * - Read with filters (status, type, search, limit)
+ * - Write/update individual items or full backlog
+ * - Support for common item types (feature, bug, chore, spike)
+ * - Priority levels (critical, high, medium, low)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { defineTool, createSuccessResult, createErrorResult } from '../define.js';
+// =============================================================================
+// File Operations
+// =============================================================================
+const BACKLOG_PATHS = ['.compilr/backlog.json', 'backlog.json', '.claude/backlog.json'];
+function findBacklogFile(cwd = process.cwd()) {
+    for (const relPath of BACKLOG_PATHS) {
+        const fullPath = path.join(cwd, relPath);
+        if (fs.existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+function getDefaultBacklogPath(cwd = process.cwd()) {
+    // Prefer .compilr directory if it exists
+    const compilrDir = path.join(cwd, '.compilr');
+    if (fs.existsSync(compilrDir)) {
+        return path.join(compilrDir, 'backlog.json');
+    }
+    // Otherwise use project root
+    return path.join(cwd, 'backlog.json');
+}
+function loadBacklog(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(content);
+        return {
+            version: data.version || '1.0',
+            items: Array.isArray(data.items) ? data.items : [],
+        };
+    }
+    catch {
+        return { version: '1.0', items: [] };
+    }
+}
+function saveBacklog(filePath, backlog) {
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Update timestamps
+    const now = new Date().toISOString();
+    backlog.items = backlog.items.map((item) => ({
+        ...item,
+        updatedAt: now,
+        createdAt: item.createdAt || now,
+    }));
+    fs.writeFileSync(filePath, JSON.stringify(backlog, null, 2), 'utf-8');
+}
+function generateItemId(type, items) {
+    const prefix = {
+        feature: 'FEAT',
+        bug: 'BUG',
+        chore: 'CHORE',
+        spike: 'SPIKE',
+    }[type];
+    // Find highest number for this type
+    const existingIds = items
+        .filter((i) => i.id.startsWith(prefix))
+        .map((i) => parseInt(i.id.split('-')[1], 10))
+        .filter((n) => !isNaN(n));
+    const nextNum = existingIds.length > 0 ? Math.max(...existingIds) + 1 : 1;
+    return `${prefix}-${String(nextNum).padStart(3, '0')}`;
+}
+// =============================================================================
+// Backlog Read Tool
+// =============================================================================
+/**
+ * Read backlog items with optional filters
+ */
+export const backlogReadTool = defineTool({
+    name: 'backlog_read',
+    description: 'Read backlog items from the project. ' +
+        'Use filters to narrow results. Use id parameter to get a specific item. ' +
+        'Returns items sorted by priority (critical first) then by creation date.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: {
+                type: 'string',
+                description: 'Get a specific item by ID (e.g., "FEAT-001")',
+            },
+            status: {
+                type: 'string',
+                enum: ['backlog', 'in-progress', 'done', 'blocked'],
+                description: 'Filter by status',
+            },
+            type: {
+                type: 'string',
+                enum: ['feature', 'bug', 'chore', 'spike'],
+                description: 'Filter by item type',
+            },
+            search: {
+                type: 'string',
+                description: 'Search in title and description',
+            },
+            priority: {
+                type: 'string',
+                enum: ['critical', 'high', 'medium', 'low'],
+                description: 'Filter by priority',
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum items to return (default: 20)',
+            },
+        },
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    execute: async (input) => {
+        try {
+            const filePath = findBacklogFile();
+            if (!filePath) {
+                return createSuccessResult({
+                    items: [],
+                    total: 0,
+                    filtered: 0,
+                    message: 'No backlog file found. Use backlog_write to create one.',
+                });
+            }
+            const backlog = loadBacklog(filePath);
+            let items = [...backlog.items];
+            const total = items.length;
+            // Filter by ID (exact match)
+            if (input.id) {
+                items = items.filter((i) => i.id === input.id);
+            }
+            // Filter by status
+            if (input.status) {
+                items = items.filter((i) => i.status === input.status);
+            }
+            // Filter by type
+            if (input.type) {
+                items = items.filter((i) => i.type === input.type);
+            }
+            // Filter by priority
+            if (input.priority) {
+                items = items.filter((i) => i.priority === input.priority);
+            }
+            // Search in title and description
+            if (input.search) {
+                const query = input.search.toLowerCase();
+                items = items.filter((i) => i.title.toLowerCase().includes(query) || i.description?.toLowerCase().includes(query));
+            }
+            // Sort by priority then by creation date
+            const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+            items.sort((a, b) => {
+                const pa = priorityOrder[a.priority || 'medium'];
+                const pb = priorityOrder[b.priority || 'medium'];
+                if (pa !== pb)
+                    return pa - pb;
+                return (a.createdAt || '').localeCompare(b.createdAt || '');
+            });
+            // Apply limit
+            const limit = input.limit ?? 20;
+            const filtered = items.length;
+            items = items.slice(0, limit);
+            return createSuccessResult({
+                items,
+                total,
+                filtered,
+            });
+        }
+        catch (error) {
+            return createErrorResult(error instanceof Error ? error.message : String(error));
+        }
+    },
+});
+// =============================================================================
+// Backlog Write Tool
+// =============================================================================
+/**
+ * Write/update backlog items
+ */
+export const backlogWriteTool = defineTool({
+    name: 'backlog_write',
+    description: 'Create, update, or delete backlog items. ' +
+        'Actions: add (new item), update (modify existing), delete (remove), replace (full list). ' +
+        'IDs are auto-generated for new items based on type (e.g., FEAT-001, BUG-002).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['add', 'update', 'delete', 'replace'],
+                description: 'Action to perform',
+            },
+            item: {
+                type: 'object',
+                description: 'Item to add or update (for add/update actions)',
+                properties: {
+                    id: { type: 'string', description: 'Item ID (required for update)' },
+                    type: {
+                        type: 'string',
+                        enum: ['feature', 'bug', 'chore', 'spike'],
+                        description: 'Item type (required for add)',
+                    },
+                    title: { type: 'string', description: 'Item title' },
+                    description: { type: 'string', description: 'Detailed description' },
+                    status: {
+                        type: 'string',
+                        enum: ['backlog', 'in-progress', 'done', 'blocked'],
+                        description: 'Item status',
+                    },
+                    priority: {
+                        type: 'string',
+                        enum: ['critical', 'high', 'medium', 'low'],
+                        description: 'Priority level',
+                    },
+                    acceptanceCriteria: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Acceptance criteria list',
+                    },
+                    dependencies: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'IDs of items this depends on',
+                    },
+                    labels: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Labels/tags',
+                    },
+                },
+            },
+            deleteId: {
+                type: 'string',
+                description: 'Item ID to delete (for delete action)',
+            },
+            items: {
+                type: 'array',
+                description: 'Full list of items (for replace action)',
+                items: {
+                    type: 'object',
+                },
+            },
+        },
+        required: ['action'],
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    execute: async (input) => {
+        try {
+            const existingPath = findBacklogFile();
+            const filePath = existingPath || getDefaultBacklogPath();
+            const backlog = existingPath ? loadBacklog(existingPath) : { version: '1.0', items: [] };
+            switch (input.action) {
+                case 'add': {
+                    if (!input.item) {
+                        return createErrorResult('Item is required for add action');
+                    }
+                    const itemType = input.item.type;
+                    const itemTitle = input.item.title;
+                    if (!itemType) {
+                        return createErrorResult('Item type is required for add action');
+                    }
+                    if (!itemTitle) {
+                        return createErrorResult('Item title is required for add action');
+                    }
+                    const newItem = {
+                        id: generateItemId(itemType, backlog.items),
+                        type: itemType,
+                        title: itemTitle,
+                        description: input.item.description,
+                        status: input.item.status ?? 'backlog',
+                        priority: input.item.priority,
+                        acceptanceCriteria: input.item.acceptanceCriteria,
+                        dependencies: input.item.dependencies,
+                        labels: input.item.labels,
+                    };
+                    backlog.items.push(newItem);
+                    saveBacklog(filePath, backlog);
+                    return createSuccessResult({
+                        success: true,
+                        action: 'add',
+                        itemId: newItem.id,
+                        itemCount: backlog.items.length,
+                    });
+                }
+                case 'update': {
+                    const updateItem = input.item;
+                    const updateId = updateItem?.id;
+                    if (!updateItem || !updateId) {
+                        return createErrorResult('Item ID is required for update action');
+                    }
+                    const idx = backlog.items.findIndex((i) => i.id === updateId);
+                    if (idx === -1) {
+                        return createErrorResult(`Item not found: ${updateId}`);
+                    }
+                    // Merge updates
+                    backlog.items[idx] = {
+                        ...backlog.items[idx],
+                        ...updateItem,
+                        id: backlog.items[idx].id, // Preserve original ID
+                    };
+                    saveBacklog(filePath, backlog);
+                    return createSuccessResult({
+                        success: true,
+                        action: 'update',
+                        itemId: updateId,
+                        itemCount: backlog.items.length,
+                    });
+                }
+                case 'delete': {
+                    const deleteId = input.deleteId || input.item?.id;
+                    if (!deleteId) {
+                        return createErrorResult('deleteId or item.id is required for delete action');
+                    }
+                    const initialCount = backlog.items.length;
+                    backlog.items = backlog.items.filter((i) => i.id !== deleteId);
+                    if (backlog.items.length === initialCount) {
+                        return createErrorResult(`Item not found: ${deleteId}`);
+                    }
+                    saveBacklog(filePath, backlog);
+                    return createSuccessResult({
+                        success: true,
+                        action: 'delete',
+                        itemId: deleteId,
+                        itemCount: backlog.items.length,
+                    });
+                }
+                case 'replace': {
+                    if (!input.items) {
+                        return createErrorResult('Items array is required for replace action');
+                    }
+                    backlog.items = input.items;
+                    saveBacklog(filePath, backlog);
+                    return createSuccessResult({
+                        success: true,
+                        action: 'replace',
+                        itemCount: backlog.items.length,
+                    });
+                }
+                default:
+                    return createErrorResult(`Unknown action: ${input.action}`);
+            }
+        }
+        catch (error) {
+            return createErrorResult(error instanceof Error ? error.message : String(error));
+        }
+    },
+});
+/**
+ * Create backlog tools with custom options
+ */
+export function createBacklogTools(_options = {}) {
+    // For now, just return the default tools
+    // Future: could customize file paths, storage backend, etc.
+    return {
+        backlogRead: backlogReadTool,
+        backlogWrite: backlogWriteTool,
+    };
+}

package/dist/tools/builtin/bash.js

@@ -116,7 +116,7 @@ export const bashTool = defineTool({
 /**
  * Execute the bash tool
  */
-async function executeBash(input) {
+async function executeBash(input, context) {
     const { command, cwd, timeout = DEFAULT_TIMEOUT, env, run_in_background } = input;
     // Detect FIFO usage and add warning
     const fifoCheck = detectFifoUsage(command);
@@ -124,6 +124,17 @@ async function executeBash(input) {
     if (run_in_background) {
         return executeInBackground(command, { cwd, env });
     }
+    // Use streaming execution if context.onOutput is provided
+    if (context?.onOutput) {
+        return executeWithStreaming(command, {
+            cwd,
+            timeout,
+            env,
+            onOutput: context.onOutput,
+            fifoCheck,
+        });
+    }
+    // Non-streaming execution (original behavior)
     try {
         const result = await execAsync(command, {
             cwd,
@@ -164,6 +175,154 @@ async function executeBash(input) {
         return createErrorResult(error instanceof Error ? error.message : String(error));
     }
 }
+/**
+ * Execute command with streaming output to onOutput callback
+ */
+async function executeWithStreaming(command, options) {
+    const { cwd, timeout = DEFAULT_TIMEOUT, env, onOutput, fifoCheck } = options;
+    return new Promise((resolve) => {
+        const child = spawn(command, [], {
+            cwd,
+            shell: '/bin/bash',
+            env: env ? { ...process.env, ...env } : undefined,
+        });
+        let stdoutBuffer = '';
+        let stderrBuffer = '';
+        let timedOut = false;
+        // Set up timeout
+        const timeoutId = timeout > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+                // Force kill after 5 seconds if not dead
+                setTimeout(() => child.kill('SIGKILL'), 5000);
+            }, timeout)
+            : undefined;
+        // Stream stdout
+        child.stdout.on('data', (data) => {
+            const text = data.toString();
+            stdoutBuffer += text;
+            // Emit each line separately for better UI updates
+            const lines = text.split('\n');
+            for (const line of lines) {
+                if (line.length > 0) {
+                    onOutput(line, 'stdout');
+                }
+            }
+        });
+        // Stream stderr
+        child.stderr.on('data', (data) => {
+            const text = data.toString();
+            stderrBuffer += text;
+            // Emit each line separately
+            const lines = text.split('\n');
+            for (const line of lines) {
+                if (line.length > 0) {
+                    onOutput(line, 'stderr');
+                }
+            }
+        });
+        // Handle completion
+        child.on('close', (code) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (timedOut) {
+                resolve(createErrorResult(`Command timed out after ${String(timeout)}ms`));
+                return;
+            }
+            // Truncate for final result
+            const stdout = truncateOutput(stdoutBuffer, DEFAULT_MAX_OUTPUT_SIZE);
+            const stderr = truncateOutput(stderrBuffer, DEFAULT_MAX_OUTPUT_SIZE);
+            resolve(createSuccessResult({
+                stdout: stdout.content,
+                stderr: stderr.content,
+                exitCode: code ?? 0,
+                truncated: stdout.truncated || stderr.truncated,
+                ...(fifoCheck.detected && { fifoWarning: fifoCheck.warning }),
+            }));
+        });
+        // Handle spawn errors
+        child.on('error', (error) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            resolve(createErrorResult(error.message));
+        });
+    });
+}
+/**
+ * Execute command with streaming output (custom options version for createBashTool)
+ */
+async function executeWithStreamingCustom(command, options) {
+    const { cwd, timeout = DEFAULT_TIMEOUT, env, onOutput, fifoCheck, maxOutputSize, shell, } = options;
+    return new Promise((resolve) => {
+        const child = spawn(command, [], {
+            cwd,
+            shell,
+            env: env ? { ...process.env, ...env } : undefined,
+        });
+        let stdoutBuffer = '';
+        let stderrBuffer = '';
+        let timedOut = false;
+        // Set up timeout
+        const timeoutId = timeout > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+                // Force kill after 5 seconds if not dead
+                setTimeout(() => child.kill('SIGKILL'), 5000);
+            }, timeout)
+            : undefined;
+        // Stream stdout
+        child.stdout.on('data', (data) => {
+            const text = data.toString();
+            stdoutBuffer += text;
+            // Emit each line separately for better UI updates
+            const lines = text.split('\n');
+            for (const line of lines) {
+                if (line.length > 0) {
+                    onOutput(line, 'stdout');
+                }
+            }
+        });
+        // Stream stderr
+        child.stderr.on('data', (data) => {
+            const text = data.toString();
+            stderrBuffer += text;
+            // Emit each line separately
+            const lines = text.split('\n');
+            for (const line of lines) {
+                if (line.length > 0) {
+                    onOutput(line, 'stderr');
+                }
+            }
+        });
+        // Handle completion
+        child.on('close', (code) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (timedOut) {
+                resolve(createErrorResult(`Command timed out after ${String(timeout)}ms`));
+                return;
+            }
+            // Truncate for final result
+            const stdout = truncateOutput(stdoutBuffer, maxOutputSize);
+            const stderr = truncateOutput(stderrBuffer, maxOutputSize);
+            resolve(createSuccessResult({
+                stdout: stdout.content,
+                stderr: stderr.content,
+                exitCode: code ?? 0,
+                truncated: stdout.truncated || stderr.truncated,
+                ...(fifoCheck.detected && { fifoWarning: fifoCheck.warning }),
+            }));
+        });
+        // Handle spawn errors
+        child.on('error', (error) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            resolve(createErrorResult(error.message));
+        });
+    });
+}
 /**
  * Execute command in background and return shell ID
  */
@@ -234,7 +393,7 @@ export function createBashTool(options) {
             },
             required: ['command'],
         },
-        execute: async (input) => {
+        execute: async (input, context) => {
             const { cwd: defaultCwd, timeout: defaultTimeout = DEFAULT_TIMEOUT, maxOutputSize = DEFAULT_MAX_OUTPUT_SIZE, blockedCommands = [], restrictToAllowed = false, allowedCommands = [], shell = '/bin/bash', shellManager, fifoMode = 'warn', } = options ?? {};
             const command = input.command.trim();
             // Detect FIFO usage
@@ -274,19 +433,27 @@ export function createBashTool(options) {
                     return createErrorResult(error instanceof Error ? error.message : String(error));
                 }
             }
-            // Execute with merged options
-            const mergedInput = {
-                ...input,
-                cwd: input.cwd ?? defaultCwd,
-                timeout: input.timeout ?? defaultTimeout,
-            };
+            const timeout = input.timeout ?? defaultTimeout;
+            // Use streaming execution if context.onOutput is provided
+            if (context?.onOutput) {
+                return executeWithStreamingCustom(command, {
+                    cwd: input.cwd ?? defaultCwd,
+                    timeout,
+                    env: input.env,
+                    onOutput: context.onOutput,
+                    fifoCheck,
+                    maxOutputSize,
+                    shell,
+                });
+            }
+            // Execute with merged options (non-streaming)
             try {
-                const result = await execAsync(mergedInput.command, {
-                    cwd: mergedInput.cwd,
-                    timeout: mergedInput.timeout,
+                const result = await execAsync(command, {
+                    cwd: input.cwd ?? defaultCwd,
+                    timeout,
                     maxBuffer: MAX_BUFFER_SIZE,
                     shell,
-                    env: mergedInput.env ? { ...process.env, ...mergedInput.env } : undefined,
+                    env: input.env ? { ...process.env, ...input.env } : undefined,
                 });
                 // Truncate output to prevent memory bloat
                 const stdout = truncateOutput(result.stdout, maxOutputSize);
@@ -302,7 +469,7 @@ export function createBashTool(options) {
             catch (error) {
                 if (isExecError(error)) {
                     if (error.killed) {
-                        return createErrorResult(`Command timed out after ${String(mergedInput.timeout ?? defaultTimeout)}ms`);
+                        return createErrorResult(`Command timed out after ${String(timeout)}ms`);
                     }
                     // Truncate output even on error
                     const stdout = truncateOutput(error.stdout ?? '', maxOutputSize);

package/dist/tools/builtin/index.d.ts

@@ -29,6 +29,12 @@ export { webFetchTool, createWebFetchTool } from './web-fetch.js';
 export type { WebFetchInput, WebFetchResult, WebFetchOptions } from './web-fetch.js';
 export { suggestTool, createSuggestTool } from './suggest.js';
 export type { SuggestInput, SuggestToolOptions } from './suggest.js';
+export { askUserTool, createAskUserTool } from './ask-user.js';
+export type { AskUserInput, AskUserResult, AskUserQuestion, AskUserOption, AskUserToolOptions, } from './ask-user.js';
+export { askUserSimpleTool, createAskUserSimpleTool } from './ask-user-simple.js';
+export type { AskUserSimpleInput, AskUserSimpleResult, AskUserSimpleToolOptions, } from './ask-user-simple.js';
+export { backlogReadTool, backlogWriteTool, createBacklogTools } from './backlog.js';
+export type { BacklogItem, BacklogStatus, BacklogItemType, BacklogPriority, BacklogReadInput, BacklogReadResult, BacklogWriteInput, BacklogWriteResult, BacklogToolOptions, } from './backlog.js';
 export declare const builtinTools: {
     readonly readFile: import("../types.js").Tool<import("./read-file.js").ReadFileInput>;
     readonly writeFile: import("../types.js").Tool<import("./write-file.js").WriteFileInput>;
@@ -42,8 +48,12 @@ export declare const builtinTools: {
     readonly todoRead: import("../types.js").Tool<import("./todo.js").TodoReadInput>;
     readonly webFetch: import("../types.js").Tool<import("./web-fetch.js").WebFetchInput>;
     readonly suggest: import("../types.js").Tool<import("./suggest.js").SuggestInput>;
+    readonly askUser: import("../types.js").Tool<import("./ask-user.js").AskUserInput>;
+    readonly askUserSimple: import("../types.js").Tool<import("./ask-user-simple.js").AskUserSimpleInput>;
+    readonly backlogRead: import("../types.js").Tool<import("./backlog.js").BacklogReadInput>;
+    readonly backlogWrite: import("../types.js").Tool<import("./backlog.js").BacklogWriteInput>;
 };
 /**
  * Array of all built-in tools
  */
-export declare const allBuiltinTools: readonly [import("../types.js").Tool<import("./read-file.js").ReadFileInput>, import("../types.js").Tool<import("./write-file.js").WriteFileInput>, import("../types.js").Tool<import("./bash.js").BashInput>, import("../types.js").Tool<import("./bash-output.js").BashOutputInput>, import("../types.js").Tool<import("./kill-shell.js").KillShellInput>, import("../types.js").Tool<import("./grep.js").GrepInput>, import("../types.js").Tool<import("./glob.js").GlobInput>, import("../types.js").Tool<import("./edit.js").EditInput>, import("../types.js").Tool<import("./todo.js").TodoWriteInput>, import("../types.js").Tool<import("./todo.js").TodoReadInput>, import("../types.js").Tool<import("./web-fetch.js").WebFetchInput>, import("../types.js").Tool<import("./suggest.js").SuggestInput>];
+export declare const allBuiltinTools: readonly [import("../types.js").Tool<import("./read-file.js").ReadFileInput>, import("../types.js").Tool<import("./write-file.js").WriteFileInput>, import("../types.js").Tool<import("./bash.js").BashInput>, import("../types.js").Tool<import("./bash-output.js").BashOutputInput>, import("../types.js").Tool<import("./kill-shell.js").KillShellInput>, import("../types.js").Tool<import("./grep.js").GrepInput>, import("../types.js").Tool<import("./glob.js").GlobInput>, import("../types.js").Tool<import("./edit.js").EditInput>, import("../types.js").Tool<import("./todo.js").TodoWriteInput>, import("../types.js").Tool<import("./todo.js").TodoReadInput>, import("../types.js").Tool<import("./web-fetch.js").WebFetchInput>, import("../types.js").Tool<import("./suggest.js").SuggestInput>, import("../types.js").Tool<import("./ask-user.js").AskUserInput>, import("../types.js").Tool<import("./ask-user-simple.js").AskUserSimpleInput>, import("../types.js").Tool<import("./backlog.js").BacklogReadInput>, import("../types.js").Tool<import("./backlog.js").BacklogWriteInput>];

package/dist/tools/builtin/index.js

@@ -29,6 +29,11 @@ export { createTaskTool, defaultAgentTypes } from './task.js';
 export { webFetchTool, createWebFetchTool } from './web-fetch.js';
 // Suggest tool (next action suggestions)
 export { suggestTool, createSuggestTool } from './suggest.js';
+// Ask user tools (user interaction)
+export { askUserTool, createAskUserTool } from './ask-user.js';
+export { askUserSimpleTool, createAskUserSimpleTool } from './ask-user-simple.js';
+// Backlog tools (file-based project backlog)
+export { backlogReadTool, backlogWriteTool, createBacklogTools } from './backlog.js';
 /**
  * Collection of all built-in tools for easy registration
  */
@@ -43,6 +48,9 @@ import { editTool } from './edit.js';
 import { todoWriteTool, todoReadTool } from './todo.js';
 import { webFetchTool } from './web-fetch.js';
 import { suggestTool } from './suggest.js';
+import { askUserTool } from './ask-user.js';
+import { askUserSimpleTool } from './ask-user-simple.js';
+import { backlogReadTool, backlogWriteTool } from './backlog.js';
 export const builtinTools = {
     readFile: readFileTool,
     writeFile: writeFileTool,
@@ -56,6 +64,10 @@ export const builtinTools = {
     todoRead: todoReadTool,
     webFetch: webFetchTool,
     suggest: suggestTool,
+    askUser: askUserTool,
+    askUserSimple: askUserSimpleTool,
+    backlogRead: backlogReadTool,
+    backlogWrite: backlogWriteTool,
 };
 /**
  * Array of all built-in tools
@@ -73,4 +85,8 @@ export const allBuiltinTools = [
     todoReadTool,
     webFetchTool,
     suggestTool,
+    askUserTool,
+    askUserSimpleTool,
+    backlogReadTool,
+    backlogWriteTool,
 ];