tarsk 0.4.4 → 0.4.6

package/dist/tools/todo.js

@@ -1,168 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { getDatabase } from "../database/database.js";
-import { fetchAllTodos, addTodos } from "../features/todos/todos.database.js";
-const todoSchema = Type.Object({
-    action: Type.Union([Type.Literal("add"), Type.Literal("update"), Type.Literal("list"), Type.Literal("delete")], {
-        description: "Operation to perform: 'add' creates new items, 'update' changes status, 'list' returns all items, 'delete' removes items.",
-    }),
-    descriptions: Type.Optional(Type.Array(Type.String(), {
-        description: "Todo item descriptions. Required for 'add'. Provide one or more descriptions to create multiple items at once.",
-    })),
-    ids: Type.Optional(Type.Array(Type.String(), {
-        description: "Todo item IDs. Required for 'update' and 'delete'. Provide one or more IDs to update or delete multiple items at once.",
-    })),
-    status: Type.Optional(Type.Union([Type.Literal("pending"), Type.Literal("working"), Type.Literal("done")], {
-        description: "New status for 'update'. Applied to all specified IDs. 'pending' = not started, 'working' = in progress, 'done' = complete.",
-    })),
-    assignedTo: Type.Optional(Type.String({
-        description: "Who items are assigned to. Defaults to 'agent'. Applied to all specified items.",
-    })),
-});
-export function createTodoTool(threadId) {
-    return {
-        name: "todo",
-        label: "todo",
-        description: "Manage todo items to break down the current task into 2 more items. Use 'add' to create items when planning work, 'update' to change an item's status as you progress (pending → working → done), 'list' to see all current items, and 'delete' to remove one. Marking an item done does not end the conversation — continue working on remaining items. Call 'list' at the end so the user sees a completion checklist.",
-        parameters: todoSchema,
-        execute: async (_toolCallId, { action, descriptions, ids, status, assignedTo }) => {
-            const db = await getDatabase();
-            const now = new Date().toISOString();
-            switch (action) {
-                case "add": {
-                    const validDescriptions = descriptions?.filter((d) => d.trim());
-                    if (!validDescriptions?.length) {
-                        return {
-                            content: [
-                                { type: "text", text: "Error: descriptions is required for 'add'" },
-                            ],
-                            details: undefined,
-                        };
-                    }
-                    const todosAfterAdd = await addTodos(threadId, validDescriptions, assignedTo ?? "agent");
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({ todos: todosAfterAdd }),
-                            },
-                        ],
-                        details: undefined,
-                    };
-                }
-                case "update": {
-                    if (!ids?.length) {
-                        return {
-                            content: [{ type: "text", text: "Error: ids is required for 'update'" }],
-                            details: undefined,
-                        };
-                    }
-                    const notFound = [];
-                    for (const id of ids) {
-                        const existing = await db.execute({
-                            sql: `SELECT id FROM todos WHERE id = ? AND threadId = ?`,
-                            args: [id, threadId],
-                        });
-                        if (existing.rows.length === 0) {
-                            notFound.push(id);
-                            continue;
-                        }
-                        const updates = [];
-                        const args = [];
-                        if (status) {
-                            updates.push("status = ?");
-                            args.push(status);
-                        }
-                        if (assignedTo !== undefined) {
-                            updates.push("assignedTo = ?");
-                            args.push(assignedTo);
-                        }
-                        updates.push("updatedAt = ?");
-                        args.push(now);
-                        args.push(id, threadId);
-                        await db.execute({
-                            sql: `UPDATE todos SET ${updates.join(", ")} WHERE id = ? AND threadId = ?`,
-                            args,
-                        });
-                    }
-                    if (notFound.length > 0) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Error: todos not found: ${notFound.join(", ")}`,
-                                },
-                            ],
-                            details: undefined,
-                        };
-                    }
-                    const todosAfterUpdate = await fetchAllTodos(db, threadId);
-                    // If all items are now done, delete them all
-                    const allDone = todosAfterUpdate.length > 0 && todosAfterUpdate.every((t) => t.status === "done");
-                    if (allDone) {
-                        await db.execute({
-                            sql: `DELETE FROM todos WHERE threadId = ?`,
-                            args: [threadId],
-                        });
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({ todos: allDone ? [] : todosAfterUpdate }),
-                            },
-                        ],
-                        details: undefined,
-                    };
-                }
-                case "list": {
-                    const todos = await fetchAllTodos(db, threadId);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({ todos }),
-                            },
-                        ],
-                        details: undefined,
-                    };
-                }
-                case "delete": {
-                    if (!ids?.length) {
-                        return {
-                            content: [{ type: "text", text: "Error: ids is required for 'delete'" }],
-                            details: undefined,
-                        };
-                    }
-                    for (const id of ids) {
-                        await db.execute({
-                            sql: `DELETE FROM todos WHERE id = ? AND threadId = ?`,
-                            args: [id, threadId],
-                        });
-                    }
-                    const todosAfterDelete = await fetchAllTodos(db, threadId);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({ todos: todosAfterDelete }),
-                            },
-                        ],
-                        details: undefined,
-                    };
-                }
-                default:
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Unknown action: ${String(action)}`,
-                            },
-                        ],
-                        details: undefined,
-                    };
-            }
-        },
-    };
-}
-export const todoTool = createTodoTool("");
-//# sourceMappingURL=todo.js.map

package/dist/tools/tool-helpers.d.ts

@@ -1,78 +0,0 @@
-/**
- * Tool helper utilities for reducing duplication in tool implementations
- *
- * Provides:
- * - Abort signal handling wrapper to eliminate boilerplate in tool execute functions
- * - Tool result formatting utilities for consistent output across tools
- */
-/**
- * Wraps an async operation with abort signal handling
- *
- * Eliminates the need for each tool to implement the same abort signal
- * setup, cleanup, and error handling logic.
- *
- * @param signal - Optional abort signal from the tool execution
- * @param operation - The async operation to perform, receives an abort check function
- * @returns Promise that resolves with the operation result or rejects if aborted
- *
- * @example
- * ```typescript
- * execute: async (_toolCallId, { path, content }, signal) => {
- *   return withAbortSignal(signal, async (isAborted) => {
- *     await ops.mkdir(dir);
- *     if (isAborted()) return { content: [], details: undefined };
- *     await ops.writeFile(absolutePath, content);
- *     return {
- *       content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` }],
- *       details: undefined,
- *     };
- *   });
- * }
- * ```
- */
-export declare function withAbortSignal<T>(signal: AbortSignal | undefined, operation: (abortCheck: () => boolean) => Promise<T>): Promise<T>;
-/**
- * Represents a notice message to be appended to tool output
- */
-export interface ToolNotice {
-    /** Human-readable notice message */
-    message: string;
-    /** Key for the details object */
-    detailKey: string;
-    /** Value to include in details */
-    detailValue: unknown;
-}
-/**
- * Formats tool output with optional notices appended
- *
- * Creates a consistent format for tool results that include notices
- * (e.g., truncation warnings, result limits reached) and details metadata.
- *
- * @param baseOutput - The primary tool output text
- * @param notices - Array of notices to append to the output
- * @returns Object containing formatted output and optional details
- *
- * @example
- * ```typescript
- * const notices: ToolNotice[] = [];
- *
- * if (resultLimitReached) {
- *   notices.push({
- *     message: `${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more`,
- *     detailKey: 'resultLimitReached',
- *     detailValue: effectiveLimit,
- *   });
- * }
- *
- * const { output, details } = formatToolOutput(truncation.content, notices);
- * return {
- *   content: [{ type: "text", text: output }],
- *   details,
- * };
- * ```
- */
-export declare function formatToolOutput(baseOutput: string, notices: ToolNotice[]): {
-    output: string;
-    details: Record<string, unknown> | undefined;
-};
-//# sourceMappingURL=tool-helpers.d.ts.map

package/dist/tools/tool-helpers.js

@@ -1,109 +0,0 @@
-/**
- * Tool helper utilities for reducing duplication in tool implementations
- *
- * Provides:
- * - Abort signal handling wrapper to eliminate boilerplate in tool execute functions
- * - Tool result formatting utilities for consistent output across tools
- */
-/**
- * Wraps an async operation with abort signal handling
- *
- * Eliminates the need for each tool to implement the same abort signal
- * setup, cleanup, and error handling logic.
- *
- * @param signal - Optional abort signal from the tool execution
- * @param operation - The async operation to perform, receives an abort check function
- * @returns Promise that resolves with the operation result or rejects if aborted
- *
- * @example
- * ```typescript
- * execute: async (_toolCallId, { path, content }, signal) => {
- *   return withAbortSignal(signal, async (isAborted) => {
- *     await ops.mkdir(dir);
- *     if (isAborted()) return { content: [], details: undefined };
- *     await ops.writeFile(absolutePath, content);
- *     return {
- *       content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` }],
- *       details: undefined,
- *     };
- *   });
- * }
- * ```
- */
-export async function withAbortSignal(signal, operation) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(new Error("Operation aborted"));
-            return;
-        }
-        let aborted = false;
-        const onAbort = () => {
-            aborted = true;
-            reject(new Error("Operation aborted"));
-        };
-        if (signal) {
-            signal.addEventListener("abort", onAbort, { once: true });
-        }
-        const cleanup = () => {
-            if (signal)
-                signal.removeEventListener("abort", onAbort);
-        };
-        const abortCheck = () => aborted;
-        operation(abortCheck)
-            .then((result) => {
-            cleanup();
-            if (!aborted)
-                resolve(result);
-        })
-            .catch((error) => {
-            cleanup();
-            if (!aborted)
-                reject(error);
-        });
-    });
-}
-/**
- * Formats tool output with optional notices appended
- *
- * Creates a consistent format for tool results that include notices
- * (e.g., truncation warnings, result limits reached) and details metadata.
- *
- * @param baseOutput - The primary tool output text
- * @param notices - Array of notices to append to the output
- * @returns Object containing formatted output and optional details
- *
- * @example
- * ```typescript
- * const notices: ToolNotice[] = [];
- *
- * if (resultLimitReached) {
- *   notices.push({
- *     message: `${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more`,
- *     detailKey: 'resultLimitReached',
- *     detailValue: effectiveLimit,
- *   });
- * }
- *
- * const { output, details } = formatToolOutput(truncation.content, notices);
- * return {
- *   content: [{ type: "text", text: output }],
- *   details,
- * };
- * ```
- */
-export function formatToolOutput(baseOutput, notices) {
-    let output = baseOutput;
-    const details = {};
-    if (notices.length > 0) {
-        const messages = notices.map((n) => n.message);
-        output += `\n\n[${messages.join(". ")}]`;
-        for (const notice of notices) {
-            details[notice.detailKey] = notice.detailValue;
-        }
-    }
-    return {
-        output,
-        details: Object.keys(details).length > 0 ? details : undefined,
-    };
-}
-//# sourceMappingURL=tool-helpers.js.map

package/dist/tools/truncate.d.ts

@@ -1,31 +0,0 @@
-/**
- * Shared truncation utilities for tool outputs.
- */
-export declare const DEFAULT_MAX_LINES = 2000;
-export declare const DEFAULT_MAX_BYTES: number;
-export declare const GREP_MAX_LINE_LENGTH = 500;
-export interface TruncationResult {
-    content: string;
-    truncated: boolean;
-    truncatedBy: "lines" | "bytes" | null;
-    totalLines: number;
-    totalBytes: number;
-    outputLines: number;
-    outputBytes: number;
-    lastLinePartial: boolean;
-    firstLineExceedsLimit: boolean;
-    maxLines: number;
-    maxBytes: number;
-}
-export interface TruncationOptions {
-    maxLines?: number;
-    maxBytes?: number;
-}
-export declare function formatSize(bytes: number): string;
-export declare function truncateHead(content: string, options?: TruncationOptions): TruncationResult;
-export declare function truncateTail(content: string, options?: TruncationOptions): TruncationResult;
-export declare function truncateLine(line: string, maxChars?: number): {
-    text: string;
-    wasTruncated: boolean;
-};
-//# sourceMappingURL=truncate.d.ts.map

package/dist/tools/truncate.js

@@ -1,164 +0,0 @@
-/**
- * Shared truncation utilities for tool outputs.
- */
-export const DEFAULT_MAX_LINES = 2000;
-export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
-export const GREP_MAX_LINE_LENGTH = 500;
-export function formatSize(bytes) {
-    if (bytes < 1024) {
-        return `${bytes}B`;
-    }
-    else if (bytes < 1024 * 1024) {
-        return `${(bytes / 1024).toFixed(1)}KB`;
-    }
-    else {
-        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-    }
-}
-export function truncateHead(content, options = {}) {
-    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
-    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-    const totalBytes = Buffer.byteLength(content, "utf-8");
-    const lines = content.split("\n");
-    const totalLines = lines.length;
-    if (totalLines <= maxLines && totalBytes <= maxBytes) {
-        return {
-            content,
-            truncated: false,
-            truncatedBy: null,
-            totalLines,
-            totalBytes,
-            outputLines: totalLines,
-            outputBytes: totalBytes,
-            lastLinePartial: false,
-            firstLineExceedsLimit: false,
-            maxLines,
-            maxBytes,
-        };
-    }
-    const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
-    if (firstLineBytes > maxBytes) {
-        return {
-            content: "",
-            truncated: true,
-            truncatedBy: "bytes",
-            totalLines,
-            totalBytes,
-            outputLines: 0,
-            outputBytes: 0,
-            lastLinePartial: false,
-            firstLineExceedsLimit: true,
-            maxLines,
-            maxBytes,
-        };
-    }
-    const outputLinesArr = [];
-    let outputBytesCount = 0;
-    let truncatedBy = "lines";
-    for (let i = 0; i < lines.length && i < maxLines; i++) {
-        const line = lines[i];
-        const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0);
-        if (outputBytesCount + lineBytes > maxBytes) {
-            truncatedBy = "bytes";
-            break;
-        }
-        outputLinesArr.push(line);
-        outputBytesCount += lineBytes;
-    }
-    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
-        truncatedBy = "lines";
-    }
-    const outputContent = outputLinesArr.join("\n");
-    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
-    return {
-        content: outputContent,
-        truncated: true,
-        truncatedBy,
-        totalLines,
-        totalBytes,
-        outputLines: outputLinesArr.length,
-        outputBytes: finalOutputBytes,
-        lastLinePartial: false,
-        firstLineExceedsLimit: false,
-        maxLines,
-        maxBytes,
-    };
-}
-export function truncateTail(content, options = {}) {
-    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
-    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-    const totalBytes = Buffer.byteLength(content, "utf-8");
-    const lines = content.split("\n");
-    const totalLines = lines.length;
-    if (totalLines <= maxLines && totalBytes <= maxBytes) {
-        return {
-            content,
-            truncated: false,
-            truncatedBy: null,
-            totalLines,
-            totalBytes,
-            outputLines: totalLines,
-            outputBytes: totalBytes,
-            lastLinePartial: false,
-            firstLineExceedsLimit: false,
-            maxLines,
-            maxBytes,
-        };
-    }
-    const outputLinesArr = [];
-    let outputBytesCount = 0;
-    let truncatedBy = "lines";
-    let lastLinePartial = false;
-    for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
-        const line = lines[i];
-        const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0);
-        if (outputBytesCount + lineBytes > maxBytes) {
-            truncatedBy = "bytes";
-            if (outputLinesArr.length === 0) {
-                const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
-                outputLinesArr.unshift(truncatedLine);
-                outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
-                lastLinePartial = true;
-            }
-            break;
-        }
-        outputLinesArr.unshift(line);
-        outputBytesCount += lineBytes;
-    }
-    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
-        truncatedBy = "lines";
-    }
-    const outputContent = outputLinesArr.join("\n");
-    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
-    return {
-        content: outputContent,
-        truncated: true,
-        truncatedBy,
-        totalLines,
-        totalBytes,
-        outputLines: outputLinesArr.length,
-        outputBytes: finalOutputBytes,
-        lastLinePartial,
-        firstLineExceedsLimit: false,
-        maxLines,
-        maxBytes,
-    };
-}
-function truncateStringToBytesFromEnd(str, maxBytes) {
-    const buf = Buffer.from(str, "utf-8");
-    if (buf.length <= maxBytes) {
-        return str;
-    }
-    let start = buf.length - maxBytes;
-    while (start < buf.length && (buf[start] & 0xc0) === 0x80) {
-        start++;
-    }
-    return buf.slice(start).toString("utf-8");
-}
-export function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
-    if (line.length <= maxChars) {
-        return { text: line, wasTruncated: false };
-    }
-    return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
-}
-//# sourceMappingURL=truncate.js.map

package/dist/tools/write.d.ts

@@ -1,21 +0,0 @@
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-declare const writeSchema: import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TString;
-    content: import("@sinclair/typebox").TString;
-}>;
-export type WriteToolInput = Static<typeof writeSchema>;
-export interface WriteOperations {
-    writeFile: (absolutePath: string, content: string) => Promise<void>;
-    mkdir: (dir: string) => Promise<void>;
-}
-export interface WriteToolOptions {
-    operations?: WriteOperations;
-}
-export declare function createWriteTool(cwd: string, options?: WriteToolOptions): AgentTool<typeof writeSchema>;
-export declare const writeTool: AgentTool<import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TString;
-    content: import("@sinclair/typebox").TString;
-}>, any>;
-export {};
-//# sourceMappingURL=write.d.ts.map

package/dist/tools/write.js

@@ -1,65 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { mkdir as fsMkdir, writeFile as fsWriteFile } from "fs/promises";
-import { dirname } from "path";
-import { resolveToCwd, validatePathWithinCwd } from "./path-utils.js";
-const writeSchema = Type.Object({
-    path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
-    content: Type.String({ description: "Content to write to the file" }),
-});
-const defaultWriteOperations = {
-    writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
-    mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => { }),
-};
-export function createWriteTool(cwd, options) {
-    const ops = options?.operations ?? defaultWriteOperations;
-    return {
-        name: "write",
-        label: "write",
-        description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
-        parameters: writeSchema,
-        execute: async (_toolCallId, { path, content }, signal) => {
-            const absolutePath = resolveToCwd(path, cwd);
-            validatePathWithinCwd(absolutePath, cwd);
-            const dir = dirname(absolutePath);
-            return new Promise((resolve, reject) => {
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                let aborted = false;
-                const onAbort = () => {
-                    aborted = true;
-                    reject(new Error("Operation aborted"));
-                };
-                if (signal)
-                    signal.addEventListener("abort", onAbort, { once: true });
-                void (async () => {
-                    try {
-                        await ops.mkdir(dir);
-                        if (aborted)
-                            return;
-                        await ops.writeFile(absolutePath, content);
-                        if (aborted)
-                            return;
-                        if (signal)
-                            signal.removeEventListener("abort", onAbort);
-                        resolve({
-                            content: [
-                                { type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` },
-                            ],
-                            details: undefined,
-                        });
-                    }
-                    catch (error) {
-                        if (signal)
-                            signal.removeEventListener("abort", onAbort);
-                        if (!aborted)
-                            reject(error);
-                    }
-                })();
-            });
-        },
-    };
-}
-export const writeTool = createWriteTool(process.cwd());
-//# sourceMappingURL=write.js.map