Implement history management feature with database integration and CLI commands

Author: PrashamTrivedi

deno.json

@@ -2,9 +2,11 @@
   "tasks": {
     "dev": "deno run --watch src/main.ts",
     "build": "deno compile --output build/  --allow-env --allow-run --allow-net --allow-read --allow-write src/main.ts",
-    "buildLocal": "deno compile --output build/ComputerUseAgent -A src/main.ts"
+    "buildLocal": "deno compile --output build/ComputerUseAgent -A --unstable-ffi src/main.ts"
   },
   "imports": {
-    "@std/assert": "jsr:@std/assert@1"
+    "@std/assert": "jsr:@std/assert@1",
+    "@db/sqlite": "jsr:@db/sqlite",
+    "table": "jsr:@sauber/table"
   }
 }

deno.lock

@@ -0,0 +1,37 @@
+import {parseArgs} from "jsr:@std/cli/parse-args"
+import {PromptDatabase, type PromptEntry} from "../modules/db/database.ts"
+import {HistoryViewer} from "../modules/cli/history_viewer.ts"
+import {log} from "../config/logging.ts"
+
+export async function handleHistory(args: string[]) {
+
+    const db = new PromptDatabase()
+    const flags = parseArgs(args, {
+        string: ["view", "limit"],
+        default: {limit: "10"},
+    })
+
+    try {
+        if (flags.view) {
+            const id = parseInt(flags.view)
+            if (isNaN(id)) {
+                console.error("Invalid ID provided")
+                return
+            }
+            const entry = db.getPromptById(id)
+
+            if (entry) {
+                HistoryViewer.displayEntry(entry)
+            } else {
+                console.error(`No entry found with ID ${id}`)
+            }
+        } else {
+            const limit = parseInt(flags.limit || "10")
+
+            const entries: PromptEntry[] = db.listPrompts(isNaN(limit) ? 10 : limit)
+            HistoryViewer.displayHistory(entries)
+        }
+    } catch (error) {
+        log.error(`Error displaying history: ${error}`)
+    }
+}

src/commands/history.ts

@@ -11,6 +11,7 @@ import {EditorSession} from "./modules/editor/editor_session.ts"
 import {BashSession} from "./modules/bash/bash_session.ts"
 import {HybridSession} from "./modules/hybrid/hybrid_session.ts"
 import {determineIntent} from "./utils/intent.ts"
+import {handleHistory} from "./commands/history.ts"
 
 async function main() {
   await setupLogging()
@@ -29,6 +30,11 @@ async function main() {
   const mode = flags.mode
   log.debug(`Mode selected: ${mode}`)
 
+  if (flags._[0] === "history") {
+    await handleHistory(flags._.map(arg => String(arg)))
+    return
+  }
+
   if (mode === "editor") {
     const session = new EditorSession(sessionId)
     await session.processEdit(prompt)

src/main.ts

@@ -0,0 +1,63 @@
+import {blue, bold, green, magenta, yellow} from "jsr:@std/fmt/colors"
+import {Table} from "table"
+
+export class HistoryViewer {
+    static displayHistory(entries: Array<{
+        id: number
+        timestamp: string
+        mode: string
+        prompt: string
+        result: string
+        tokens_used: number
+        cost: number
+    }>) {
+        console.clear()
+
+        const table = new Table()
+        table.theme = Table.roundTheme
+        table.headers = [
+            bold("ID"),
+            bold("Time"),
+            bold("Mode"),
+            bold("Prompt"),
+            bold("Cost ($)")
+        ]
+
+        table.rows = entries.map(entry => [
+            blue(entry.id.toString()),
+            green(entry.timestamp),
+            yellow(entry.mode),
+            entry.prompt.slice(0, 50) + (entry.prompt.length > 50 ? "..." : ""),
+            magenta(entry.cost.toFixed(6))
+        ])
+
+        console.log(table.toString())
+        console.log("\nUse 'view <id>' to see full details of a specific entry")
+    }
+
+    static displayEntry(entry: {
+        id: number
+        timestamp: string
+        mode: string
+        prompt: string
+        result: string
+        tokens_used: number
+        cost: number
+    }) {
+        console.clear()
+        console.log(bold("\nPrompt Details:"))
+        console.log("═".repeat(50))
+        console.log(blue(`ID: ${entry.id}`))
+        console.log(green(`Time: ${entry.timestamp}`))
+        console.log(yellow(`Mode: ${entry.mode}`))
+        console.log(magenta(`Tokens: ${entry.tokens_used}`))
+        console.log(magenta(`Cost: $${entry.cost.toFixed(6)}`))
+        console.log("\n" + bold("Prompt:"))
+        console.log("─".repeat(50))
+        console.log(entry.prompt)
+        console.log("\n" + bold("Result:"))
+        console.log("─".repeat(50))
+        console.log(entry.result)
+        console.log("\n")
+    }
+}

src/modules/cli/history_viewer.ts

@@ -0,0 +1,106 @@
+import {Database} from "@db/sqlite"
+import {join} from "jsr:@std/path"
+import {ensureDir} from "jsr:@std/fs"
+import {homedir} from "node:os"
+import {format} from "jsr:@std/datetime"
+import {log} from "../../config/logging.ts"
+
+export type PromptEntry = {
+    id: number
+    timestamp: string
+    mode: string
+    prompt: string
+    result: string
+    tokens_used: number
+    cost: number
+}
+
+export class PromptDatabase {
+    private db: Database
+
+    constructor() {
+        try {
+            const dbPath = join(homedir(), ".ComputerUseAgent", "data")
+            // Ensure directory exists with recursive creation
+            ensureDir(dbPath)
+
+            const dbFile = join(dbPath, "history.db")
+            this.db = new Database(dbFile)
+            this.initialize()
+        } catch (error) {
+            log.error(`Failed to initialize database: ${error}`)
+            throw new Error(`Database initialization failed: ${error}`)
+        }
+    }
+
+    private initialize() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        result TEXT,
+        tokens_used INTEGER,
+        cost REAL
+      )
+    `)
+    }
+
+    async savePrompt(data: {
+        mode: string
+        prompt: string
+        result: string
+        tokens_used: number
+        cost: number
+    }) {
+
+        const timestamp = format(new Date(), "yyyy-MM-dd HH:mm:ss")
+        const number = await this.db.exec(
+            `INSERT INTO prompts (timestamp, mode, prompt, result, tokens_used, cost)
+             VALUES (:timestamp, :mode, :prompt, :result, :tokens, :cost)`,
+            {
+                timestamp,
+                mode: data.mode,
+                prompt: data.prompt,
+                result: data.result,
+                tokens: data.tokens_used,
+                cost: data.cost
+            }
+        )
+        log.debug({number})
+        return number
+    }
+
+    listPrompts(limit = 10) {
+        const stmt = this.db.prepare(
+            `SELECT * FROM prompts ORDER BY timestamp DESC LIMIT ?`
+        )
+        const results = stmt.all(limit)
+        return results.map((row: any) => ({
+            id: row.id,
+            timestamp: row.timestamp,
+            mode: row.mode,
+            prompt: row.prompt,
+            result: row.result,
+            tokens_used: row.tokens_used,
+            cost: row.cost
+        }))
+    }
+
+    getPromptById(id: number): PromptEntry | null {
+        const stmt = this.db.prepare(
+            `SELECT * FROM prompts WHERE id = ?`
+        )
+        const results = stmt.all(id)
+        return results.length === 0 ? null : {
+            id: results[0].id,
+            timestamp: results[0].timestamp,
+            mode: results[0].mode,
+            prompt: results[0].prompt,
+            result: results[0].result,
+            tokens_used: results[0].tokens_used,
+            cost: results[0].cost
+        }
+    }
+}

src/modules/db/database.ts

@@ -77,11 +77,13 @@ export class HybridSession extends BaseSession {
             }
 
             this.logger.logTotalCost()
+            await this.logInteraction('hybrid', prompt, "passed")
         } catch (error) {
             log.error(`Error in hybrid process: ${error instanceof Error ? error.message : String(error)}`)
             if (error instanceof Error && error.stack) {
                 log.error(error.stack)
             }
+            await this.logInteraction('hybrid', prompt, `${error}`)
             throw error
         }
     }