profclaw 0.0.1-beta.1

package/dist/chat/conversations.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Conversation Storage
+ *
+ * Persists chat conversations for history and context.
+ */
+export interface Conversation {
+    id: string;
+    title: string;
+    presetId: string;
+    createdAt: string;
+    updatedAt: string;
+    taskId?: string;
+    ticketId?: string;
+    projectId?: string;
+}
+export interface ToolCallRecord {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    result?: unknown;
+    status?: 'pending' | 'running' | 'success' | 'error';
+    duration?: number;
+}
+export interface ConversationMessage {
+    id: string;
+    conversationId: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    model?: string;
+    provider?: string;
+    tokenUsage?: {
+        prompt: number;
+        completion: number;
+        total: number;
+    };
+    cost?: number;
+    toolCalls?: ToolCallRecord[];
+    createdAt: string;
+}
+export declare function initConversationTables(): Promise<void>;
+export declare function createConversation(params: {
+    title?: string;
+    presetId?: string;
+    taskId?: string;
+    ticketId?: string;
+    projectId?: string;
+}): Promise<Conversation>;
+export declare function getConversation(id: string): Promise<Conversation | null>;
+export declare function listConversations(params?: {
+    limit?: number;
+    offset?: number;
+    taskId?: string;
+    ticketId?: string;
+}): Promise<{
+    conversations: Conversation[];
+    total: number;
+}>;
+export declare function updateConversationTitle(id: string, title: string): Promise<void>;
+export declare function deleteConversation(id: string): Promise<void>;
+export declare function addMessage(params: {
+    conversationId: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    model?: string;
+    provider?: string;
+    tokenUsage?: {
+        prompt: number;
+        completion: number;
+        total: number;
+    };
+    cost?: number;
+    toolCalls?: ToolCallRecord[];
+}): Promise<ConversationMessage>;
+export declare function getConversationMessages(conversationId: string): Promise<ConversationMessage[]>;
+export declare function getRecentConversationsWithPreview(limit?: number): Promise<Array<Conversation & {
+    preview: string;
+    messageCount: number;
+}>>;
+declare const _default: {
+    initConversationTables: typeof initConversationTables;
+    createConversation: typeof createConversation;
+    getConversation: typeof getConversation;
+    listConversations: typeof listConversations;
+    updateConversationTitle: typeof updateConversationTitle;
+    deleteConversation: typeof deleteConversation;
+    addMessage: typeof addMessage;
+    getConversationMessages: typeof getConversationMessages;
+    getRecentConversationsWithPreview: typeof getRecentConversationsWithPreview;
+};
+export default _default;
+//# sourceMappingURL=conversations.d.ts.map

package/dist/chat/conversations.js

@@ -0,0 +1,297 @@
+/**
+ * Conversation Storage
+ *
+ * Persists chat conversations for history and context.
+ */
+import { randomUUID } from 'node:crypto';
+import { getClient } from '../storage/index.js';
+// === Database Setup ===
+export async function initConversationTables() {
+    const client = getClient();
+    await client.execute(`
+    CREATE TABLE IF NOT EXISTS conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      preset_id TEXT NOT NULL DEFAULT 'profclaw-assistant',
+      task_id TEXT,
+      ticket_id TEXT,
+      project_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+    await client.execute(`
+    CREATE TABLE IF NOT EXISTS conversation_messages (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      model TEXT,
+      provider TEXT,
+      prompt_tokens INTEGER,
+      completion_tokens INTEGER,
+      total_tokens INTEGER,
+      cost REAL,
+      tool_calls TEXT,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+    )
+  `);
+    // Migration: Add tool_calls column if it doesn't exist (for existing tables)
+    try {
+        await client.execute(`ALTER TABLE conversation_messages ADD COLUMN tool_calls TEXT`);
+    }
+    catch {
+        // Column already exists, ignore
+    }
+    // Index for fast conversation message lookup
+    await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_conv_messages_conv_id
+    ON conversation_messages(conversation_id)
+  `);
+}
+// === Conversation CRUD ===
+export async function createConversation(params) {
+    const client = getClient();
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    const title = params.title || 'New conversation';
+    const presetId = params.presetId || 'profclaw-assistant';
+    await client.execute({
+        sql: `INSERT INTO conversations (id, title, preset_id, task_id, ticket_id, project_id, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [id, title, presetId, params.taskId || null, params.ticketId || null, params.projectId || null, now, now],
+    });
+    return {
+        id,
+        title,
+        presetId,
+        taskId: params.taskId,
+        ticketId: params.ticketId,
+        projectId: params.projectId,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+export async function getConversation(id) {
+    const client = getClient();
+    const result = await client.execute({
+        sql: `SELECT id, title, preset_id, task_id, ticket_id, project_id, created_at, updated_at
+          FROM conversations WHERE id = ?`,
+        args: [id],
+    });
+    if (result.rows.length === 0)
+        return null;
+    const row = result.rows[0];
+    return {
+        id: row.id,
+        title: row.title,
+        presetId: row.preset_id,
+        taskId: row.task_id,
+        ticketId: row.ticket_id,
+        projectId: row.project_id,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export async function listConversations(params) {
+    const client = getClient();
+    const limit = params?.limit || 20;
+    const offset = params?.offset || 0;
+    // Build WHERE clause and args
+    const conditions = ['1=1'];
+    const args = [];
+    if (params?.taskId) {
+        conditions.push('task_id = ?');
+        args.push(params.taskId);
+    }
+    if (params?.ticketId) {
+        conditions.push('ticket_id = ?');
+        args.push(params.ticketId);
+    }
+    const whereClause = conditions.join(' AND ');
+    const countResult = await client.execute({
+        sql: `SELECT COUNT(*) as total FROM conversations WHERE ${whereClause}`,
+        args,
+    });
+    const total = Number(countResult.rows[0].total);
+    const result = await client.execute({
+        sql: `SELECT id, title, preset_id, task_id, ticket_id, project_id, created_at, updated_at
+          FROM conversations
+          WHERE ${whereClause}
+          ORDER BY updated_at DESC
+          LIMIT ? OFFSET ?`,
+        args: [...args, limit, offset],
+    });
+    const conversations = result.rows.map((row) => ({
+        id: row.id,
+        title: row.title,
+        presetId: row.preset_id,
+        taskId: row.task_id,
+        ticketId: row.ticket_id,
+        projectId: row.project_id,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    }));
+    return { conversations, total };
+}
+export async function updateConversationTitle(id, title) {
+    const client = getClient();
+    const now = new Date().toISOString();
+    await client.execute({
+        sql: `UPDATE conversations SET title = ?, updated_at = ? WHERE id = ?`,
+        args: [title, now, id],
+    });
+}
+export async function deleteConversation(id) {
+    const client = getClient();
+    await client.execute({
+        sql: `DELETE FROM conversation_messages WHERE conversation_id = ?`,
+        args: [id],
+    });
+    await client.execute({
+        sql: `DELETE FROM conversations WHERE id = ?`,
+        args: [id],
+    });
+}
+// === Message CRUD ===
+export async function addMessage(params) {
+    const client = getClient();
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    // Serialize toolCalls to JSON if present
+    const toolCallsJson = params.toolCalls && params.toolCalls.length > 0
+        ? JSON.stringify(params.toolCalls)
+        : null;
+    await client.execute({
+        sql: `INSERT INTO conversation_messages (
+            id, conversation_id, role, content, model, provider,
+            prompt_tokens, completion_tokens, total_tokens, cost, tool_calls, created_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+            id,
+            params.conversationId,
+            params.role,
+            params.content,
+            params.model || null,
+            params.provider || null,
+            params.tokenUsage?.prompt || null,
+            params.tokenUsage?.completion || null,
+            params.tokenUsage?.total || null,
+            params.cost || null,
+            toolCallsJson,
+            now,
+        ],
+    });
+    // Update conversation timestamp
+    await client.execute({
+        sql: `UPDATE conversations SET updated_at = ? WHERE id = ?`,
+        args: [now, params.conversationId],
+    });
+    // Auto-generate title from first user message
+    const countResult = await client.execute({
+        sql: `SELECT COUNT(*) as count FROM conversation_messages WHERE conversation_id = ?`,
+        args: [params.conversationId],
+    });
+    const messageCount = Number(countResult.rows[0].count);
+    if (messageCount === 1 && params.role === 'user') {
+        // Generate title from first message
+        const title = params.content.slice(0, 50) + (params.content.length > 50 ? '...' : '');
+        await updateConversationTitle(params.conversationId, title);
+    }
+    return {
+        id,
+        conversationId: params.conversationId,
+        role: params.role,
+        content: params.content,
+        model: params.model,
+        provider: params.provider,
+        tokenUsage: params.tokenUsage,
+        cost: params.cost,
+        toolCalls: params.toolCalls,
+        createdAt: now,
+    };
+}
+export async function getConversationMessages(conversationId) {
+    const client = getClient();
+    const result = await client.execute({
+        sql: `SELECT id, conversation_id, role, content, model, provider,
+                 prompt_tokens, completion_tokens, total_tokens, cost, tool_calls, created_at
+          FROM conversation_messages
+          WHERE conversation_id = ?
+          ORDER BY created_at ASC`,
+        args: [conversationId],
+    });
+    return result.rows.map((row) => {
+        // Parse toolCalls from JSON if present
+        let toolCalls;
+        if (row.tool_calls) {
+            try {
+                toolCalls = JSON.parse(row.tool_calls);
+            }
+            catch {
+                // Invalid JSON, ignore
+            }
+        }
+        return {
+            id: row.id,
+            conversationId: row.conversation_id,
+            role: row.role,
+            content: row.content,
+            model: row.model,
+            provider: row.provider,
+            tokenUsage: row.total_tokens != null
+                ? {
+                    prompt: row.prompt_tokens,
+                    completion: row.completion_tokens,
+                    total: row.total_tokens,
+                }
+                : undefined,
+            cost: row.cost,
+            toolCalls,
+            createdAt: row.created_at,
+        };
+    });
+}
+export async function getRecentConversationsWithPreview(limit = 10) {
+    const client = getClient();
+    const result = await client.execute({
+        sql: `SELECT
+            c.id, c.title, c.preset_id, c.task_id, c.ticket_id, c.project_id,
+            c.created_at, c.updated_at,
+            (SELECT content FROM conversation_messages
+             WHERE conversation_id = c.id
+             ORDER BY created_at DESC LIMIT 1) as preview,
+            (SELECT COUNT(*) FROM conversation_messages
+             WHERE conversation_id = c.id) as message_count
+          FROM conversations c
+          ORDER BY c.updated_at DESC
+          LIMIT ?`,
+        args: [limit],
+    });
+    return result.rows.map((row) => ({
+        id: row.id,
+        title: row.title,
+        presetId: row.preset_id,
+        taskId: row.task_id,
+        ticketId: row.ticket_id,
+        projectId: row.project_id,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        preview: (row.preview || '').slice(0, 100),
+        messageCount: Number(row.message_count),
+    }));
+}
+export default {
+    initConversationTables,
+    createConversation,
+    getConversation,
+    listConversations,
+    updateConversationTitle,
+    deleteConversation,
+    addMessage,
+    getConversationMessages,
+    getRecentConversationsWithPreview,
+};
+//# sourceMappingURL=conversations.js.map

package/dist/chat/execution/audit.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Audit Logging System
+ *
+ * Records all tool executions, approvals, and security events.
+ * Provides compliance-ready audit trail for tool operations.
+ */
+export type AuditEventType = 'tool_execution' | 'approval_requested' | 'approval_granted' | 'approval_denied' | 'approval_expired' | 'security_denied' | 'rate_limited' | 'timeout' | 'error';
+export interface AuditEntry {
+    id: string;
+    timestamp: number;
+    eventType: AuditEventType;
+    toolName: string;
+    toolCallId: string;
+    conversationId: string;
+    userId?: string;
+    params?: Record<string, unknown>;
+    command?: string;
+    securityMode?: string;
+    securityLevel?: string;
+    success?: boolean;
+    durationMs?: number;
+    exitCode?: number | null;
+    error?: string;
+    outputPreview?: string;
+    approvalId?: string;
+    approvalDecision?: string;
+    denialReason?: string;
+    rateLimit?: {
+        limit: number;
+        remaining: number;
+        resetAt: number;
+    };
+}
+export interface AuditFilter {
+    eventTypes?: AuditEventType[];
+    toolName?: string;
+    conversationId?: string;
+    userId?: string;
+    success?: boolean;
+    since?: number;
+    until?: number;
+    limit?: number;
+    offset?: number;
+}
+export interface AuditStats {
+    totalEvents: number;
+    byEventType: Record<AuditEventType, number>;
+    byTool: Record<string, number>;
+    successRate: number;
+    avgDurationMs: number;
+    timeRange: {
+        earliest: number;
+        latest: number;
+    };
+}
+export declare class AuditLogger {
+    private entries;
+    private listeners;
+    /**
+     * Log a tool execution event
+     */
+    logExecution(event: {
+        toolName: string;
+        toolCallId: string;
+        conversationId: string;
+        userId?: string;
+        params?: Record<string, unknown>;
+        command?: string;
+        securityMode?: string;
+        success: boolean;
+        durationMs?: number;
+        exitCode?: number | null;
+        output?: string;
+        error?: string;
+    }): AuditEntry;
+    /**
+     * Log an approval request
+     */
+    logApprovalRequested(event: {
+        toolName: string;
+        toolCallId: string;
+        conversationId: string;
+        userId?: string;
+        approvalId: string;
+        command?: string;
+        securityLevel: string;
+    }): AuditEntry;
+    /**
+     * Log an approval decision
+     */
+    logApprovalDecision(event: {
+        toolName: string;
+        toolCallId: string;
+        conversationId: string;
+        userId?: string;
+        approvalId: string;
+        decision: 'allow-once' | 'allow-always' | 'deny';
+    }): AuditEntry;
+    /**
+     * Log approval expiration
+     */
+    logApprovalExpired(event: {
+        toolName: string;
+        toolCallId: string;
+        conversationId: string;
+        approvalId: string;
+    }): AuditEntry;
+    /**
+     * Log a security denial
+     */
+    logSecurityDenied(event: {
+        toolName: string;
+        toolCallId: string;
+        conversationId: string;
+        userId?: string;
+        command?: string;
+        securityMode: string;
+        reason: string;
+    }): AuditEntry;
+    /**
+     * Log rate limiting
+     */
+    logRateLimited(event: {
+        toolName: string;
+        toolCallId: string;
+        conversationId: string;
+        userId?: string;
+        limit: number;
+        remaining: number;
+        resetAt: number;
+    }): AuditEntry;
+    /**
+     * Log a timeout
+     */
+    logTimeout(event: {
+        toolName: string;
+        toolCallId: string;
+        conversationId: string;
+        userId?: string;
+        durationMs: number;
+    }): AuditEntry;
+    /**
+     * Log an error
+     */
+    logError(event: {
+        toolName: string;
+        toolCallId: string;
+        conversationId: string;
+        userId?: string;
+        error: string;
+    }): AuditEntry;
+    /**
+     * Query audit entries
+     */
+    query(filter?: AuditFilter): AuditEntry[];
+    /**
+     * Get a single entry by ID
+     */
+    get(id: string): AuditEntry | undefined;
+    /**
+     * Get audit statistics
+     */
+    getStats(filter?: {
+        since?: number;
+        until?: number;
+    }): AuditStats;
+    /**
+     * Export entries as CSV
+     */
+    exportCsv(filter?: AuditFilter): string;
+    /**
+     * Subscribe to new audit entries
+     */
+    subscribe(listener: (entry: AuditEntry) => void): () => void;
+    /**
+     * Clear all entries (for testing)
+     */
+    clear(): void;
+    /**
+     * Get entry count
+     */
+    get count(): number;
+    private createEntry;
+    private addEntry;
+    private cleanup;
+    private sanitizeParams;
+    private truncateOutput;
+    private escapeCsv;
+}
+export declare function getAuditLogger(): AuditLogger;
+export declare function initAuditLogger(): AuditLogger;
+//# sourceMappingURL=audit.d.ts.map