chore(ipuaro): release v0.20.0

Added IndexProject and ExecuteTool use cases:
- IndexProject orchestrates full indexing pipeline
- ExecuteTool manages tool execution with confirmation
- Refactored CLI index and TUI /reindex commands
- Refactored HandleMessage to use ExecuteTool
- Added 19 unit tests for IndexProject
- All 1463 tests passing, 91.58% branch coverage

packages/ipuaro/src/application/use-cases/ExecuteTool.ts

@@ -0,0 +1,201 @@
+import { randomUUID } from "node:crypto"
+import type { Session } from "../../domain/entities/Session.js"
+import type { ISessionStorage } from "../../domain/services/ISessionStorage.js"
+import type { IStorage } from "../../domain/services/IStorage.js"
+import type { DiffInfo, ToolContext } from "../../domain/services/ITool.js"
+import type { ToolCall } from "../../domain/value-objects/ToolCall.js"
+import { createErrorResult, type ToolResult } from "../../domain/value-objects/ToolResult.js"
+import { createUndoEntry } from "../../domain/value-objects/UndoEntry.js"
+import type { IToolRegistry } from "../interfaces/IToolRegistry.js"
+
+/**
+ * Confirmation handler callback type.
+ */
+export type ConfirmationHandler = (message: string, diff?: DiffInfo) => Promise<boolean>
+
+/**
+ * Progress handler callback type.
+ */
+export type ProgressHandler = (message: string) => void
+
+/**
+ * Options for ExecuteTool.
+ */
+export interface ExecuteToolOptions {
+    /** Auto-apply edits without confirmation */
+    autoApply?: boolean
+    /** Confirmation handler */
+    onConfirmation?: ConfirmationHandler
+    /** Progress handler */
+    onProgress?: ProgressHandler
+}
+
+/**
+ * Result of tool execution.
+ */
+export interface ExecuteToolResult {
+    result: ToolResult
+    undoEntryCreated: boolean
+    undoEntryId?: string
+}
+
+/**
+ * Use case for executing a single tool.
+ * Orchestrates tool execution with:
+ * - Parameter validation
+ * - Confirmation flow
+ * - Undo stack management
+ * - Storage updates
+ */
+export class ExecuteTool {
+    private readonly storage: IStorage
+    private readonly sessionStorage: ISessionStorage
+    private readonly tools: IToolRegistry
+    private readonly projectRoot: string
+    private lastUndoEntryId?: string
+
+    constructor(
+        storage: IStorage,
+        sessionStorage: ISessionStorage,
+        tools: IToolRegistry,
+        projectRoot: string,
+    ) {
+        this.storage = storage
+        this.sessionStorage = sessionStorage
+        this.tools = tools
+        this.projectRoot = projectRoot
+    }
+
+    /**
+     * Execute a tool call.
+     *
+     * @param toolCall - The tool call to execute
+     * @param session - Current session (for undo stack)
+     * @param options - Execution options
+     * @returns Execution result
+     */
+    async execute(
+        toolCall: ToolCall,
+        session: Session,
+        options: ExecuteToolOptions = {},
+    ): Promise<ExecuteToolResult> {
+        this.lastUndoEntryId = undefined
+        const startTime = Date.now()
+        const tool = this.tools.get(toolCall.name)
+
+        if (!tool) {
+            return {
+                result: createErrorResult(
+                    toolCall.id,
+                    `Unknown tool: ${toolCall.name}`,
+                    Date.now() - startTime,
+                ),
+                undoEntryCreated: false,
+            }
+        }
+
+        const validationError = tool.validateParams(toolCall.params)
+        if (validationError) {
+            return {
+                result: createErrorResult(toolCall.id, validationError, Date.now() - startTime),
+                undoEntryCreated: false,
+            }
+        }
+
+        const context = this.buildToolContext(toolCall, session, options)
+
+        try {
+            const result = await tool.execute(toolCall.params, context)
+
+            return {
+                result,
+                undoEntryCreated: this.lastUndoEntryId !== undefined,
+                undoEntryId: this.lastUndoEntryId,
+            }
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error)
+            return {
+                result: createErrorResult(toolCall.id, errorMessage, Date.now() - startTime),
+                undoEntryCreated: false,
+            }
+        }
+    }
+
+    /**
+     * Build tool context for execution.
+     */
+    private buildToolContext(
+        toolCall: ToolCall,
+        session: Session,
+        options: ExecuteToolOptions,
+    ): ToolContext {
+        return {
+            projectRoot: this.projectRoot,
+            storage: this.storage,
+            requestConfirmation: async (msg: string, diff?: DiffInfo) => {
+                return this.handleConfirmation(msg, diff, toolCall, session, options)
+            },
+            onProgress: (msg: string) => {
+                options.onProgress?.(msg)
+            },
+        }
+    }
+
+    /**
+     * Handle confirmation for tool actions.
+     */
+    private async handleConfirmation(
+        msg: string,
+        diff: DiffInfo | undefined,
+        toolCall: ToolCall,
+        session: Session,
+        options: ExecuteToolOptions,
+    ): Promise<boolean> {
+        if (options.autoApply) {
+            if (diff) {
+                this.lastUndoEntryId = await this.createUndoEntry(diff, toolCall, session)
+            }
+            return true
+        }
+
+        if (options.onConfirmation) {
+            const confirmed = await options.onConfirmation(msg, diff)
+
+            if (confirmed && diff) {
+                this.lastUndoEntryId = await this.createUndoEntry(diff, toolCall, session)
+            }
+
+            return confirmed
+        }
+
+        if (diff) {
+            this.lastUndoEntryId = await this.createUndoEntry(diff, toolCall, session)
+        }
+        return true
+    }
+
+    /**
+     * Create undo entry from diff.
+     */
+    private async createUndoEntry(
+        diff: DiffInfo,
+        toolCall: ToolCall,
+        session: Session,
+    ): Promise<string> {
+        const entryId = randomUUID()
+        const entry = createUndoEntry(
+            entryId,
+            diff.filePath,
+            diff.oldLines,
+            diff.newLines,
+            `${toolCall.name}: ${diff.filePath}`,
+            toolCall.id,
+        )
+
+        session.addUndoEntry(entry)
+        await this.sessionStorage.pushUndoEntry(session.id, entry)
+        session.stats.editsApplied++
+
+        return entryId
+    }
+}