stakeout-cli 0.1.0

package/dist/lib/config.js

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const CONFIG_DIR = join(homedir(), '.stakeout');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+const DEFAULT_CONFIG = {
+    llm_provider: 'ollama',
+    ollama_model: 'llama3',
+    ollama_host: 'http://localhost:11434',
+    openai_model: 'gpt-4o-mini',
+    watched_path: process.cwd(),
+    ignore_patterns: [
+        '*.lock',
+        'package-lock.json',
+        'yarn.lock',
+        'pnpm-lock.yaml',
+        'node_modules/**',
+        'dist/**',
+        'build/**',
+        '.git/**',
+        '*.min.js',
+        '*.min.css',
+        '*.map'
+    ]
+};
+export function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+export function loadConfig() {
+    ensureConfigDir();
+    if (!existsSync(CONFIG_FILE)) {
+        saveConfig(DEFAULT_CONFIG);
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const raw = readFileSync(CONFIG_FILE, 'utf-8');
+        return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+    }
+    catch {
+        return DEFAULT_CONFIG;
+    }
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function getConfigPath() {
+    return CONFIG_FILE;
+}

package/dist/lib/database.d.ts

@@ -0,0 +1,31 @@
+import Database from 'better-sqlite3';
+import type { StakeoutEntry } from '../types/index.js';
+export declare function getDb(): Database.Database;
+export declare function insertEntry(entry: StakeoutEntry): number;
+export declare function updateEntry(id: number, updates: Partial<StakeoutEntry>): void;
+export declare function getEntry(id: number): StakeoutEntry | null;
+export declare function getEntries(options: {
+    limit?: number;
+    since?: string;
+    path?: string;
+    repo?: string;
+    favorites?: boolean;
+    tag?: string;
+}): StakeoutEntry[];
+export declare function entryExists(diffHash: string): boolean;
+export declare function addRepo(path: string, name: string): void;
+export declare function getRepos(): {
+    id: number;
+    path: string;
+    name: string;
+    added_at: string;
+    last_recorded: string | null;
+}[];
+export declare function updateRepoLastRecorded(path: string): void;
+export declare function addChatMessage(role: 'user' | 'assistant', content: string): void;
+export declare function getChatHistory(limit?: number): {
+    role: string;
+    content: string;
+}[];
+export declare function clearChatHistory(): void;
+export declare function closeDb(): void;

package/dist/lib/database.js

@@ -0,0 +1,222 @@
+import Database from 'better-sqlite3';
+import { join } from 'path';
+import { homedir } from 'os';
+import { ensureConfigDir } from './config.js';
+const DB_PATH = join(homedir(), '.stakeout', 'stakeout.db');
+let db = null;
+export function getDb() {
+    if (!db) {
+        ensureConfigDir();
+        db = new Database(DB_PATH);
+        initSchema();
+        migrateSchema();
+        createIndexes();
+    }
+    return db;
+}
+function initSchema() {
+    const database = db;
+    // Create base tables (without new columns for backwards compat)
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS entries (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp TEXT NOT NULL,
+      files_changed TEXT NOT NULL,
+      directories TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      diff_hash TEXT NOT NULL,
+      commit_hash TEXT,
+      commit_message TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS repos (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      path TEXT UNIQUE NOT NULL,
+      name TEXT NOT NULL,
+      added_at TEXT NOT NULL,
+      last_recorded TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS chat_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL
+    );
+  `);
+}
+function createIndexes() {
+    const database = db;
+    // Create indexes after migrations have added all columns
+    try {
+        database.exec(`
+      CREATE INDEX IF NOT EXISTS idx_timestamp ON entries(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_diff_hash ON entries(diff_hash);
+    `);
+        // Only create these if columns exist
+        const columns = database.prepare("PRAGMA table_info(entries)").all();
+        const columnNames = columns.map(c => c.name);
+        if (columnNames.includes('favorite')) {
+            database.exec(`CREATE INDEX IF NOT EXISTS idx_favorite ON entries(favorite);`);
+        }
+        if (columnNames.includes('repo_path')) {
+            database.exec(`CREATE INDEX IF NOT EXISTS idx_repo_path ON entries(repo_path);`);
+        }
+    }
+    catch (e) {
+        // Indexes may already exist
+    }
+}
+function migrateSchema() {
+    const database = db;
+    // Add new columns if they don't exist (for existing databases)
+    const columns = database.prepare("PRAGMA table_info(entries)").all();
+    const columnNames = columns.map(c => c.name);
+    if (!columnNames.includes('tags')) {
+        database.exec("ALTER TABLE entries ADD COLUMN tags TEXT DEFAULT '[]'");
+    }
+    if (!columnNames.includes('favorite')) {
+        database.exec("ALTER TABLE entries ADD COLUMN favorite INTEGER DEFAULT 0");
+    }
+    if (!columnNames.includes('notes')) {
+        database.exec("ALTER TABLE entries ADD COLUMN notes TEXT DEFAULT ''");
+    }
+    if (!columnNames.includes('repo_path')) {
+        database.exec("ALTER TABLE entries ADD COLUMN repo_path TEXT DEFAULT ''");
+    }
+    if (!columnNames.includes('is_breaking')) {
+        database.exec("ALTER TABLE entries ADD COLUMN is_breaking INTEGER DEFAULT 0");
+    }
+}
+export function insertEntry(entry) {
+    const database = getDb();
+    const stmt = database.prepare(`
+    INSERT INTO entries (timestamp, files_changed, directories, summary, diff_hash, commit_hash, commit_message, tags, favorite, notes, repo_path, is_breaking)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const result = stmt.run(entry.timestamp, JSON.stringify(entry.files_changed), JSON.stringify(entry.directories), entry.summary, entry.diff_hash, entry.commit_hash ?? null, entry.commit_message ?? null, JSON.stringify(entry.tags || []), entry.favorite ? 1 : 0, entry.notes || '', entry.repo_path || '', entry.is_breaking ? 1 : 0);
+    return result.lastInsertRowid;
+}
+export function updateEntry(id, updates) {
+    const database = getDb();
+    const fields = [];
+    const values = [];
+    if (updates.tags !== undefined) {
+        fields.push('tags = ?');
+        values.push(JSON.stringify(updates.tags));
+    }
+    if (updates.favorite !== undefined) {
+        fields.push('favorite = ?');
+        values.push(updates.favorite ? 1 : 0);
+    }
+    if (updates.notes !== undefined) {
+        fields.push('notes = ?');
+        values.push(updates.notes);
+    }
+    if (updates.is_breaking !== undefined) {
+        fields.push('is_breaking = ?');
+        values.push(updates.is_breaking ? 1 : 0);
+    }
+    if (fields.length === 0)
+        return;
+    values.push(id);
+    const stmt = database.prepare(`UPDATE entries SET ${fields.join(', ')} WHERE id = ?`);
+    stmt.run(...values);
+}
+export function getEntry(id) {
+    const database = getDb();
+    const row = database.prepare('SELECT * FROM entries WHERE id = ?').get(id);
+    if (!row)
+        return null;
+    return parseEntryRow(row);
+}
+export function getEntries(options) {
+    const database = getDb();
+    let query = 'SELECT * FROM entries WHERE 1=1';
+    const params = [];
+    if (options.since) {
+        query += ' AND timestamp >= ?';
+        params.push(options.since);
+    }
+    if (options.path) {
+        query += ' AND (files_changed LIKE ? OR directories LIKE ?)';
+        params.push(`%${options.path}%`, `%${options.path}%`);
+    }
+    if (options.repo) {
+        query += ' AND repo_path = ?';
+        params.push(options.repo);
+    }
+    if (options.favorites) {
+        query += ' AND favorite = 1';
+    }
+    if (options.tag) {
+        query += ' AND tags LIKE ?';
+        params.push(`%"${options.tag}"%`);
+    }
+    query += ' ORDER BY timestamp DESC';
+    if (options.limit) {
+        query += ' LIMIT ?';
+        params.push(options.limit);
+    }
+    const stmt = database.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map(parseEntryRow);
+}
+function parseEntryRow(row) {
+    return {
+        id: row.id,
+        timestamp: row.timestamp,
+        files_changed: JSON.parse(row.files_changed),
+        directories: JSON.parse(row.directories),
+        summary: row.summary,
+        diff_hash: row.diff_hash,
+        commit_hash: row.commit_hash,
+        commit_message: row.commit_message,
+        tags: row.tags ? JSON.parse(row.tags) : [],
+        favorite: row.favorite === 1,
+        notes: row.notes || '',
+        repo_path: row.repo_path || '',
+        is_breaking: row.is_breaking === 1
+    };
+}
+export function entryExists(diffHash) {
+    const database = getDb();
+    const stmt = database.prepare('SELECT 1 FROM entries WHERE diff_hash = ?');
+    return stmt.get(diffHash) !== undefined;
+}
+// Repo management
+export function addRepo(path, name) {
+    const database = getDb();
+    const stmt = database.prepare(`
+    INSERT OR REPLACE INTO repos (path, name, added_at, last_recorded)
+    VALUES (?, ?, ?, NULL)
+  `);
+    stmt.run(path, name, new Date().toISOString());
+}
+export function getRepos() {
+    const database = getDb();
+    return database.prepare('SELECT * FROM repos ORDER BY name').all();
+}
+export function updateRepoLastRecorded(path) {
+    const database = getDb();
+    database.prepare('UPDATE repos SET last_recorded = ? WHERE path = ?').run(new Date().toISOString(), path);
+}
+// Chat history
+export function addChatMessage(role, content) {
+    const database = getDb();
+    database.prepare('INSERT INTO chat_history (timestamp, role, content) VALUES (?, ?, ?)').run(new Date().toISOString(), role, content);
+}
+export function getChatHistory(limit = 20) {
+    const database = getDb();
+    return database.prepare('SELECT role, content FROM chat_history ORDER BY id DESC LIMIT ?').all(limit).reverse();
+}
+export function clearChatHistory() {
+    const database = getDb();
+    database.prepare('DELETE FROM chat_history').run();
+}
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}

package/dist/lib/diff.d.ts

@@ -0,0 +1,3 @@
+import type { DiffResult } from '../types/index.js';
+export declare function collectDiff(targetPath?: string): Promise<DiffResult | null>;
+export declare function collectLastCommit(targetPath?: string): Promise<DiffResult | null>;

package/dist/lib/diff.js

@@ -0,0 +1,118 @@
+import { simpleGit } from 'simple-git';
+import { createHash } from 'crypto';
+import { loadConfig } from './config.js';
+export async function collectDiff(targetPath) {
+    const config = loadConfig();
+    const path = targetPath ?? config.watched_path;
+    const git = simpleGit(path);
+    // Check if it's a git repo
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        console.error('Not a git repository:', path);
+        return null;
+    }
+    // Get the diff - staged + unstaged changes
+    const diff = await git.diff();
+    const stagedDiff = await git.diff(['--staged']);
+    const combinedDiff = diff + stagedDiff;
+    if (!combinedDiff.trim()) {
+        // No uncommitted changes, check last commit
+        const log = await git.log({ maxCount: 1 });
+        if (!log.latest) {
+            return null;
+        }
+        const lastCommitDiff = await git.diff([`${log.latest.hash}^`, log.latest.hash]);
+        if (!lastCommitDiff.trim()) {
+            return null;
+        }
+        return parseDiff(lastCommitDiff, log.latest.hash, log.latest.message);
+    }
+    return parseDiff(combinedDiff);
+}
+export async function collectLastCommit(targetPath) {
+    const config = loadConfig();
+    const path = targetPath ?? config.watched_path;
+    const git = simpleGit(path);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        console.error('Not a git repository:', path);
+        return null;
+    }
+    const log = await git.log({ maxCount: 1 });
+    if (!log.latest) {
+        return null;
+    }
+    // Get diff of the last commit
+    const commitDiff = await git.diff([`${log.latest.hash}^`, log.latest.hash]).catch(() => {
+        // First commit has no parent, get the full tree
+        return git.show([log.latest.hash, '--format=', '--name-only']);
+    });
+    if (!commitDiff.trim()) {
+        return null;
+    }
+    return parseDiff(commitDiff, log.latest.hash, log.latest.message);
+}
+function parseDiff(diffText, commitHash, commitMessage) {
+    const config = loadConfig();
+    // Extract file paths from diff
+    const fileMatches = diffText.matchAll(/^(?:diff --git a\/(.+?) b\/|(?:\+\+\+|---) [ab]\/(.+))$/gm);
+    const filesSet = new Set();
+    for (const match of fileMatches) {
+        const file = match[1] || match[2];
+        if (file && !shouldIgnore(file, config.ignore_patterns)) {
+            filesSet.add(file);
+        }
+    }
+    const files = Array.from(filesSet);
+    // Extract unique directories
+    const dirsSet = new Set();
+    for (const file of files) {
+        const parts = file.split('/');
+        if (parts.length > 1) {
+            // Add immediate parent and top-level dir
+            dirsSet.add(parts[0]);
+            if (parts.length > 2) {
+                dirsSet.add(parts.slice(0, 2).join('/'));
+            }
+        }
+    }
+    const directories = Array.from(dirsSet);
+    // Create hash for deduplication
+    const diffHash = createHash('sha256').update(diffText).digest('hex').slice(0, 16);
+    // Filter the diff text to remove ignored files
+    const filteredDiff = filterDiffText(diffText, config.ignore_patterns);
+    return {
+        files,
+        directories,
+        diff_text: filteredDiff,
+        diff_hash: diffHash,
+        commit_hash: commitHash,
+        commit_message: commitMessage
+    };
+}
+function shouldIgnore(filePath, patterns) {
+    for (const pattern of patterns) {
+        if (matchPattern(filePath, pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchPattern(filePath, pattern) {
+    // Simple glob matching
+    const regexPattern = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*');
+    return new RegExp(`^${regexPattern}$`).test(filePath);
+}
+function filterDiffText(diffText, ignorePatterns) {
+    const chunks = diffText.split(/(?=^diff --git)/m);
+    const filteredChunks = chunks.filter(chunk => {
+        const match = chunk.match(/^diff --git a\/(.+?) b\//);
+        if (!match)
+            return true;
+        return !shouldIgnore(match[1], ignorePatterns);
+    });
+    return filteredChunks.join('');
+}

package/dist/lib/summarizer.d.ts

@@ -0,0 +1,2 @@
+import type { DiffResult } from '../types/index.js';
+export declare function summarize(diff: DiffResult): Promise<string>;

package/dist/lib/summarizer.js

@@ -0,0 +1,90 @@
+import { Ollama } from 'ollama';
+import OpenAI from 'openai';
+import { loadConfig } from './config.js';
+const SYSTEM_PROMPT = `You are a code change analyst. Your job is to summarize code changes concisely.
+
+Rules:
+- Focus on the WHY and IMPACT, not just what files changed
+- Be concise: 1-3 sentences max
+- Use plain language, avoid jargon
+- If there's a commit message, use it as context for intent
+- Group related changes together conceptually
+- Mention breaking changes or risky modifications explicitly
+
+Example good summary:
+"Added rate limiting to the auth endpoints to prevent brute force attacks. Also fixed a bug where expired tokens weren't being rejected properly."
+
+Example bad summary:
+"Modified auth.ts, added rate-limiter.ts, updated config.json"`;
+export async function summarize(diff) {
+    const config = loadConfig();
+    const userPrompt = buildPrompt(diff);
+    if (config.llm_provider === 'ollama') {
+        return summarizeWithOllama(userPrompt, config.ollama_model, config.ollama_host);
+    }
+    else {
+        return summarizeWithOpenAI(userPrompt, config.openai_model, config.openai_api_key);
+    }
+}
+function buildPrompt(diff) {
+    let prompt = '';
+    if (diff.commit_message) {
+        prompt += `Commit message: "${diff.commit_message}"\n\n`;
+    }
+    prompt += `Files changed (${diff.files.length}):\n`;
+    prompt += diff.files.map(f => `  - ${f}`).join('\n');
+    prompt += '\n\n';
+    if (diff.directories.length > 0) {
+        prompt += `Areas affected: ${diff.directories.join(', ')}\n\n`;
+    }
+    // Truncate diff if too long (keep first 4000 chars)
+    const maxDiffLength = 4000;
+    let diffText = diff.diff_text;
+    if (diffText.length > maxDiffLength) {
+        diffText = diffText.slice(0, maxDiffLength) + '\n\n... (diff truncated)';
+    }
+    prompt += `Diff:\n\`\`\`\n${diffText}\n\`\`\``;
+    return prompt;
+}
+async function summarizeWithOllama(prompt, model, host) {
+    try {
+        const ollama = new Ollama({ host });
+        const response = await ollama.chat({
+            model,
+            messages: [
+                { role: 'system', content: SYSTEM_PROMPT },
+                { role: 'user', content: prompt }
+            ],
+            options: {
+                temperature: 0.3
+            }
+        });
+        return response.message.content.trim();
+    }
+    catch (error) {
+        if (error.code === 'ECONNREFUSED') {
+            throw new Error(`Cannot connect to Ollama at ${host}. Is Ollama running?\n` +
+                `Start it with: ollama serve\n` +
+                `Or switch to OpenAI with: stakeout config --provider openai`);
+        }
+        throw error;
+    }
+}
+async function summarizeWithOpenAI(prompt, model, apiKey) {
+    if (!apiKey) {
+        throw new Error('OpenAI API key not configured.\n' +
+            'Set it with: stakeout config --openai-key YOUR_KEY\n' +
+            'Or switch to Ollama with: stakeout config --provider ollama');
+    }
+    const openai = new OpenAI({ apiKey });
+    const response = await openai.chat.completions.create({
+        model,
+        messages: [
+            { role: 'system', content: SYSTEM_PROMPT },
+            { role: 'user', content: prompt }
+        ],
+        temperature: 0.3,
+        max_tokens: 500
+    });
+    return response.choices[0]?.message?.content?.trim() ?? 'Unable to generate summary';
+}

package/dist/tui/App.d.ts

@@ -0,0 +1 @@
+export declare function App(): import("react/jsx-runtime").JSX.Element;

package/dist/tui/App.js

@@ -0,0 +1,125 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import Spinner from 'ink-spinner';
+import { getEntries, getDb } from '../lib/database.js';
+import { collectDiff, collectLastCommit } from '../lib/diff.js';
+import { summarize } from '../lib/summarizer.js';
+import { insertEntry } from '../lib/database.js';
+export function App() {
+    const { exit } = useApp();
+    const [entries, setEntries] = useState([]);
+    const [stats, setStats] = useState({ total: 0, today: 0, thisWeek: 0 });
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [isRecording, setIsRecording] = useState(false);
+    const [message, setMessage] = useState('');
+    const [showHelp, setShowHelp] = useState(false);
+    const loadData = () => {
+        const db = getDb();
+        const totalEntries = db.prepare('SELECT COUNT(*) as count FROM entries').get();
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        const todayEntries = db.prepare('SELECT COUNT(*) as count FROM entries WHERE timestamp >= ?').get(today.toISOString());
+        const weekAgo = new Date();
+        weekAgo.setDate(weekAgo.getDate() - 7);
+        const weekEntries = db.prepare('SELECT COUNT(*) as count FROM entries WHERE timestamp >= ?').get(weekAgo.toISOString());
+        setStats({
+            total: totalEntries.count,
+            today: todayEntries.count,
+            thisWeek: weekEntries.count
+        });
+        setEntries(getEntries({ limit: 10 }));
+    };
+    useEffect(() => {
+        loadData();
+    }, []);
+    const showMessage = (msg) => {
+        setMessage(msg);
+        setTimeout(() => setMessage(''), 3000);
+    };
+    const doRecord = async (lastCommit) => {
+        setIsRecording(true);
+        setMessage(lastCommit ? 'Recording last commit...' : 'Recording changes...');
+        try {
+            const diff = lastCommit ? await collectLastCommit() : await collectDiff();
+            if (!diff) {
+                showMessage('No changes detected');
+                setIsRecording(false);
+                return;
+            }
+            const summary = await summarize(diff);
+            const entry = {
+                timestamp: new Date().toISOString(),
+                files_changed: diff.files,
+                directories: diff.directories,
+                summary,
+                diff_hash: diff.diff_hash,
+                commit_hash: diff.commit_hash,
+                commit_message: diff.commit_message
+            };
+            insertEntry(entry);
+            loadData();
+            showMessage('Recorded successfully!');
+        }
+        catch (err) {
+            showMessage(`Error: ${err.message}`);
+        }
+        setIsRecording(false);
+    };
+    useInput((input, key) => {
+        if (showHelp) {
+            setShowHelp(false);
+            return;
+        }
+        if (input === 'q') {
+            exit();
+            return;
+        }
+        if (input === '?') {
+            setShowHelp(true);
+            return;
+        }
+        if (input === 'r' && !isRecording) {
+            doRecord(false);
+            return;
+        }
+        if (input === 'c' && !isRecording) {
+            doRecord(true);
+            return;
+        }
+        if (input === 'f') {
+            loadData();
+            showMessage('Refreshed');
+            return;
+        }
+        if (key.upArrow && selectedIndex > 0) {
+            setSelectedIndex(selectedIndex - 1);
+        }
+        if (key.downArrow && selectedIndex < entries.length - 1) {
+            setSelectedIndex(selectedIndex + 1);
+        }
+    });
+    if (showHelp) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "STAKEOUT - Keyboard Shortcuts" }) }), _jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "r" }), " - Record current changes"] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "c" }), " - Record last commit"] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "f" }), " - Refresh data"] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "\u2191/\u2193" }), " - Navigate entries"] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "?" }), " - Show/hide help"] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "q" }), " - Quit"] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press any key to close" }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "green", children: "\uD83D\uDD0D STAKEOUT" }), _jsx(Text, { dimColor: true, children: " - Command Center" }), _jsx(Box, { flexGrow: 1 }), _jsx(Text, { dimColor: true, children: "[?] help  [q] quit" })] }), _jsxs(Box, { marginBottom: 1, gap: 2, children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: stats.total }), _jsx(Text, { dimColor: true, children: " total" })] }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: stats.today }), _jsx(Text, { dimColor: true, children: " today" })] }), _jsxs(Box, { children: [_jsx(Text, { color: "yellow", bold: true, children: stats.thisWeek }), _jsx(Text, { dimColor: true, children: " this week" })] })] }), _jsx(Box, { marginBottom: 1, gap: 2, children: isRecording ? (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), _jsxs(Text, { color: "yellow", children: [" ", message] })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "[r] record" }), _jsx(Text, { dimColor: true, children: "[c] last commit" }), _jsx(Text, { dimColor: true, children: "[f] refresh" })] })) }), message && !isRecording && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "cyan", children: message }) })), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: '─'.repeat(60) }) }), entries.length === 0 ? (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "No intel recorded. Press [r] to record changes." }) })) : (_jsx(Box, { flexDirection: "column", children: entries.map((entry, i) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 1, borderStyle: i === selectedIndex ? 'single' : undefined, borderColor: "green", children: [_jsxs(Box, { gap: 2, children: [_jsxs(Text, { color: "green", children: ["#", entry.id] }), _jsx(Text, { dimColor: true, children: formatTime(entry.timestamp) }), entry.commit_hash && (_jsx(Text, { color: "magenta", children: entry.commit_hash.slice(0, 7) }))] }), _jsx(Text, { wrap: "truncate-end", children: entry.summary.length > 80
+                                ? entry.summary.slice(0, 80) + '...'
+                                : entry.summary })] }, entry.id))) }))] }));
+}
+function formatTime(timestamp) {
+    const date = new Date(timestamp);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffMins < 1)
+        return 'just now';
+    if (diffMins < 60)
+        return `${diffMins}m ago`;
+    if (diffHours < 24)
+        return `${diffHours}h ago`;
+    if (diffDays < 7)
+        return `${diffDays}d ago`;
+    return date.toLocaleDateString();
+}