profclaw 2.0.0 → 2.3.0

package/dist/agents/tool-loader.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Tool Loader
+ *
+ * Manages tool categorization and lazy loading for the agentic system.
+ * Provides search over tool categories so the AI can discover and enable
+ * tools on demand without paying the full context cost of all schemas.
+ */
+import type { ToolDefinition } from '../chat/execution/types.js';
+export interface ToolCategory {
+    /** Unique slug for this category (e.g. "file_ops") */
+    name: string;
+    /** Human-readable description shown to users and the AI */
+    description: string;
+    /** Keywords used for fuzzy search / auto-load decisions */
+    keywords: string[];
+    /** Canonical tool names that belong to this category */
+    tools: string[];
+    /** When true, these tools are always included in every session */
+    alwaysLoaded: boolean;
+}
+export declare class ToolLoader {
+    private allTools;
+    private categories;
+    private loadedToolNames;
+    constructor(allTools: Map<string, ToolDefinition>);
+    /**
+     * Return the subset of tools that are always loaded (core session tools).
+     */
+    getCoreTools(): ToolDefinition[];
+    /**
+     * Return all tools that have been loaded for the current session,
+     * including always_loaded plus any dynamically loaded categories/tools.
+     */
+    getSessionTools(): ToolDefinition[];
+    /**
+     * Search categories by query string.
+     * Matches against category name, description, and keywords using
+     * case-insensitive substring matching; results are ranked by score.
+     */
+    search(query: string): ToolCategory[];
+    /**
+     * Load all tools belonging to a named category into the active session.
+     * Silently ignores tool names that are not registered.
+     */
+    loadCategory(categoryName: string): void;
+    /**
+     * Load a single tool by name into the active session.
+     * Silently ignores names that are not registered.
+     */
+    loadTool(toolName: string): void;
+    /**
+     * Return all registered categories.
+     */
+    getCategories(): ToolCategory[];
+    /**
+     * Register a custom category.
+     * Will overwrite any existing category with the same name.
+     */
+    registerCategory(category: ToolCategory): void;
+    /**
+     * Check whether a specific tool is currently loaded into the session.
+     */
+    isLoaded(toolName: string): boolean;
+}
+//# sourceMappingURL=tool-loader.d.ts.map

package/dist/agents/tool-loader.js

@@ -0,0 +1,273 @@
+/**
+ * Tool Loader
+ *
+ * Manages tool categorization and lazy loading for the agentic system.
+ * Provides search over tool categories so the AI can discover and enable
+ * tools on demand without paying the full context cost of all schemas.
+ */
+// Built-in Category Definitions
+const BUILT_IN_CATEGORIES = [
+    {
+        name: 'always_loaded',
+        description: 'Core tools that are always available in every session',
+        keywords: ['core', 'always', 'base', 'default', 'essential'],
+        tools: [
+            'read_file',
+            'write_file',
+            'search_files',
+            'exec',
+            'git_status',
+            'git_commit',
+            'complete_task',
+            'search_available_tools',
+        ],
+        alwaysLoaded: true,
+    },
+    {
+        name: 'file_ops',
+        description: 'Extended file system operations: edit, grep, patch, directory tree',
+        keywords: ['file', 'filesystem', 'read', 'write', 'edit', 'grep', 'search', 'patch', 'directory'],
+        tools: [
+            'read_file',
+            'write_file',
+            'search_files',
+            'grep',
+            'edit_file',
+            'directory_tree',
+            'patch_apply',
+            'multi_patch',
+        ],
+        alwaysLoaded: false,
+    },
+    {
+        name: 'browser',
+        description: 'Browser automation tools for web scraping and UI testing',
+        keywords: ['browser', 'playwright', 'navigate', 'click', 'screenshot', 'web', 'automation', 'scrape'],
+        tools: [
+            'browser_navigate',
+            'browser_click',
+            'browser_fill',
+            'browser_screenshot',
+            'browser_evaluate',
+        ],
+        alwaysLoaded: false,
+    },
+    {
+        name: 'integration',
+        description: 'Third-party integration tools: Slack, Discord, Telegram, screen capture, clipboard',
+        keywords: ['slack', 'discord', 'telegram', 'notification', 'clipboard', 'screen', 'capture', 'integration'],
+        tools: [
+            'slack_actions',
+            'discord_actions',
+            'telegram_actions',
+            'screen_capture',
+            'clipboard_read',
+            'clipboard_write',
+            'notify',
+        ],
+        alwaysLoaded: false,
+    },
+    {
+        name: 'git_advanced',
+        description: 'Advanced Git operations beyond status and commit',
+        keywords: ['git', 'diff', 'log', 'branch', 'stash', 'remote', 'merge', 'rebase', 'version control'],
+        tools: [
+            'git_status',
+            'git_diff',
+            'git_log',
+            'git_commit',
+            'git_branch',
+            'git_stash',
+            'git_remote',
+        ],
+        alwaysLoaded: false,
+    },
+    {
+        name: 'canvas',
+        description: 'Canvas rendering and image generation tools',
+        keywords: ['canvas', 'image', 'render', 'draw', 'generate', 'visual', 'graphic'],
+        tools: [
+            'canvas_render',
+            'openai_image_gen',
+            'image_analyze',
+        ],
+        alwaysLoaded: false,
+    },
+    {
+        name: 'voice',
+        description: 'Text-to-speech and voice synthesis tools',
+        keywords: ['voice', 'tts', 'speech', 'audio', 'speak', 'synthesize'],
+        tools: [
+            'tts_speak',
+        ],
+        alwaysLoaded: false,
+    },
+    {
+        name: 'memory',
+        description: 'Conversation memory management: search, retrieval, and statistics',
+        keywords: ['memory', 'remember', 'recall', 'search', 'context', 'history', 'retrieve'],
+        tools: [
+            'memory_search',
+            'memory_get',
+            'memory_stats',
+        ],
+        alwaysLoaded: false,
+    },
+    {
+        name: 'system',
+        description: 'System information, environment variables, and process management',
+        keywords: ['system', 'env', 'environment', 'process', 'info', 'hardware', 'os', 'which', 'path'],
+        tools: [
+            'env',
+            'system_info',
+            'process_list',
+            'path_info',
+            'which',
+        ],
+        alwaysLoaded: false,
+    },
+];
+// Tool Loader
+export class ToolLoader {
+    allTools;
+    categories;
+    loadedToolNames;
+    constructor(allTools) {
+        this.allTools = allTools;
+        this.categories = new Map();
+        this.loadedToolNames = new Set();
+        // Register built-in categories
+        for (const category of BUILT_IN_CATEGORIES) {
+            this.categories.set(category.name, category);
+        }
+        // Pre-load always_loaded tools
+        const alwaysLoaded = this.categories.get('always_loaded');
+        if (alwaysLoaded) {
+            for (const toolName of alwaysLoaded.tools) {
+                if (this.allTools.has(toolName)) {
+                    this.loadedToolNames.add(toolName);
+                }
+            }
+        }
+    }
+    /**
+     * Return the subset of tools that are always loaded (core session tools).
+     */
+    getCoreTools() {
+        const core = this.categories.get('always_loaded');
+        if (!core)
+            return [];
+        return core.tools
+            .map((name) => this.allTools.get(name))
+            .filter((tool) => tool !== undefined);
+    }
+    /**
+     * Return all tools that have been loaded for the current session,
+     * including always_loaded plus any dynamically loaded categories/tools.
+     */
+    getSessionTools() {
+        return Array.from(this.loadedToolNames)
+            .map((name) => this.allTools.get(name))
+            .filter((tool) => tool !== undefined);
+    }
+    /**
+     * Search categories by query string.
+     * Matches against category name, description, and keywords using
+     * case-insensitive substring matching; results are ranked by score.
+     */
+    search(query) {
+        if (!query.trim()) {
+            return Array.from(this.categories.values());
+        }
+        const terms = query
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((t) => t.length > 0);
+        const scored = [];
+        for (const category of this.categories.values()) {
+            let score = 0;
+            for (const term of terms) {
+                // Exact name match gets highest weight
+                if (category.name === term) {
+                    score += 10;
+                }
+                else if (category.name.includes(term)) {
+                    score += 5;
+                }
+                // Description match
+                if (category.description.toLowerCase().includes(term)) {
+                    score += 3;
+                }
+                // Keyword match
+                for (const keyword of category.keywords) {
+                    if (keyword === term) {
+                        score += 4;
+                    }
+                    else if (keyword.includes(term)) {
+                        score += 2;
+                    }
+                }
+                // Tool name match
+                for (const toolName of category.tools) {
+                    if (toolName.includes(term)) {
+                        score += 1;
+                    }
+                }
+            }
+            if (score > 0) {
+                scored.push({ category, score });
+            }
+        }
+        return scored
+            .sort((a, b) => b.score - a.score)
+            .map((s) => s.category);
+    }
+    /**
+     * Load all tools belonging to a named category into the active session.
+     * Silently ignores tool names that are not registered.
+     */
+    loadCategory(categoryName) {
+        const category = this.categories.get(categoryName);
+        if (!category) {
+            return;
+        }
+        for (const toolName of category.tools) {
+            if (this.allTools.has(toolName)) {
+                this.loadedToolNames.add(toolName);
+            }
+        }
+    }
+    /**
+     * Load a single tool by name into the active session.
+     * Silently ignores names that are not registered.
+     */
+    loadTool(toolName) {
+        if (this.allTools.has(toolName)) {
+            this.loadedToolNames.add(toolName);
+        }
+    }
+    /**
+     * Return all registered categories.
+     */
+    getCategories() {
+        return Array.from(this.categories.values());
+    }
+    /**
+     * Register a custom category.
+     * Will overwrite any existing category with the same name.
+     */
+    registerCategory(category) {
+        this.categories.set(category.name, category);
+        // If the new category is marked always_loaded, immediately load its tools
+        if (category.alwaysLoaded) {
+            this.loadCategory(category.name);
+        }
+    }
+    /**
+     * Check whether a specific tool is currently loaded into the session.
+     */
+    isLoaded(toolName) {
+        return this.loadedToolNames.has(toolName);
+    }
+}
+//# sourceMappingURL=tool-loader.js.map

package/dist/agents/transcript.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Transcript Persistence
+ *
+ * Saves all conversations to JSONL files for searchable history and session resumption.
+ * Files are stored at .profclaw/transcripts/{sessionId}.jsonl
+ * Index is stored at .profclaw/transcripts/index.json
+ */
+import * as os from 'os';
+export interface TranscriptEntry {
+    timestamp: number;
+    sessionId: string;
+    type: 'user' | 'assistant' | 'tool_call' | 'tool_result' | 'system' | 'error';
+    content: string;
+    metadata?: {
+        toolName?: string;
+        toolCallId?: string;
+        model?: string;
+        tokensUsed?: number;
+        duration?: number;
+    };
+}
+export interface SessionMeta {
+    sessionId: string;
+    title: string;
+    startedAt: number;
+    lastActivityAt: number;
+    messageCount: number;
+    tokensUsed: number;
+    model?: string;
+}
+export declare class TranscriptStore {
+    private transcriptsDir;
+    private sessionsIndex;
+    private indexDirty;
+    private indexTimer;
+    constructor(projectRoot?: string);
+    /**
+     * Append a single entry to the session's JSONL file.
+     */
+    append(entry: TranscriptEntry): void;
+    /**
+     * Read all entries for a session from its JSONL file.
+     */
+    getSession(sessionId: string): TranscriptEntry[];
+    /**
+     * List sessions sorted by lastActivityAt descending.
+     */
+    listSessions(options?: {
+        limit?: number;
+        offset?: number;
+    }): SessionMeta[];
+    /**
+     * Full-text search across transcript entries.
+     * Returns matching entries with their session ID and line number.
+     */
+    search(query: string, options?: {
+        sessionId?: string;
+        limit?: number;
+    }): Array<{
+        entry: TranscriptEntry;
+        sessionId: string;
+        lineNumber: number;
+    }>;
+    /**
+     * Get or create session metadata. Uses firstMessage to auto-generate a title
+     * if the session doesn't yet exist.
+     */
+    getOrCreateMeta(sessionId: string, firstMessage?: string): SessionMeta;
+    /**
+     * Merge partial updates into an existing session's metadata.
+     */
+    updateMeta(sessionId: string, updates: Partial<SessionMeta>): void;
+    /**
+     * Delete a session's JSONL file and remove it from the index.
+     */
+    deleteSession(sessionId: string): void;
+    flush(): void;
+    private markIndexDirty;
+    private sessionFilePath;
+    private indexFilePath;
+    private ensureDir;
+    private loadIndex;
+    private saveIndex;
+    /**
+     * Generate a human-readable title from the first 50 chars of a message.
+     * Strips newlines, trims whitespace.
+     */
+    private generateTitle;
+}
+/**
+ * Returns the process-level singleton TranscriptStore, rooted at cwd().
+ */
+export declare function getTranscriptStore(): TranscriptStore;
+export declare function _resetTranscriptStoreSingleton(): void;
+export { os };
+//# sourceMappingURL=transcript.d.ts.map

package/dist/agents/transcript.js

@@ -0,0 +1,267 @@
+/**
+ * Transcript Persistence
+ *
+ * Saves all conversations to JSONL files for searchable history and session resumption.
+ * Files are stored at .profclaw/transcripts/{sessionId}.jsonl
+ * Index is stored at .profclaw/transcripts/index.json
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+let _instance = null;
+export class TranscriptStore {
+    transcriptsDir;
+    sessionsIndex;
+    indexDirty = false;
+    indexTimer = null;
+    constructor(projectRoot) {
+        const root = projectRoot ?? process.cwd();
+        this.transcriptsDir = path.join(root, '.profclaw', 'transcripts');
+        this.sessionsIndex = new Map();
+        this.loadIndex();
+    }
+    /**
+     * Append a single entry to the session's JSONL file.
+     */
+    append(entry) {
+        this.ensureDir();
+        const filePath = this.sessionFilePath(entry.sessionId);
+        const line = JSON.stringify(entry) + '\n';
+        try {
+            fs.appendFileSync(filePath, line, 'utf8');
+        }
+        catch (err) {
+            console.error('[TranscriptStore] Failed to append entry:', err);
+            return;
+        }
+        // Update session metadata
+        const meta = this.getOrCreateMeta(entry.sessionId);
+        meta.lastActivityAt = entry.timestamp;
+        meta.messageCount += 1;
+        if (entry.metadata?.tokensUsed) {
+            meta.tokensUsed += entry.metadata.tokensUsed;
+        }
+        if (entry.metadata?.model && !meta.model) {
+            meta.model = entry.metadata.model;
+        }
+        this.sessionsIndex.set(entry.sessionId, meta);
+        this.markIndexDirty();
+    }
+    /**
+     * Read all entries for a session from its JSONL file.
+     */
+    getSession(sessionId) {
+        const filePath = this.sessionFilePath(sessionId);
+        if (!fs.existsSync(filePath)) {
+            return [];
+        }
+        try {
+            const raw = fs.readFileSync(filePath, 'utf8');
+            const entries = [];
+            for (const line of raw.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    entries.push(JSON.parse(trimmed));
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+            return entries;
+        }
+        catch (err) {
+            console.error(`[TranscriptStore] Failed to read session ${sessionId}:`, err);
+            return [];
+        }
+    }
+    /**
+     * List sessions sorted by lastActivityAt descending.
+     */
+    listSessions(options) {
+        const all = Array.from(this.sessionsIndex.values()).sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+        const offset = options?.offset ?? 0;
+        const limit = options?.limit ?? all.length;
+        return all.slice(offset, offset + limit);
+    }
+    /**
+     * Full-text search across transcript entries.
+     * Returns matching entries with their session ID and line number.
+     */
+    search(query, options) {
+        const results = [];
+        const lowerQuery = query.toLowerCase();
+        const limit = options?.limit ?? 50;
+        const sessionIds = options?.sessionId
+            ? [options.sessionId]
+            : Array.from(this.sessionsIndex.keys());
+        for (const sessionId of sessionIds) {
+            if (results.length >= limit)
+                break;
+            const filePath = this.sessionFilePath(sessionId);
+            if (!fs.existsSync(filePath))
+                continue;
+            let raw;
+            try {
+                raw = fs.readFileSync(filePath, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const lines = raw.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                if (results.length >= limit)
+                    break;
+                const line = lines[i].trim();
+                if (!line)
+                    continue;
+                if (line.toLowerCase().includes(lowerQuery)) {
+                    try {
+                        const entry = JSON.parse(line);
+                        results.push({ entry, sessionId, lineNumber: i + 1 });
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Get or create session metadata. Uses firstMessage to auto-generate a title
+     * if the session doesn't yet exist.
+     */
+    getOrCreateMeta(sessionId, firstMessage) {
+        const existing = this.sessionsIndex.get(sessionId);
+        if (existing)
+            return existing;
+        const now = Date.now();
+        const meta = {
+            sessionId,
+            title: firstMessage ? this.generateTitle(firstMessage) : `Session ${sessionId.slice(0, 8)}`,
+            startedAt: now,
+            lastActivityAt: now,
+            messageCount: 0,
+            tokensUsed: 0,
+        };
+        this.sessionsIndex.set(sessionId, meta);
+        this.saveIndex();
+        return meta;
+    }
+    /**
+     * Merge partial updates into an existing session's metadata.
+     */
+    updateMeta(sessionId, updates) {
+        const existing = this.sessionsIndex.get(sessionId);
+        if (!existing)
+            return;
+        this.sessionsIndex.set(sessionId, { ...existing, ...updates, sessionId });
+        this.saveIndex();
+    }
+    /**
+     * Delete a session's JSONL file and remove it from the index.
+     */
+    deleteSession(sessionId) {
+        const filePath = this.sessionFilePath(sessionId);
+        if (fs.existsSync(filePath)) {
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch (err) {
+                console.error(`[TranscriptStore] Failed to delete session file ${sessionId}:`, err);
+            }
+        }
+        this.sessionsIndex.delete(sessionId);
+        this.saveIndex();
+    }
+    flush() {
+        if (this.indexTimer) {
+            clearTimeout(this.indexTimer);
+            this.indexTimer = null;
+        }
+        if (this.indexDirty) {
+            this.saveIndex();
+            this.indexDirty = false;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    markIndexDirty() {
+        this.indexDirty = true;
+        if (!this.indexTimer) {
+            this.indexTimer = setTimeout(() => {
+                this.indexTimer = null;
+                if (this.indexDirty) {
+                    this.saveIndex();
+                    this.indexDirty = false;
+                }
+            }, 1000);
+        }
+    }
+    sessionFilePath(sessionId) {
+        return path.join(this.transcriptsDir, `${sessionId}.jsonl`);
+    }
+    indexFilePath() {
+        return path.join(this.transcriptsDir, 'index.json');
+    }
+    ensureDir() {
+        if (!fs.existsSync(this.transcriptsDir)) {
+            fs.mkdirSync(this.transcriptsDir, { recursive: true });
+        }
+    }
+    loadIndex() {
+        const indexPath = this.indexFilePath();
+        if (!fs.existsSync(indexPath))
+            return;
+        try {
+            const raw = fs.readFileSync(indexPath, 'utf8');
+            const sessions = JSON.parse(raw);
+            for (const session of sessions) {
+                this.sessionsIndex.set(session.sessionId, session);
+            }
+        }
+        catch (err) {
+            console.error('[TranscriptStore] Failed to load index:', err);
+        }
+    }
+    saveIndex() {
+        this.ensureDir();
+        const indexPath = this.indexFilePath();
+        const sessions = Array.from(this.sessionsIndex.values());
+        try {
+            fs.writeFileSync(indexPath, JSON.stringify(sessions, null, 2), 'utf8');
+        }
+        catch (err) {
+            console.error('[TranscriptStore] Failed to save index:', err);
+        }
+    }
+    /**
+     * Generate a human-readable title from the first 50 chars of a message.
+     * Strips newlines, trims whitespace.
+     */
+    generateTitle(message) {
+        const cleaned = message.replace(/[\r\n\t]+/g, ' ').trim();
+        if (cleaned.length <= 50)
+            return cleaned;
+        return cleaned.slice(0, 47) + '...';
+    }
+}
+/**
+ * Returns the process-level singleton TranscriptStore, rooted at cwd().
+ */
+export function getTranscriptStore() {
+    if (!_instance) {
+        _instance = new TranscriptStore();
+    }
+    return _instance;
+}
+// Exported for test injection
+export function _resetTranscriptStoreSingleton() {
+    _instance = null;
+}
+// Re-export os for use in tests (avoids test-only imports from module internals)
+export { os };
+//# sourceMappingURL=transcript.js.map