agentfs-sdk 0.1.0-pre.1

package/dist/filesystem.d.ts

@@ -0,0 +1,68 @@
+import { Database } from '@tursodatabase/database';
+export interface Stats {
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    size: number;
+    atime: number;
+    mtime: number;
+    ctime: number;
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+}
+export declare class Filesystem {
+    private db;
+    private initialized;
+    private rootIno;
+    constructor(db: Database);
+    private initialize;
+    /**
+     * Ensure root directory exists
+     */
+    private ensureRoot;
+    /**
+     * Normalize a path
+     */
+    private normalizePath;
+    /**
+     * Split path into components
+     */
+    private splitPath;
+    /**
+     * Resolve a path to an inode number
+     */
+    private resolvePath;
+    /**
+     * Get parent directory inode and basename from path
+     */
+    private resolveParent;
+    /**
+     * Create an inode
+     */
+    private createInode;
+    /**
+     * Create a directory entry
+     */
+    private createDentry;
+    /**
+     * Ensure parent directories exist
+     */
+    private ensureParentDirs;
+    /**
+     * Get link count for an inode
+     */
+    private getLinkCount;
+    writeFile(path: string, content: string | Buffer): Promise<void>;
+    private updateFileContent;
+    readFile(path: string): Promise<string>;
+    readdir(path: string): Promise<string[]>;
+    deleteFile(path: string): Promise<void>;
+    stat(path: string): Promise<Stats>;
+    /**
+     * Wait for initialization to complete
+     */
+    ready(): Promise<void>;
+}

package/dist/filesystem.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Filesystem = void 0;
+// File types for mode field
+const S_IFMT = 0o170000; // File type mask
+const S_IFREG = 0o100000; // Regular file
+const S_IFDIR = 0o040000; // Directory
+const S_IFLNK = 0o120000; // Symbolic link
+// Default permissions
+const DEFAULT_FILE_MODE = S_IFREG | 0o644; // Regular file, rw-r--r--
+const DEFAULT_DIR_MODE = S_IFDIR | 0o755; // Directory, rwxr-xr-x
+class Filesystem {
+    constructor(db) {
+        this.rootIno = 1;
+        this.db = db;
+        this.initialized = this.initialize();
+    }
+    async initialize() {
+        // Ensure database is connected
+        try {
+            await this.db.connect();
+        }
+        catch (error) {
+            // Ignore "already connected" errors
+            if (!error.message?.includes('already')) {
+                throw error;
+            }
+        }
+        // Create the inode table
+        await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS fs_inode (
+        ino INTEGER PRIMARY KEY AUTOINCREMENT,
+        mode INTEGER NOT NULL,
+        uid INTEGER NOT NULL DEFAULT 0,
+        gid INTEGER NOT NULL DEFAULT 0,
+        size INTEGER NOT NULL DEFAULT 0,
+        atime INTEGER NOT NULL,
+        mtime INTEGER NOT NULL,
+        ctime INTEGER NOT NULL
+      )
+    `);
+        // Create the directory entry table
+        await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS fs_dentry (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        parent_ino INTEGER NOT NULL,
+        ino INTEGER NOT NULL,
+        UNIQUE(parent_ino, name)
+      )
+    `);
+        // Create index for efficient path lookups
+        await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_fs_dentry_parent
+      ON fs_dentry(parent_ino, name)
+    `);
+        // Create the data blocks table
+        await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS fs_data (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        ino INTEGER NOT NULL,
+        offset INTEGER NOT NULL,
+        size INTEGER NOT NULL,
+        data BLOB NOT NULL
+      )
+    `);
+        // Create index for efficient data block lookups
+        await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_fs_data_ino_offset
+      ON fs_data(ino, offset)
+    `);
+        // Create the symlink table
+        await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS fs_symlink (
+        ino INTEGER PRIMARY KEY,
+        target TEXT NOT NULL
+      )
+    `);
+        // Create root directory if it doesn't exist
+        await this.ensureRoot();
+    }
+    /**
+     * Ensure root directory exists
+     */
+    async ensureRoot() {
+        const stmt = this.db.prepare('SELECT ino FROM fs_inode WHERE ino = ?');
+        const root = await stmt.get(this.rootIno);
+        if (!root) {
+            const now = Math.floor(Date.now() / 1000);
+            const insertStmt = this.db.prepare(`
+        INSERT INTO fs_inode (ino, mode, uid, gid, size, atime, mtime, ctime)
+        VALUES (?, ?, 0, 0, 0, ?, ?, ?)
+      `);
+            await insertStmt.run(this.rootIno, DEFAULT_DIR_MODE, now, now, now);
+        }
+    }
+    /**
+     * Normalize a path
+     */
+    normalizePath(path) {
+        // Remove trailing slashes except for root
+        const normalized = path.replace(/\/+$/, '') || '/';
+        // Ensure leading slash
+        return normalized.startsWith('/') ? normalized : '/' + normalized;
+    }
+    /**
+     * Split path into components
+     */
+    splitPath(path) {
+        const normalized = this.normalizePath(path);
+        if (normalized === '/')
+            return [];
+        return normalized.split('/').filter(p => p);
+    }
+    /**
+     * Resolve a path to an inode number
+     */
+    async resolvePath(path) {
+        await this.initialized;
+        const normalized = this.normalizePath(path);
+        // Root directory
+        if (normalized === '/') {
+            return this.rootIno;
+        }
+        const parts = this.splitPath(normalized);
+        let currentIno = this.rootIno;
+        // Traverse the path
+        for (const name of parts) {
+            const stmt = this.db.prepare(`
+        SELECT ino FROM fs_dentry
+        WHERE parent_ino = ? AND name = ?
+      `);
+            const result = await stmt.get(currentIno, name);
+            if (!result) {
+                return null;
+            }
+            currentIno = result.ino;
+        }
+        return currentIno;
+    }
+    /**
+     * Get parent directory inode and basename from path
+     */
+    async resolveParent(path) {
+        const normalized = this.normalizePath(path);
+        if (normalized === '/') {
+            return null; // Root has no parent
+        }
+        const parts = this.splitPath(normalized);
+        const name = parts[parts.length - 1];
+        const parentPath = parts.length === 1 ? '/' : '/' + parts.slice(0, -1).join('/');
+        const parentIno = await this.resolvePath(parentPath);
+        if (parentIno === null) {
+            return null;
+        }
+        return { parentIno, name };
+    }
+    /**
+     * Create an inode
+     */
+    async createInode(mode, uid = 0, gid = 0) {
+        const now = Math.floor(Date.now() / 1000);
+        const stmt = this.db.prepare(`
+      INSERT INTO fs_inode (mode, uid, gid, size, atime, mtime, ctime)
+      VALUES (?, ?, ?, 0, ?, ?, ?)
+    `);
+        const result = await stmt.run(mode, uid, gid, now, now, now);
+        return Number(result.lastInsertRowid);
+    }
+    /**
+     * Create a directory entry
+     */
+    async createDentry(parentIno, name, ino) {
+        const stmt = this.db.prepare(`
+      INSERT INTO fs_dentry (name, parent_ino, ino)
+      VALUES (?, ?, ?)
+    `);
+        await stmt.run(name, parentIno, ino);
+    }
+    /**
+     * Ensure parent directories exist
+     */
+    async ensureParentDirs(path) {
+        const parts = this.splitPath(path);
+        // Remove the filename, keep only directory parts
+        parts.pop();
+        let currentIno = this.rootIno;
+        let currentPath = '';
+        for (const name of parts) {
+            currentPath += '/' + name;
+            // Check if this directory exists
+            const stmt = this.db.prepare(`
+        SELECT ino FROM fs_dentry
+        WHERE parent_ino = ? AND name = ?
+      `);
+            const result = await stmt.get(currentIno, name);
+            if (!result) {
+                // Create directory
+                const dirIno = await this.createInode(DEFAULT_DIR_MODE);
+                await this.createDentry(currentIno, name, dirIno);
+                currentIno = dirIno;
+            }
+            else {
+                currentIno = result.ino;
+            }
+        }
+    }
+    /**
+     * Get link count for an inode
+     */
+    async getLinkCount(ino) {
+        const stmt = this.db.prepare('SELECT COUNT(*) as count FROM fs_dentry WHERE ino = ?');
+        const result = await stmt.get(ino);
+        return result.count;
+    }
+    async writeFile(path, content) {
+        await this.initialized;
+        // Ensure parent directories exist
+        await this.ensureParentDirs(path);
+        // Check if file already exists
+        const ino = await this.resolvePath(path);
+        if (ino !== null) {
+            // Update existing file
+            await this.updateFileContent(ino, content);
+        }
+        else {
+            // Create new file
+            const parent = await this.resolveParent(path);
+            if (!parent) {
+                throw new Error(`ENOENT: parent directory does not exist: ${path}`);
+            }
+            // Create inode
+            const fileIno = await this.createInode(DEFAULT_FILE_MODE);
+            // Create directory entry
+            await this.createDentry(parent.parentIno, parent.name, fileIno);
+            // Write content
+            await this.updateFileContent(fileIno, content);
+        }
+    }
+    async updateFileContent(ino, content) {
+        const buffer = typeof content === 'string' ? Buffer.from(content, 'utf-8') : content;
+        const now = Math.floor(Date.now() / 1000);
+        // Delete existing data blocks
+        const deleteStmt = this.db.prepare('DELETE FROM fs_data WHERE ino = ?');
+        await deleteStmt.run(ino);
+        // Write data in chunks (for now, single chunk, but can be extended)
+        const stmt = this.db.prepare(`
+      INSERT INTO fs_data (ino, offset, size, data)
+      VALUES (?, ?, ?, ?)
+    `);
+        await stmt.run(ino, 0, buffer.length, buffer);
+        // Update inode size and mtime
+        const updateStmt = this.db.prepare(`
+      UPDATE fs_inode
+      SET size = ?, mtime = ?
+      WHERE ino = ?
+    `);
+        await updateStmt.run(buffer.length, now, ino);
+    }
+    async readFile(path) {
+        await this.initialized;
+        const ino = await this.resolvePath(path);
+        if (ino === null) {
+            throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+        }
+        // Get all data blocks
+        const stmt = this.db.prepare(`
+      SELECT data FROM fs_data
+      WHERE ino = ?
+      ORDER BY offset ASC
+    `);
+        const rows = await stmt.all(ino);
+        if (rows.length === 0) {
+            return '';
+        }
+        // Concatenate all chunks
+        const buffers = rows.map(row => row.data);
+        const combined = Buffer.concat(buffers);
+        // Update atime
+        const now = Math.floor(Date.now() / 1000);
+        const updateStmt = this.db.prepare('UPDATE fs_inode SET atime = ? WHERE ino = ?');
+        await updateStmt.run(now, ino);
+        return combined.toString('utf-8');
+    }
+    async readdir(path) {
+        await this.initialized;
+        const ino = await this.resolvePath(path);
+        if (ino === null) {
+            throw new Error(`ENOENT: no such file or directory, scandir '${path}'`);
+        }
+        // Get all directory entries
+        const stmt = this.db.prepare(`
+      SELECT name FROM fs_dentry
+      WHERE parent_ino = ?
+      ORDER BY name ASC
+    `);
+        const rows = await stmt.all(ino);
+        return rows.map(row => row.name);
+    }
+    async deleteFile(path) {
+        await this.initialized;
+        const ino = await this.resolvePath(path);
+        if (ino === null) {
+            throw new Error(`ENOENT: no such file or directory, unlink '${path}'`);
+        }
+        const parent = await this.resolveParent(path);
+        if (!parent) {
+            throw new Error(`Cannot delete root directory`);
+        }
+        // Delete the directory entry
+        const stmt = this.db.prepare(`
+      DELETE FROM fs_dentry
+      WHERE parent_ino = ? AND name = ?
+    `);
+        await stmt.run(parent.parentIno, parent.name);
+        // Check if this was the last link to the inode
+        const linkCount = await this.getLinkCount(ino);
+        if (linkCount === 0) {
+            // Delete the inode and all associated data (CASCADE will handle data blocks)
+            const deleteStmt = this.db.prepare('DELETE FROM fs_inode WHERE ino = ?');
+            await deleteStmt.run(ino);
+        }
+    }
+    async stat(path) {
+        await this.initialized;
+        const ino = await this.resolvePath(path);
+        if (ino === null) {
+            throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+        }
+        const stmt = this.db.prepare(`
+      SELECT ino, mode, uid, gid, size, atime, mtime, ctime
+      FROM fs_inode
+      WHERE ino = ?
+    `);
+        const row = await stmt.get(ino);
+        if (!row) {
+            throw new Error(`Inode not found: ${ino}`);
+        }
+        const nlink = await this.getLinkCount(ino);
+        return {
+            ino: row.ino,
+            mode: row.mode,
+            nlink: nlink,
+            uid: row.uid,
+            gid: row.gid,
+            size: row.size,
+            atime: row.atime,
+            mtime: row.mtime,
+            ctime: row.ctime,
+            isFile: () => (row.mode & S_IFMT) === S_IFREG,
+            isDirectory: () => (row.mode & S_IFMT) === S_IFDIR,
+            isSymbolicLink: () => (row.mode & S_IFMT) === S_IFLNK,
+        };
+    }
+    /**
+     * Wait for initialization to complete
+     */
+    async ready() {
+        await this.initialized;
+    }
+}
+exports.Filesystem = Filesystem;

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { Database } from '@tursodatabase/database';
+import { KvStore } from './kvstore';
+import { Filesystem } from './filesystem';
+import { ToolCalls } from './toolcalls';
+export declare class AgentFS {
+    private db;
+    readonly kv: KvStore;
+    readonly fs: Filesystem;
+    readonly tools: ToolCalls;
+    /**
+     * Private constructor - use AgentFS.create() instead
+     */
+    private constructor();
+    /**
+     * Create a new AgentFS instance (async factory method)
+     * @param dbPath Path to the database file (defaults to ':memory:')
+     * @returns Fully initialized AgentFS instance
+     */
+    static create(dbPath?: string): Promise<AgentFS>;
+    /**
+     * Get the underlying Database instance
+     */
+    getDatabase(): Database;
+    /**
+     * Close the database connection
+     */
+    close(): Promise<void>;
+}
+export { KvStore } from './kvstore';
+export { Filesystem } from './filesystem';
+export type { Stats } from './filesystem';
+export { ToolCalls } from './toolcalls';
+export type { ToolCall, ToolCallStats } from './toolcalls';

package/dist/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCalls = exports.Filesystem = exports.KvStore = exports.AgentFS = void 0;
+const database_1 = require("@tursodatabase/database");
+const kvstore_1 = require("./kvstore");
+const filesystem_1 = require("./filesystem");
+const toolcalls_1 = require("./toolcalls");
+class AgentFS {
+    /**
+     * Private constructor - use AgentFS.create() instead
+     */
+    constructor(db, kv, fs, tools) {
+        this.db = db;
+        this.kv = kv;
+        this.fs = fs;
+        this.tools = tools;
+    }
+    /**
+     * Create a new AgentFS instance (async factory method)
+     * @param dbPath Path to the database file (defaults to ':memory:')
+     * @returns Fully initialized AgentFS instance
+     */
+    static async create(dbPath = ':memory:') {
+        const db = new database_1.Database(dbPath);
+        // Connect to the database to ensure it's created
+        await db.connect();
+        // Create subsystems
+        const kv = new kvstore_1.KvStore(db);
+        const fs = new filesystem_1.Filesystem(db);
+        const tools = new toolcalls_1.ToolCalls(db);
+        // Wait for all subsystems to initialize
+        await kv.ready();
+        await fs.ready();
+        await tools.ready();
+        // Return fully initialized instance
+        return new AgentFS(db, kv, fs, tools);
+    }
+    /**
+     * Get the underlying Database instance
+     */
+    getDatabase() {
+        return this.db;
+    }
+    /**
+     * Close the database connection
+     */
+    async close() {
+        await this.db.close();
+    }
+}
+exports.AgentFS = AgentFS;
+var kvstore_2 = require("./kvstore");
+Object.defineProperty(exports, "KvStore", { enumerable: true, get: function () { return kvstore_2.KvStore; } });
+var filesystem_2 = require("./filesystem");
+Object.defineProperty(exports, "Filesystem", { enumerable: true, get: function () { return filesystem_2.Filesystem; } });
+var toolcalls_2 = require("./toolcalls");
+Object.defineProperty(exports, "ToolCalls", { enumerable: true, get: function () { return toolcalls_2.ToolCalls; } });

package/dist/kvstore.d.ts

@@ -0,0 +1,14 @@
+import { Database } from '@tursodatabase/database';
+export declare class KvStore {
+    private db;
+    private initialized;
+    constructor(db: Database);
+    private initialize;
+    set(key: string, value: any): Promise<void>;
+    get(key: string): Promise<any>;
+    delete(key: string): Promise<void>;
+    /**
+     * Wait for initialization to complete
+     */
+    ready(): Promise<void>;
+}

package/dist/kvstore.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KvStore = void 0;
+class KvStore {
+    constructor(db) {
+        this.db = db;
+        this.initialized = this.initialize();
+    }
+    async initialize() {
+        // Ensure database is connected
+        try {
+            await this.db.connect();
+        }
+        catch (error) {
+            // Ignore "already connected" errors
+            if (!error.message?.includes('already')) {
+                throw error;
+            }
+        }
+        // Create the key-value store table if it doesn't exist
+        await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS kv_store (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        created_at INTEGER DEFAULT (unixepoch()),
+        updated_at INTEGER DEFAULT (unixepoch())
+      )
+    `);
+        // Create index on created_at for potential queries
+        await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_kv_store_created_at
+      ON kv_store(created_at)
+    `);
+    }
+    async set(key, value) {
+        await this.initialized;
+        // Serialize the value to JSON
+        const serializedValue = JSON.stringify(value);
+        // Use prepared statement to insert or update
+        const stmt = this.db.prepare(`
+      INSERT INTO kv_store (key, value, updated_at)
+      VALUES (?, ?, unixepoch())
+      ON CONFLICT(key) DO UPDATE SET
+        value = excluded.value,
+        updated_at = unixepoch()
+    `);
+        await stmt.run(key, serializedValue);
+    }
+    async get(key) {
+        await this.initialized;
+        const stmt = this.db.prepare(`SELECT value FROM kv_store WHERE key = ?`);
+        const row = await stmt.get(key);
+        if (!row) {
+            return undefined;
+        }
+        // Deserialize the JSON value
+        return JSON.parse(row.value);
+    }
+    async delete(key) {
+        await this.initialized;
+        const stmt = this.db.prepare(`DELETE FROM kv_store WHERE key = ?`);
+        await stmt.run(key);
+    }
+    /**
+     * Wait for initialization to complete
+     */
+    async ready() {
+        await this.initialized;
+    }
+}
+exports.KvStore = KvStore;

package/dist/toolcalls.d.ts

@@ -0,0 +1,69 @@
+import { Database } from '@tursodatabase/database';
+export interface ToolCall {
+    id: number;
+    name: string;
+    parameters?: any;
+    result?: any;
+    error?: string;
+    status: 'pending' | 'success' | 'error';
+    started_at: number;
+    completed_at?: number;
+    duration_ms?: number;
+}
+export interface ToolCallStats {
+    name: string;
+    total_calls: number;
+    successful: number;
+    failed: number;
+    avg_duration_ms: number;
+}
+export declare class ToolCalls {
+    private db;
+    private initialized;
+    constructor(db: Database);
+    private initialize;
+    /**
+     * Start a new tool call and mark it as pending
+     * Returns the ID of the created tool call record
+     */
+    start(name: string, parameters?: any): Promise<number>;
+    /**
+     * Mark a tool call as successful
+     */
+    success(id: number, result?: any): Promise<void>;
+    /**
+     * Mark a tool call as failed
+     */
+    error(id: number, error: string): Promise<void>;
+    /**
+     * Record a completed tool call
+     * Either result or error should be provided, not both
+     * Returns the ID of the created tool call record
+     */
+    record(name: string, started_at: number, completed_at: number, parameters?: any, result?: any, error?: string): Promise<number>;
+    /**
+     * Get a specific tool call by ID
+     */
+    get(id: number): Promise<ToolCall | undefined>;
+    /**
+     * Query tool calls by name
+     */
+    getByName(name: string, limit?: number): Promise<ToolCall[]>;
+    /**
+     * Query recent tool calls
+     */
+    getRecent(since: number, limit?: number): Promise<ToolCall[]>;
+    /**
+     * Get performance statistics for all tools
+     * Only includes completed calls (success or failed), not pending ones
+     */
+    getStats(): Promise<ToolCallStats[]>;
+    /**
+     * Helper to convert database row to ToolCall object
+     */
+    private rowToToolCall;
+    /**
+     * Wait for initialization to complete
+     */
+    ready(): Promise<void>;
+}

package/dist/toolcalls.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCalls = void 0;
+class ToolCalls {
+    constructor(db) {
+        this.db = db;
+        this.initialized = this.initialize();
+    }
+    async initialize() {
+        // Ensure database is connected
+        try {
+            await this.db.connect();
+        }
+        catch (error) {
+            // Ignore "already connected" errors
+            if (!error.message?.includes('already')) {
+                throw error;
+            }
+        }
+        // Create the tool_calls table
+        await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tool_calls (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        parameters TEXT,
+        result TEXT,
+        error TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        started_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        duration_ms INTEGER
+      )
+    `);
+        // Create indexes for efficient queries
+        await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_name
+      ON tool_calls(name)
+    `);
+        await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_started_at
+      ON tool_calls(started_at)
+    `);
+    }
+    /**
+     * Start a new tool call and mark it as pending
+     * Returns the ID of the created tool call record
+     */
+    async start(name, parameters) {
+        await this.initialized;
+        const serializedParams = parameters !== undefined ? JSON.stringify(parameters) : null;
+        const started_at = Math.floor(Date.now() / 1000);
+        const stmt = this.db.prepare(`
+      INSERT INTO tool_calls (name, parameters, status, started_at)
+      VALUES (?, ?, 'pending', ?)
+    `);
+        const result = await stmt.run(name, serializedParams, started_at);
+        return Number(result.lastInsertRowid);
+    }
+    /**
+     * Mark a tool call as successful
+     */
+    async success(id, result) {
+        await this.initialized;
+        const serializedResult = result !== undefined ? JSON.stringify(result) : null;
+        const completed_at = Math.floor(Date.now() / 1000);
+        // Get the started_at time to calculate duration
+        const getStmt = this.db.prepare('SELECT started_at FROM tool_calls WHERE id = ?');
+        const row = await getStmt.get(id);
+        if (!row) {
+            throw new Error(`Tool call with ID ${id} not found`);
+        }
+        const duration_ms = (completed_at - row.started_at) * 1000;
+        const updateStmt = this.db.prepare(`
+      UPDATE tool_calls
+      SET status = 'success', result = ?, completed_at = ?, duration_ms = ?
+      WHERE id = ?
+    `);
+        await updateStmt.run(serializedResult, completed_at, duration_ms, id);
+    }
+    /**
+     * Mark a tool call as failed
+     */
+    async error(id, error) {
+        await this.initialized;
+        const completed_at = Math.floor(Date.now() / 1000);
+        // Get the started_at time to calculate duration
+        const getStmt = this.db.prepare('SELECT started_at FROM tool_calls WHERE id = ?');
+        const row = await getStmt.get(id);
+        if (!row) {
+            throw new Error(`Tool call with ID ${id} not found`);
+        }
+        const duration_ms = (completed_at - row.started_at) * 1000;
+        const updateStmt = this.db.prepare(`
+      UPDATE tool_calls
+      SET status = 'error', error = ?, completed_at = ?, duration_ms = ?
+      WHERE id = ?
+    `);
+        await updateStmt.run(error, completed_at, duration_ms, id);
+    }
+    /**
+     * Record a completed tool call
+     * Either result or error should be provided, not both
+     * Returns the ID of the created tool call record
+     */
+    async record(name, started_at, completed_at, parameters, result, error) {
+        await this.initialized;
+        const serializedParams = parameters !== undefined ? JSON.stringify(parameters) : null;
+        const serializedResult = result !== undefined ? JSON.stringify(result) : null;
+        const duration_ms = (completed_at - started_at) * 1000;
+        const status = error ? 'error' : 'success';
+        const stmt = this.db.prepare(`
+      INSERT INTO tool_calls (name, parameters, result, error, status, started_at, completed_at, duration_ms)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const result_row = await stmt.run(name, serializedParams, serializedResult, error || null, status, started_at, completed_at, duration_ms);
+        return Number(result_row.lastInsertRowid);
+    }
+    /**
+     * Get a specific tool call by ID
+     */
+    async get(id) {
+        await this.initialized;
+        const stmt = this.db.prepare(`
+      SELECT * FROM tool_calls WHERE id = ?
+    `);
+        const row = await stmt.get(id);
+        if (!row) {
+            return undefined;
+        }
+        return this.rowToToolCall(row);
+    }
+    /**
+     * Query tool calls by name
+     */
+    async getByName(name, limit) {
+        await this.initialized;
+        const limitClause = limit !== undefined ? `LIMIT ${limit}` : '';
+        const stmt = this.db.prepare(`
+      SELECT * FROM tool_calls
+      WHERE name = ?
+      ORDER BY started_at DESC
+      ${limitClause}
+    `);
+        const rows = await stmt.all(name);
+        return rows.map(row => this.rowToToolCall(row));
+    }
+    /**
+     * Query recent tool calls
+     */
+    async getRecent(since, limit) {
+        await this.initialized;
+        const limitClause = limit !== undefined ? `LIMIT ${limit}` : '';
+        const stmt = this.db.prepare(`
+      SELECT * FROM tool_calls
+      WHERE started_at > ?
+      ORDER BY started_at DESC
+      ${limitClause}
+    `);
+        const rows = await stmt.all(since);
+        return rows.map(row => this.rowToToolCall(row));
+    }
+    /**
+     * Get performance statistics for all tools
+     * Only includes completed calls (success or failed), not pending ones
+     */
+    async getStats() {
+        await this.initialized;
+        const stmt = this.db.prepare(`
+      SELECT
+        name,
+        COUNT(*) as total_calls,
+        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successful,
+        SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as failed,
+        AVG(duration_ms) as avg_duration_ms
+      FROM tool_calls
+      WHERE status != 'pending'
+      GROUP BY name
+      ORDER BY total_calls DESC
+    `);
+        const rows = await stmt.all();
+        return rows.map(row => ({
+            name: row.name,
+            total_calls: row.total_calls,
+            successful: row.successful,
+            failed: row.failed,
+            avg_duration_ms: row.avg_duration_ms || 0,
+        }));
+    }
+    /**
+     * Helper to convert database row to ToolCall object
+     */
+    rowToToolCall(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            parameters: row.parameters !== null ? JSON.parse(row.parameters) : undefined,
+            result: row.result !== null ? JSON.parse(row.result) : undefined,
+            error: row.error !== null ? row.error : undefined,
+            status: row.status,
+            started_at: row.started_at,
+            completed_at: row.completed_at !== null ? row.completed_at : undefined,
+            duration_ms: row.duration_ms !== null ? row.duration_ms : undefined,
+        };
+    }
+    /**
+     * Wait for initialization to complete
+     */
+    async ready() {
+        await this.initialized;
+    }
+}
+exports.ToolCalls = ToolCalls;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "agentfs-sdk",
+  "version": "0.1.0-pre.1",
+  "description": "AgentFS SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "packageManager": "npm@10.9.0",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "turso",
+    "sqlite",
+    "key-value",
+    "filesystem"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/ui": "^4.0.1",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.1"
+  },
+  "dependencies": {
+    "@tursodatabase/database": "^0.3.2"
+  },
+  "files": [
+    "dist"
+  ]
+}