stakeout-cli 0.1.0

package/dist/commands/digest.js

@@ -0,0 +1,113 @@
+import chalk from 'chalk';
+import { getEntries } from '../lib/database.js';
+import { loadConfig } from '../lib/config.js';
+import { Ollama } from 'ollama';
+import OpenAI from 'openai';
+export async function digest(options) {
+    const since = options.since ? parseSince(options.since) : getWeekAgo();
+    console.log(chalk.dim('🔍 Gathering intel...'));
+    const entries = getEntries({
+        limit: 100,
+        since,
+        path: options.path
+    });
+    if (entries.length === 0) {
+        console.log(chalk.yellow('No entries found in this time period.'));
+        return;
+    }
+    console.log(chalk.dim(`📊 Found ${entries.length} entries`));
+    console.log(chalk.dim('🤖 Generating digest...\n'));
+    // Build a summary of all entries
+    const entriesSummary = entries.map(e => {
+        const date = new Date(e.timestamp).toLocaleDateString();
+        const dirs = e.directories.length > 0 ? ` (${e.directories.join(', ')})` : '';
+        return `- [${date}]${dirs}: ${e.summary}`;
+    }).join('\n');
+    const prompt = `You are analyzing a development activity log. Create a high-level digest that:
+
+1. Identifies the main themes/areas of work
+2. Highlights significant changes or milestones
+3. Notes any patterns or concerns
+4. Provides a brief "executive summary" (2-3 sentences)
+
+Keep the digest concise but insightful. Focus on the big picture.
+
+Activity log:
+${entriesSummary}
+
+Generate a digest with sections: Executive Summary, Key Areas, Notable Changes, Patterns/Observations`;
+    try {
+        const summary = await generateDigest(prompt);
+        console.log(chalk.bold.green('📋 STAKEOUT DIGEST'));
+        console.log(chalk.dim(`Period: ${new Date(since).toLocaleDateString()} - ${new Date().toLocaleDateString()}`));
+        console.log(chalk.dim(`Entries analyzed: ${entries.length}`));
+        console.log(chalk.dim('─'.repeat(60)));
+        console.log('');
+        console.log(summary);
+        console.log('');
+    }
+    catch (error) {
+        console.error(chalk.red('Error generating digest: ' + error.message));
+        process.exit(1);
+    }
+}
+async function generateDigest(prompt) {
+    const config = loadConfig();
+    if (config.llm_provider === 'ollama') {
+        const ollama = new Ollama({ host: config.ollama_host });
+        const response = await ollama.chat({
+            model: config.ollama_model,
+            messages: [{ role: 'user', content: prompt }],
+            options: { temperature: 0.4 }
+        });
+        return response.message.content.trim();
+    }
+    else {
+        if (!config.openai_api_key) {
+            throw new Error('OpenAI API key not configured');
+        }
+        const openai = new OpenAI({ apiKey: config.openai_api_key });
+        const response = await openai.chat.completions.create({
+            model: config.openai_model,
+            messages: [{ role: 'user', content: prompt }],
+            temperature: 0.4,
+            max_tokens: 1000
+        });
+        return response.choices[0]?.message?.content?.trim() ?? 'Unable to generate digest';
+    }
+}
+function parseSince(since) {
+    const now = new Date();
+    const match = since.match(/^(\d+)\s*(day|days|week|weeks|month|months)$/i);
+    if (match) {
+        const amount = parseInt(match[1], 10);
+        const unit = match[2].toLowerCase();
+        switch (unit) {
+            case 'day':
+            case 'days':
+                now.setDate(now.getDate() - amount);
+                break;
+            case 'week':
+            case 'weeks':
+                now.setDate(now.getDate() - (amount * 7));
+                break;
+            case 'month':
+            case 'months':
+                now.setMonth(now.getMonth() - amount);
+                break;
+        }
+        return now.toISOString();
+    }
+    // Try to parse as date
+    const parsed = new Date(since);
+    if (!isNaN(parsed.getTime())) {
+        return parsed.toISOString();
+    }
+    // Default to 1 week
+    return getWeekAgo();
+}
+function getWeekAgo() {
+    const now = new Date();
+    now.setDate(now.getDate() - 7);
+    return now.toISOString();
+}

package/dist/commands/export.d.ts

@@ -0,0 +1,8 @@
+interface ExportOptions {
+    format?: string;
+    since?: string;
+    path?: string;
+    output?: string;
+}
+export declare function exportCmd(options: ExportOptions): Promise<void>;
+export {};

package/dist/commands/export.js

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { getEntries } from '../lib/database.js';
+export async function exportCmd(options) {
+    const format = options.format || 'markdown';
+    const since = options.since ? parseSince(options.since) : undefined;
+    const entries = getEntries({
+        limit: 1000,
+        since,
+        path: options.path
+    });
+    if (entries.length === 0) {
+        console.log(chalk.yellow('No entries to export.'));
+        return;
+    }
+    let content;
+    let extension;
+    switch (format.toLowerCase()) {
+        case 'json':
+            content = JSON.stringify(entries, null, 2);
+            extension = 'json';
+            break;
+        case 'csv':
+            content = exportToCsv(entries);
+            extension = 'csv';
+            break;
+        case 'markdown':
+        case 'md':
+        default:
+            content = exportToMarkdown(entries);
+            extension = 'md';
+            break;
+    }
+    const outputPath = options.output || `stakeout-export-${Date.now()}.${extension}`;
+    writeFileSync(outputPath, content);
+    console.log(chalk.green(`✓ Exported ${entries.length} entries to ${outputPath}`));
+}
+function exportToMarkdown(entries) {
+    const lines = [
+        '# STAKEOUT Export',
+        '',
+        `Generated: ${new Date().toISOString()}`,
+        `Entries: ${entries.length}`,
+        '',
+        '---',
+        ''
+    ];
+    for (const entry of entries) {
+        const date = new Date(entry.timestamp).toLocaleString();
+        lines.push(`## Entry #${entry.id}`);
+        lines.push('');
+        lines.push(`**Date:** ${date}`);
+        if (entry.commit_hash) {
+            lines.push(`**Commit:** \`${entry.commit_hash.slice(0, 7)}\``);
+        }
+        if (entry.commit_message) {
+            lines.push(`**Message:** ${entry.commit_message}`);
+        }
+        lines.push('');
+        lines.push('### Summary');
+        lines.push('');
+        lines.push(entry.summary);
+        lines.push('');
+        if (entry.directories.length > 0) {
+            lines.push('### Directories');
+            lines.push('');
+            lines.push(entry.directories.map((d) => `- \`${d}\``).join('\n'));
+            lines.push('');
+        }
+        if (entry.files_changed.length > 0) {
+            lines.push('### Files Changed');
+            lines.push('');
+            lines.push(entry.files_changed.slice(0, 20).map((f) => `- \`${f}\``).join('\n'));
+            if (entry.files_changed.length > 20) {
+                lines.push(`- ... and ${entry.files_changed.length - 20} more`);
+            }
+            lines.push('');
+        }
+        lines.push('---');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function exportToCsv(entries) {
+    const headers = ['id', 'timestamp', 'commit_hash', 'summary', 'directories', 'file_count'];
+    const rows = entries.map(e => [
+        e.id,
+        e.timestamp,
+        e.commit_hash || '',
+        `"${e.summary.replace(/"/g, '""')}"`,
+        `"${e.directories.join(', ')}"`,
+        e.files_changed.length
+    ]);
+    return [headers.join(','), ...rows.map(r => r.join(','))].join('\n');
+}
+function parseSince(since) {
+    const now = new Date();
+    const match = since.match(/^(\d+)\s*(day|days|week|weeks|month|months)$/i);
+    if (match) {
+        const amount = parseInt(match[1], 10);
+        const unit = match[2].toLowerCase();
+        switch (unit) {
+            case 'day':
+            case 'days':
+                now.setDate(now.getDate() - amount);
+                break;
+            case 'week':
+            case 'weeks':
+                now.setDate(now.getDate() - (amount * 7));
+                break;
+            case 'month':
+            case 'months':
+                now.setMonth(now.getMonth() - amount);
+                break;
+        }
+    }
+    return now.toISOString();
+}

package/dist/commands/hook.d.ts

@@ -0,0 +1,6 @@
+interface HookOptions {
+    path?: string;
+    remove?: boolean;
+}
+export declare function hook(options: HookOptions): Promise<void>;
+export {};

package/dist/commands/hook.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import { existsSync, writeFileSync, chmodSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { simpleGit } from 'simple-git';
+const HOOK_SCRIPT = `#!/bin/sh
+# STAKEOUT post-commit hook
+# Records changes after each commit
+
+stakeout record --last-commit 2>/dev/null || true
+`;
+export async function hook(options) {
+    const repoPath = options.path || process.cwd();
+    const git = simpleGit(repoPath);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        console.error(chalk.red('Not a git repository: ' + repoPath));
+        process.exit(1);
+    }
+    const gitDir = join(repoPath, '.git');
+    const hooksDir = join(gitDir, 'hooks');
+    const hookPath = join(hooksDir, 'post-commit');
+    if (options.remove) {
+        if (existsSync(hookPath)) {
+            const { unlinkSync } = await import('fs');
+            unlinkSync(hookPath);
+            console.log(chalk.green('✓ Removed post-commit hook'));
+        }
+        else {
+            console.log(chalk.yellow('No hook installed'));
+        }
+        return;
+    }
+    // Create hooks directory if it doesn't exist
+    if (!existsSync(hooksDir)) {
+        mkdirSync(hooksDir, { recursive: true });
+    }
+    // Check if hook already exists
+    if (existsSync(hookPath)) {
+        console.log(chalk.yellow('Hook already exists at: ' + hookPath));
+        console.log(chalk.dim('Use --remove to uninstall first'));
+        return;
+    }
+    // Write the hook
+    writeFileSync(hookPath, HOOK_SCRIPT, { mode: 0o755 });
+    // Make sure it's executable (for Unix systems)
+    try {
+        chmodSync(hookPath, 0o755);
+    }
+    catch {
+        // Windows doesn't need chmod
+    }
+    console.log(chalk.green('✓ Installed post-commit hook'));
+    console.log(chalk.dim('  Location: ' + hookPath));
+    console.log('');
+    console.log(chalk.cyan('Now every commit will automatically record a summary!'));
+    console.log(chalk.dim('To remove: stakeout hook --remove'));
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,6 @@
+interface InitOptions {
+    path?: string;
+    hook?: boolean;
+}
+export declare function init(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,70 @@
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { simpleGit } from 'simple-git';
+import { loadConfig, saveConfig } from '../lib/config.js';
+import { hook } from './hook.js';
+export async function init(options) {
+    const repoPath = options.path || process.cwd();
+    console.log(chalk.bold.green('\n🔍 STAKEOUT Setup\n'));
+    console.log(chalk.dim('─'.repeat(40)));
+    // Check if it's a git repo
+    const git = simpleGit(repoPath);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        console.log(chalk.red('✗ Not a git repository'));
+        console.log(chalk.dim(`  Path: ${repoPath}`));
+        console.log(chalk.dim('  Initialize with: git init'));
+        return;
+    }
+    console.log(chalk.green('✓ Git repository detected'));
+    console.log(chalk.dim(`  Path: ${repoPath}`));
+    // Get repo info
+    const log = await git.log({ maxCount: 1 }).catch(() => null);
+    if (log?.latest) {
+        console.log(chalk.dim(`  Latest commit: ${log.latest.hash.slice(0, 7)} - ${log.latest.message.slice(0, 40)}`));
+    }
+    // Update config with this path
+    const config = loadConfig();
+    config.watched_path = repoPath;
+    saveConfig(config);
+    console.log(chalk.green('✓ Set as watched path'));
+    // Check Ollama
+    console.log('');
+    console.log(chalk.dim('Checking LLM provider...'));
+    try {
+        const { Ollama } = await import('ollama');
+        const ollama = new Ollama({ host: config.ollama_host });
+        await ollama.list();
+        console.log(chalk.green(`✓ Ollama connected (${config.ollama_model})`));
+    }
+    catch {
+        console.log(chalk.yellow('⚠ Ollama not available'));
+        console.log(chalk.dim('  Start with: ollama serve'));
+        console.log(chalk.dim('  Or use: stakeout config --provider openai'));
+    }
+    // Install hook if requested
+    if (options.hook !== false) {
+        console.log('');
+        console.log(chalk.dim('Installing git hook...'));
+        const hooksDir = join(repoPath, '.git', 'hooks');
+        const hookPath = join(hooksDir, 'post-commit');
+        if (existsSync(hookPath)) {
+            console.log(chalk.yellow('⚠ Hook already exists'));
+        }
+        else {
+            await hook({ path: repoPath });
+        }
+    }
+    // Summary
+    console.log('');
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(chalk.bold.green('\n✓ STAKEOUT is ready!\n'));
+    console.log('Quick commands:');
+    console.log(chalk.cyan('  stakeout record') + chalk.dim('        # Record current changes'));
+    console.log(chalk.cyan('  stakeout record -c') + chalk.dim('     # Record last commit'));
+    console.log(chalk.cyan('  stakeout dash') + chalk.dim('          # Open web dashboard'));
+    console.log(chalk.cyan('  stakeout ui') + chalk.dim('            # Open terminal UI'));
+    console.log(chalk.cyan('  stakeout watch') + chalk.dim('         # Auto-record mode'));
+    console.log('');
+}

package/dist/commands/log.d.ts

@@ -0,0 +1,9 @@
+interface LogOptions {
+    limit?: string;
+    since?: string;
+    path?: string;
+    favorites?: boolean;
+    tag?: string;
+}
+export declare function log(options: LogOptions): Promise<void>;
+export {};

package/dist/commands/log.js

@@ -0,0 +1,103 @@
+import chalk from 'chalk';
+import { getEntries } from '../lib/database.js';
+export async function log(options) {
+    const limit = options.limit ? parseInt(options.limit, 10) : 10;
+    const since = options.since ? parseSince(options.since) : undefined;
+    const entries = getEntries({
+        limit,
+        since,
+        path: options.path,
+        favorites: options.favorites,
+        tag: options.tag
+    });
+    if (entries.length === 0) {
+        console.log(chalk.yellow('No entries found.'));
+        console.log(chalk.dim('Record changes with: stakeout record'));
+        return;
+    }
+    let title = 'STAKEOUT LOG';
+    if (options.favorites)
+        title = 'FAVORITES';
+    if (options.tag)
+        title = `TAG: ${options.tag}`;
+    console.log(chalk.bold(`\n📋 ${title} (${entries.length} entries)\n`));
+    console.log(chalk.dim('─'.repeat(60)));
+    for (const entry of entries) {
+        const date = new Date(entry.timestamp);
+        const timeAgo = getTimeAgo(date);
+        console.log('');
+        // Build status indicators
+        const indicators = [];
+        if (entry.favorite)
+            indicators.push(chalk.yellow('★'));
+        if (entry.is_breaking)
+            indicators.push(chalk.red('⚠️'));
+        console.log(chalk.cyan(`#${entry.id}`) +
+            (indicators.length > 0 ? ' ' + indicators.join(' ') : '') +
+            chalk.dim(` · ${timeAgo}`) +
+            (entry.commit_hash ? chalk.dim(` · ${entry.commit_hash.slice(0, 7)}`) : ''));
+        console.log(chalk.white(entry.summary));
+        if (entry.tags && entry.tags.length > 0) {
+            console.log(chalk.magenta(`  🏷️  ${entry.tags.join(', ')}`));
+        }
+        if (entry.notes) {
+            console.log(chalk.dim(`  📝 ${entry.notes}`));
+        }
+        if (entry.directories.length > 0) {
+            console.log(chalk.dim(`  📁 ${entry.directories.join(', ')}`));
+        }
+        console.log(chalk.dim('─'.repeat(60)));
+    }
+    console.log('');
+}
+function parseSince(since) {
+    const now = new Date();
+    const match = since.match(/^(\d+)\s*(day|days|week|weeks|hour|hours|month|months)$/i);
+    if (!match) {
+        // Try to parse as date
+        const parsed = new Date(since);
+        if (!isNaN(parsed.getTime())) {
+            return parsed.toISOString();
+        }
+        console.error(chalk.red(`Invalid --since format: ${since}`));
+        console.error(chalk.dim('Examples: "3 days", "1 week", "2 hours"'));
+        process.exit(1);
+    }
+    const amount = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    switch (unit) {
+        case 'hour':
+        case 'hours':
+            now.setHours(now.getHours() - amount);
+            break;
+        case 'day':
+        case 'days':
+            now.setDate(now.getDate() - amount);
+            break;
+        case 'week':
+        case 'weeks':
+            now.setDate(now.getDate() - (amount * 7));
+            break;
+        case 'month':
+        case 'months':
+            now.setMonth(now.getMonth() - amount);
+            break;
+    }
+    return now.toISOString();
+}
+function getTimeAgo(date) {
+    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();
+}

package/dist/commands/note.d.ts

@@ -0,0 +1,9 @@
+interface NoteOptions {
+    note?: string;
+    favorite?: boolean;
+    unfavorite?: boolean;
+    breaking?: boolean;
+    notBreaking?: boolean;
+}
+export declare function note(entryId: string, options: NoteOptions): Promise<void>;
+export {};

package/dist/commands/note.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { getEntry, updateEntry } from '../lib/database.js';
+export async function note(entryId, options) {
+    const id = parseInt(entryId, 10);
+    if (isNaN(id)) {
+        console.error(chalk.red('Invalid entry ID'));
+        return;
+    }
+    const entry = getEntry(id);
+    if (!entry) {
+        console.error(chalk.red(`Entry #${id} not found`));
+        return;
+    }
+    // If no options, show current state
+    if (!options.note && !options.favorite && !options.unfavorite && !options.breaking && !options.notBreaking) {
+        console.log(chalk.bold(`\nEntry #${id}\n`));
+        console.log(chalk.dim('Summary: ') + entry.summary);
+        console.log(chalk.dim('Favorite: ') + (entry.favorite ? chalk.yellow('★ Yes') : 'No'));
+        console.log(chalk.dim('Breaking: ') + (entry.is_breaking ? chalk.red('⚠️ Yes') : 'No'));
+        console.log(chalk.dim('Notes: ') + (entry.notes || chalk.dim('(none)')));
+        console.log('');
+        return;
+    }
+    const updates = {};
+    if (options.note !== undefined) {
+        updates.notes = options.note;
+        console.log(chalk.green(`✓ Updated note for entry #${id}`));
+    }
+    if (options.favorite) {
+        updates.favorite = true;
+        console.log(chalk.green(`✓ Marked entry #${id} as favorite ★`));
+    }
+    if (options.unfavorite) {
+        updates.favorite = false;
+        console.log(chalk.green(`✓ Removed favorite from entry #${id}`));
+    }
+    if (options.breaking) {
+        updates.is_breaking = true;
+        console.log(chalk.green(`✓ Marked entry #${id} as breaking change ⚠️`));
+    }
+    if (options.notBreaking) {
+        updates.is_breaking = false;
+        console.log(chalk.green(`✓ Unmarked entry #${id} as breaking change`));
+    }
+    if (Object.keys(updates).length > 0) {
+        updateEntry(id, updates);
+    }
+}

package/dist/commands/record.d.ts

@@ -0,0 +1,6 @@
+interface RecordOptions {
+    path?: string;
+    lastCommit?: boolean;
+}
+export declare function record(options: RecordOptions): Promise<void>;
+export {};

package/dist/commands/record.js

@@ -0,0 +1,106 @@
+import chalk from 'chalk';
+import { collectDiff, collectLastCommit } from '../lib/diff.js';
+import { summarize } from '../lib/summarizer.js';
+import { insertEntry, entryExists, updateRepoLastRecorded } from '../lib/database.js';
+import { loadConfig } from '../lib/config.js';
+// Default patterns that indicate potentially breaking changes
+const DEFAULT_BREAKING_PATTERNS = [
+    /^src\/api\//i,
+    /^api\//i,
+    /schema/i,
+    /migration/i,
+    /\.proto$/i,
+    /breaking/i,
+    /major/i,
+    /deprecated/i,
+    /removed?/i,
+    /delete/i,
+];
+export async function record(options) {
+    const config = loadConfig();
+    const repoPath = options.path || config.watched_path || process.cwd();
+    console.log(chalk.dim('🔍 Collecting changes...'));
+    const diff = options.lastCommit
+        ? await collectLastCommit(repoPath)
+        : await collectDiff(repoPath);
+    if (!diff) {
+        console.log(chalk.yellow('No changes detected.'));
+        return;
+    }
+    // Check for duplicates
+    if (entryExists(diff.diff_hash)) {
+        console.log(chalk.yellow('These changes have already been recorded.'));
+        return;
+    }
+    console.log(chalk.dim(`📁 ${diff.files.length} files changed`));
+    console.log(chalk.dim('🤖 Generating summary...'));
+    try {
+        const summary = await summarize(diff);
+        // Detect breaking changes
+        const isBreaking = detectBreakingChange(diff.files, diff.diff_text, summary);
+        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,
+            repo_path: repoPath,
+            is_breaking: isBreaking,
+            tags: [],
+            favorite: false,
+            notes: ''
+        };
+        const id = insertEntry(entry);
+        // Update repo last recorded time
+        updateRepoLastRecorded(repoPath);
+        console.log('');
+        console.log(chalk.green('✓ Recorded entry #' + id));
+        if (isBreaking) {
+            console.log(chalk.red.bold('⚠️  POTENTIAL BREAKING CHANGE DETECTED'));
+        }
+        console.log('');
+        console.log(chalk.bold('Summary:'));
+        console.log(chalk.white(summary));
+        console.log('');
+        console.log(chalk.dim(`Files: ${diff.files.slice(0, 5).join(', ')}${diff.files.length > 5 ? ` (+${diff.files.length - 5} more)` : ''}`));
+    }
+    catch (error) {
+        console.error(chalk.red('Error: ' + error.message));
+        process.exit(1);
+    }
+}
+function detectBreakingChange(files, diffText, summary) {
+    // Check files against breaking patterns
+    for (const file of files) {
+        for (const pattern of DEFAULT_BREAKING_PATTERNS) {
+            if (pattern.test(file)) {
+                return true;
+            }
+        }
+    }
+    // Check summary for breaking keywords
+    const breakingKeywords = [
+        'breaking change',
+        'breaking:',
+        'removed',
+        'deleted',
+        'deprecated',
+        'incompatible',
+        'migration required',
+        'schema change',
+        'api change'
+    ];
+    const lowerSummary = summary.toLowerCase();
+    for (const keyword of breakingKeywords) {
+        if (lowerSummary.includes(keyword)) {
+            return true;
+        }
+    }
+    // Check diff for removal of exports or public APIs
+    if (diffText.includes('-export ') || diffText.includes('-public ')) {
+        return true;
+    }
+    return false;
+}

package/dist/commands/repo.d.ts

@@ -0,0 +1,7 @@
+interface RepoOptions {
+    add?: string;
+    remove?: string;
+    list?: boolean;
+}
+export declare function repo(options: RepoOptions): Promise<void>;
+export {};