cli-link 0.0.5 → 0.0.7

package/dist/server/store.js

@@ -33,6 +33,17 @@ function buildHistoryTitle(messages) {
     const userMessage = messages.find(m => m.type === 'user_message' || m.type === 'user');
     return userMessage ? cleanHistoryTitle(userMessage.content) : '会话记录';
 }
+function normalizePromptHistoryText(content) {
+    if (typeof content !== 'string')
+        return null;
+    const text = content.trim();
+    if (!text)
+        return null;
+    const key = text.replace(/\s+/g, ' ').toLowerCase();
+    if (!key)
+        return null;
+    return { text, key };
+}
 function normalizeWorkDir(workDir) {
     if (typeof workDir !== 'string')
         return null;
@@ -124,7 +135,20 @@ export function initDb(dbPath) {
       created_at INTEGER NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS prompt_history (
+      id TEXT PRIMARY KEY,
+      work_dir TEXT,
+      text TEXT NOT NULL,
+      normalized_text TEXT NOT NULL,
+      session_id TEXT,
+      message_id TEXT,
+      use_count INTEGER NOT NULL DEFAULT 1,
+      last_used_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
     CREATE INDEX IF NOT EXISTS idx_messages_session_seq ON messages(session_id, seq);
+    CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id, id);
   `);
     // Migrate: add 'details' column if it doesn't exist (for existing databases)
     const columns = db.prepare(`PRAGMA table_info(messages)`).all();
@@ -147,7 +171,11 @@ export function initDb(dbPath) {
     }
     db.exec(`CREATE INDEX IF NOT EXISTS idx_history_tasks_work_dir_created ON history_tasks(work_dir, created_at DESC)`);
     db.exec(`CREATE INDEX IF NOT EXISTS idx_workdir_history_last_used ON workdir_history(last_used_at DESC)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_prompt_history_work_dir_last_used ON prompt_history(work_dir, last_used_at DESC)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_prompt_history_last_used ON prompt_history(last_used_at DESC)`);
+    db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_prompt_history_work_dir_norm ON prompt_history(work_dir, normalized_text)`);
     backfillHistoryTaskSummaries();
+    backfillPromptHistoryFromMessages();
     console.log(`[Store] Database initialized at ${path}`);
 }
 function backfillHistoryTaskSummaries() {
@@ -475,6 +503,105 @@ export function getRecentWorkDirs(limit = 12) {
     }
     return existing;
 }
+// --- Prompt History ---
+export function recordPromptHistory(input) {
+    const normalizedText = normalizePromptHistoryText(input.text);
+    if (!normalizedText)
+        return null;
+    const workDir = normalizeWorkDir(input.workDir);
+    const now = Date.now();
+    const existing = workDir
+        ? db.prepare(`SELECT * FROM prompt_history WHERE work_dir = ? AND normalized_text = ?`)
+            .get(workDir, normalizedText.key)
+        : db.prepare(`SELECT * FROM prompt_history WHERE work_dir IS NULL AND normalized_text = ?`)
+            .get(normalizedText.key);
+    if (existing) {
+        db.prepare(`UPDATE prompt_history
+       SET text = ?, session_id = ?, message_id = ?, use_count = use_count + 1, last_used_at = ?
+       WHERE id = ?`).run(normalizedText.text, input.sessionId || null, input.messageId || null, now, existing.id);
+        return {
+            ...existing,
+            text: normalizedText.text,
+            session_id: input.sessionId || null,
+            message_id: input.messageId || null,
+            use_count: existing.use_count + 1,
+            last_used_at: now,
+        };
+    }
+    const item = {
+        id: randomUUID(),
+        work_dir: workDir,
+        text: normalizedText.text,
+        normalized_text: normalizedText.key,
+        session_id: input.sessionId || null,
+        message_id: input.messageId || null,
+        use_count: 1,
+        last_used_at: now,
+        created_at: now,
+    };
+    db.prepare(`INSERT INTO prompt_history (id, work_dir, text, normalized_text, session_id, message_id, use_count, last_used_at, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(item.id, item.work_dir || null, item.text, item.normalized_text, item.session_id || null, item.message_id || null, item.use_count, item.last_used_at, item.created_at);
+    return item;
+}
+export function getPromptHistory(options = {}) {
+    const limit = Math.max(1, Math.min(100, Math.floor(options.limit || 50)));
+    const workDir = normalizeWorkDir(options.workDir);
+    const query = normalizePromptHistoryText(options.query || '')?.key || '';
+    const like = `%${query}%`;
+    if (workDir && query) {
+        return db.prepare(`SELECT * FROM prompt_history
+       WHERE work_dir = ? AND normalized_text LIKE ?
+       ORDER BY last_used_at DESC
+       LIMIT ?`).all(workDir, like, limit);
+    }
+    if (workDir) {
+        return db.prepare(`SELECT * FROM prompt_history
+       WHERE work_dir = ?
+       ORDER BY last_used_at DESC
+       LIMIT ?`).all(workDir, limit);
+    }
+    if (query) {
+        return db.prepare(`SELECT * FROM prompt_history
+       WHERE normalized_text LIKE ?
+       ORDER BY last_used_at DESC
+       LIMIT ?`).all(like, limit);
+    }
+    return db.prepare(`SELECT * FROM prompt_history
+     ORDER BY last_used_at DESC
+     LIMIT ?`).all(limit);
+}
+export function deletePromptHistory(id, workDir) {
+    const normalizedWorkDir = normalizeWorkDir(workDir);
+    const result = normalizedWorkDir
+        ? db.prepare(`DELETE FROM prompt_history WHERE id = ? AND work_dir = ?`).run(id, normalizedWorkDir)
+        : db.prepare(`DELETE FROM prompt_history WHERE id = ?`).run(id);
+    return result.changes > 0;
+}
+function backfillPromptHistoryFromMessages() {
+    const existing = db.prepare(`SELECT COUNT(*) AS count FROM prompt_history`).get();
+    if (existing.count > 0)
+        return;
+    const rows = db.prepare(`SELECT m.id AS message_id, m.session_id, m.content, s.cli_config
+     FROM messages m
+     LEFT JOIN sessions s ON s.id = m.session_id
+     WHERE m.type IN ('user_message', 'user') AND TRIM(m.content) != ''
+     ORDER BY m.seq ASC
+     LIMIT 10000`).all();
+    if (rows.length === 0)
+        return;
+    const backfill = db.transaction((items) => {
+        for (const item of items) {
+            recordPromptHistory({
+                text: item.content,
+                workDir: getWorkDirFromSessionConfig(item.cli_config),
+                sessionId: item.session_id,
+                messageId: item.message_id,
+            });
+        }
+    });
+    backfill(rows);
+    console.log(`[Store] Backfilled ${rows.length} user messages into prompt history`);
+}
 // --- Migration (from client localStorage) ---
 export function importLocalData(messages, historyTasks, workDir) {
     const current = getCurrentSession();
@@ -496,7 +623,18 @@ export function importLocalData(messages, historyTasks, workDir) {
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
         const insertMany = db.transaction((msgs) => {
             for (const msg of msgs) {
-                insertStmt.run(String(msg.id || randomUUID()), String(msg.type || 'system'), String(msg.content || ''), String(msg.time || new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })), msg.status || null, msg.toolName || null, msg.toolDetails || null, msg.permission ? JSON.stringify(msg.permission) : null, sessionId);
+                const id = String(msg.id || randomUUID());
+                const type = String(msg.type || 'system');
+                const content = String(msg.content || '');
+                insertStmt.run(id, type, content, String(msg.time || new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', hourCycle: 'h23' })), msg.status || null, msg.toolName || null, msg.toolDetails || null, msg.permission ? JSON.stringify(msg.permission) : null, sessionId);
+                if (type === 'user_message' || type === 'user') {
+                    recordPromptHistory({
+                        text: content,
+                        workDir: importWorkDir,
+                        sessionId,
+                        messageId: id,
+                    });
+                }
             }
         });
         insertMany(messages);
@@ -517,10 +655,76 @@ export function importLocalData(messages, historyTasks, workDir) {
     }
     console.log(`[Store] Imported ${messages.length} messages and ${historyTasks.length} history tasks`);
 }
+function jsonOrNull(value) {
+    if (value == null)
+        return null;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function textOrNull(value) {
+    if (value == null)
+        return null;
+    const text = String(value);
+    return text.length > 0 ? text : null;
+}
+function getImportedSessionTiming(session) {
+    const startedAt = Number.isFinite(session.startedAt) && session.startedAt > 0 ? session.startedAt : Date.now();
+    const endedAt = Number.isFinite(session.endedAt) && session.endedAt > 0 ? session.endedAt : startedAt;
+    const createdAt = Number.isFinite(session.createdAt) && session.createdAt > 0 ? session.createdAt : endedAt;
+    const diffSec = Math.max(0, Math.round((endedAt - startedAt) / 1000));
+    const duration = diffSec > 0
+        ? diffSec >= 60
+            ? `${Math.floor(diffSec / 60)}m ${String(diffSec % 60).padStart(2, '0')}s`
+            : `${diffSec}s`
+        : null;
+    return { startedAt, endedAt, createdAt, duration };
+}
+function importedMessageSignature(message) {
+    return [
+        message.type || '',
+        message.time || '',
+        message.toolUseId || '',
+        message.toolName || '',
+        message.content || '',
+    ].join('\u001f');
+}
+function storedMessageSignature(message) {
+    return importedMessageSignature({
+        type: message.type,
+        content: message.content,
+        time: message.time,
+        toolName: message.toolName || undefined,
+        toolUseId: message.toolUseId || undefined,
+    });
+}
+function codexSpecialKeyFromDetails(details, type) {
+    if (type !== 'system')
+        return null;
+    const parsed = typeof details === 'string' ? parseConfig(details) : details;
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const record = parsed;
+    const subtype = record.subtype;
+    const sessionId = record.session_id;
+    if ((subtype === 'init' || subtype === 'result') && typeof sessionId === 'string' && sessionId) {
+        return `${subtype}:${sessionId}`;
+    }
+    return null;
+}
+function putFirst(map, key, value) {
+    if (key == null || map.has(key))
+        return;
+    map.set(key, value);
+}
 export function importCodexSessions(sessions) {
     const result = {
         scanned: sessions.length,
         imported: 0,
+        updated: 0,
         skipped: 0,
         failed: 0,
         messagesImported: 0,
@@ -529,60 +733,198 @@ export function importCodexSessions(sessions) {
     if (sessions.length === 0) {
         return result;
     }
-    const sessionExists = db.prepare(`SELECT 1 FROM sessions WHERE id = ? LIMIT 1`);
-    const taskExists = db.prepare(`SELECT 1 FROM history_tasks WHERE id = ? LIMIT 1`);
+    const getSession = db.prepare(`SELECT * FROM sessions WHERE id = ?`);
+    const getTaskById = db.prepare(`SELECT * FROM history_tasks WHERE id = ?`);
+    const getTaskBySession = db.prepare(`SELECT * FROM history_tasks WHERE session_id = ? ORDER BY created_at DESC LIMIT 1`);
+    const getMessagesBySession = db.prepare(`SELECT * FROM messages WHERE session_id = ? ORDER BY seq ASC`);
     const insertSession = db.prepare(`INSERT INTO sessions (id, status, cli_config, started_at, last_seq) VALUES (?, ?, ?, ?, 0)`);
+    const updateSession = db.prepare(`UPDATE sessions SET cli_config = ?, started_at = ? WHERE id = ?`);
     const insertMessage = db.prepare(`INSERT INTO messages (id, type, content, time, status, toolName, toolDetails, toolUseId, toolResult, permission, details, session_id)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const updateMessage = db.prepare(`UPDATE messages
+     SET id = ?, type = ?, content = ?, time = ?, status = ?, toolName = ?, toolDetails = ?, toolUseId = ?, toolResult = ?, permission = ?, details = ?
+     WHERE seq = ?`);
+    const getMaxSeq = db.prepare(`SELECT MAX(seq) AS seq FROM messages WHERE session_id = ?`);
     const updateLastSeq = db.prepare(`UPDATE sessions SET last_seq = ? WHERE id = ?`);
     const insertTask = db.prepare(`INSERT INTO history_tasks (id, session_id, work_dir, status, title, confirm_count, tool_count, duration, start_time, end_time, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const updateTask = db.prepare(`UPDATE history_tasks
+     SET session_id = ?, work_dir = ?, status = ?, title = ?, confirm_count = ?, tool_count = ?, duration = ?, start_time = ?, end_time = ?, created_at = ?
+     WHERE id = ?`);
     const importOne = db.transaction((session) => {
         const workDir = normalizeWorkDir(session.workDir);
         const messages = session.messages || [];
         const confirmCount = messages.filter(m => m.type === 'confirm_request' || m.type === 'confirm').length;
         const toolCount = messages.filter(m => m.type === 'tool_call' || m.type === 'tool').length;
-        const startedAt = Number.isFinite(session.startedAt) && session.startedAt > 0 ? session.startedAt : Date.now();
-        const endedAt = Number.isFinite(session.endedAt) && session.endedAt > 0 ? session.endedAt : startedAt;
-        const createdAt = Number.isFinite(session.createdAt) && session.createdAt > 0 ? session.createdAt : endedAt;
-        const diffSec = Math.max(0, Math.round((endedAt - startedAt) / 1000));
-        const duration = diffSec > 0
-            ? diffSec >= 60
-                ? `${Math.floor(diffSec / 60)}m ${String(diffSec % 60).padStart(2, '0')}s`
-                : `${diffSec}s`
-            : null;
-        insertSession.run(session.sessionId, 'archived', JSON.stringify(session.cliConfig || {}), startedAt);
-        let lastSeq = 0;
+        const { startedAt, endedAt, createdAt, duration } = getImportedSessionTiming(session);
+        const existingSession = getSession.get(session.sessionId);
+        const createdSession = !existingSession;
+        let changed = false;
+        if (existingSession) {
+            const mergedConfig = { ...parseConfig(existingSession.cli_config), ...(session.cliConfig || {}) };
+            const nextConfig = JSON.stringify(mergedConfig);
+            const nextStartedAt = existingSession.started_at > 0 ? Math.min(existingSession.started_at, startedAt) : startedAt;
+            if ((existingSession.cli_config || null) !== nextConfig || existingSession.started_at !== nextStartedAt) {
+                updateSession.run(nextConfig, nextStartedAt, session.sessionId);
+                changed = true;
+            }
+        }
+        else {
+            insertSession.run(session.sessionId, 'archived', JSON.stringify(session.cliConfig || {}), startedAt);
+            changed = true;
+        }
+        const existingMessages = getMessagesBySession.all(session.sessionId);
+        const byId = new Map();
+        const bySpecial = new Map();
+        const byToolUseId = new Map();
+        const bySignature = new Map();
+        const rememberMessage = (message) => {
+            putFirst(byId, message.id, message);
+            putFirst(bySpecial, codexSpecialKeyFromDetails(message.details, message.type), message);
+            if (message.type === 'tool_call' || message.type === 'tool') {
+                putFirst(byToolUseId, message.toolUseId, message);
+            }
+            putFirst(bySignature, storedMessageSignature(message), message);
+        };
+        for (const message of existingMessages)
+            rememberMessage(message);
+        let insertedMessages = 0;
+        let updatedMessages = 0;
         for (const message of messages) {
-            const inserted = insertMessage.run(message.id, message.type, message.content || '', message.time || '', message.status || null, message.toolName || null, message.toolDetails || null, message.toolUseId || null, message.toolResult || null, message.permission ? JSON.stringify(message.permission) : null, message.details ? JSON.stringify(message.details) : null, session.sessionId);
-            lastSeq = Number(inserted.lastInsertRowid);
+            if (!message.id || !message.type)
+                continue;
+            const next = {
+                id: message.id,
+                type: message.type,
+                content: message.content || '',
+                time: message.time || '',
+                status: textOrNull(message.status),
+                toolName: textOrNull(message.toolName),
+                toolDetails: textOrNull(message.toolDetails),
+                toolUseId: textOrNull(message.toolUseId),
+                toolResult: textOrNull(message.toolResult),
+                permission: jsonOrNull(message.permission),
+                details: jsonOrNull(message.details),
+            };
+            const specialKey = codexSpecialKeyFromDetails(message.details, message.type);
+            const signature = importedMessageSignature(message);
+            const existing = byId.get(next.id)
+                || (next.toolUseId && (next.type === 'tool_call' || next.type === 'tool') ? byToolUseId.get(next.toolUseId) : undefined)
+                || (specialKey ? bySpecial.get(specialKey) : undefined)
+                || bySignature.get(signature);
+            if (existing) {
+                const differs = existing.id !== next.id
+                    || existing.type !== next.type
+                    || existing.content !== next.content
+                    || existing.time !== next.time
+                    || (existing.status || null) !== next.status
+                    || (existing.toolName || null) !== next.toolName
+                    || (existing.toolDetails || null) !== next.toolDetails
+                    || (existing.toolUseId || null) !== next.toolUseId
+                    || (existing.toolResult || null) !== next.toolResult
+                    || (existing.permission || null) !== next.permission
+                    || (existing.details || null) !== next.details;
+                if (differs) {
+                    updateMessage.run(next.id, next.type, next.content, next.time, next.status, next.toolName, next.toolDetails, next.toolUseId, next.toolResult, next.permission, next.details, existing.seq);
+                    updatedMessages += 1;
+                    changed = true;
+                    rememberMessage({
+                        ...existing,
+                        ...next,
+                        status: next.status || undefined,
+                        toolName: next.toolName || undefined,
+                        toolDetails: next.toolDetails || undefined,
+                        toolUseId: next.toolUseId || undefined,
+                        toolResult: next.toolResult || undefined,
+                        permission: next.permission || undefined,
+                        details: next.details || undefined,
+                    });
+                }
+                continue;
+            }
+            const inserted = insertMessage.run(next.id, next.type, next.content, next.time, next.status, next.toolName, next.toolDetails, next.toolUseId, next.toolResult, next.permission, next.details, session.sessionId);
+            insertedMessages += 1;
+            changed = true;
+            if (next.type === 'user_message' || next.type === 'user') {
+                recordPromptHistory({
+                    text: next.content,
+                    workDir,
+                    sessionId: session.sessionId,
+                    messageId: next.id,
+                });
+            }
+            rememberMessage({
+                seq: Number(inserted.lastInsertRowid),
+                id: next.id,
+                type: next.type,
+                content: next.content,
+                time: next.time,
+                status: next.status || undefined,
+                toolName: next.toolName || undefined,
+                toolDetails: next.toolDetails || undefined,
+                toolUseId: next.toolUseId || undefined,
+                toolResult: next.toolResult || undefined,
+                permission: next.permission || undefined,
+                details: next.details || undefined,
+                session_id: session.sessionId,
+            });
+        }
+        if (insertedMessages > 0 || updatedMessages > 0) {
+            const row = getMaxSeq.get(session.sessionId);
+            if (row?.seq)
+                updateLastSeq.run(row.seq, session.sessionId);
+        }
+        const refreshedSession = (existingSession ? getSession.get(session.sessionId) : null);
+        const isActiveSession = (refreshedSession || existingSession)?.status !== 'archived' && !!(refreshedSession || existingSession);
+        const existingTask = (getTaskById.get(session.taskId) || getTaskBySession.get(session.sessionId));
+        const taskStatus = session.status || 'completed';
+        const taskTitle = session.title || 'Codex 会话记录';
+        if (existingTask) {
+            const taskDiffers = existingTask.session_id !== session.sessionId
+                || (existingTask.work_dir || null) !== (workDir || null)
+                || existingTask.status !== taskStatus
+                || existingTask.title !== taskTitle
+                || existingTask.confirm_count !== confirmCount
+                || existingTask.tool_count !== toolCount
+                || (existingTask.duration || null) !== duration
+                || existingTask.start_time !== startedAt
+                || existingTask.end_time !== endedAt
+                || existingTask.created_at !== createdAt;
+            if (taskDiffers) {
+                updateTask.run(session.sessionId, workDir, taskStatus, taskTitle, confirmCount, toolCount, duration, startedAt, endedAt, createdAt, existingTask.id);
+                changed = true;
+            }
         }
-        if (lastSeq > 0) {
-            updateLastSeq.run(lastSeq, session.sessionId);
+        else if (!isActiveSession) {
+            insertTask.run(session.taskId, session.sessionId, workDir, taskStatus, taskTitle, confirmCount, toolCount, duration, startedAt, endedAt, createdAt);
+            changed = true;
         }
-        insertTask.run(session.taskId, session.sessionId, workDir, session.status || 'completed', session.title || 'Codex 会话记录', confirmCount, toolCount, duration, startedAt, endedAt, createdAt);
-        return messages.length;
+        return { createdSession, changed, insertedMessages };
     });
     for (const session of sessions) {
         try {
-            if (!session.sessionId || !session.taskId || session.messages.length === 0) {
+            if (!session.sessionId || !session.taskId || !session.messages || session.messages.length === 0) {
                 result.skipped += 1;
                 continue;
             }
-            if (sessionExists.get(session.sessionId) || taskExists.get(session.taskId)) {
+            const imported = importOne(session);
+            if (imported.createdSession) {
+                result.imported += 1;
+            }
+            else if (imported.changed) {
+                result.updated += 1;
+            }
+            else {
                 result.skipped += 1;
-                continue;
             }
-            const importedMessages = importOne(session);
-            result.imported += 1;
-            result.messagesImported += importedMessages;
+            result.messagesImported += imported.insertedMessages;
         }
         catch (err) {
             result.failed += 1;
             result.errors.push(`${session.sessionId || 'unknown'}: ${err?.message || 'import failed'}`);
         }
     }
-    console.log(`[Store] Synced Codex history: imported=${result.imported}, skipped=${result.skipped}, failed=${result.failed}`);
+    console.log(`[Store] Synced Codex history: imported=${result.imported}, updated=${result.updated}, skipped=${result.skipped}, failed=${result.failed}`);
     return result;
 }
 // --- Cleanup ---