stakeout-cli 0.1.0

package/dist/commands/repo.js

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import { basename } from 'path';
+import { simpleGit } from 'simple-git';
+import { addRepo, getRepos, getDb } from '../lib/database.js';
+export async function repo(options) {
+    if (options.add) {
+        await addRepoCmd(options.add);
+        return;
+    }
+    if (options.remove) {
+        await removeRepoCmd(options.remove);
+        return;
+    }
+    // Default: list repos
+    await listReposCmd();
+}
+async function addRepoCmd(path) {
+    const git = simpleGit(path);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        console.error(chalk.red('Not a git repository: ' + path));
+        return;
+    }
+    const name = basename(path);
+    addRepo(path, name);
+    console.log(chalk.green(`✓ Added repository: ${name}`));
+    console.log(chalk.dim(`  Path: ${path}`));
+}
+async function removeRepoCmd(pathOrName) {
+    const db = getDb();
+    const result = db.prepare('DELETE FROM repos WHERE path = ? OR name = ?').run(pathOrName, pathOrName);
+    if (result.changes > 0) {
+        console.log(chalk.green(`✓ Removed repository: ${pathOrName}`));
+    }
+    else {
+        console.log(chalk.yellow(`Repository not found: ${pathOrName}`));
+    }
+}
+async function listReposCmd() {
+    const repos = getRepos();
+    const db = getDb();
+    console.log(chalk.bold('\n📦 Tracked Repositories\n'));
+    if (repos.length === 0) {
+        console.log(chalk.dim('No repositories tracked.'));
+        console.log(chalk.dim('Add one with: stakeout repo --add /path/to/repo'));
+        console.log('');
+        return;
+    }
+    for (const repo of repos) {
+        // Get entry count for this repo
+        const count = db.prepare('SELECT COUNT(*) as count FROM entries WHERE repo_path = ?').get(repo.path).count;
+        console.log(chalk.cyan(repo.name));
+        console.log(chalk.dim(`  Path: ${repo.path}`));
+        console.log(chalk.dim(`  Entries: ${count}`));
+        if (repo.last_recorded) {
+            console.log(chalk.dim(`  Last recorded: ${new Date(repo.last_recorded).toLocaleString()}`));
+        }
+        console.log('');
+    }
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,5 @@
+interface SearchOptions {
+    limit?: string;
+}
+export declare function search(query: string, options: SearchOptions): Promise<void>;
+export {};

package/dist/commands/search.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+import { getDb } from '../lib/database.js';
+export async function search(query, options) {
+    const limit = options.limit ? parseInt(options.limit, 10) : 20;
+    const db = getDb();
+    // Search in summaries, commit messages, files, and directories
+    const stmt = db.prepare(`
+    SELECT * FROM entries
+    WHERE summary LIKE ?
+       OR commit_message LIKE ?
+       OR files_changed LIKE ?
+       OR directories LIKE ?
+    ORDER BY timestamp DESC
+    LIMIT ?
+  `);
+    const pattern = `%${query}%`;
+    const rows = stmt.all(pattern, pattern, pattern, pattern, limit);
+    if (rows.length === 0) {
+        console.log(chalk.yellow(`No results for "${query}"`));
+        return;
+    }
+    console.log(chalk.bold(`\n🔍 Search results for "${query}" (${rows.length} found)\n`));
+    console.log(chalk.dim('─'.repeat(60)));
+    for (const row of rows) {
+        const entry = {
+            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
+        };
+        const date = new Date(entry.timestamp);
+        const timeAgo = getTimeAgo(date);
+        console.log('');
+        console.log(chalk.cyan(`#${entry.id}`) +
+            chalk.dim(` · ${timeAgo}`) +
+            (entry.commit_hash ? chalk.dim(` · ${entry.commit_hash.slice(0, 7)}`) : ''));
+        // Highlight the query in the summary
+        const highlightedSummary = entry.summary.replace(new RegExp(`(${escapeRegex(query)})`, 'gi'), chalk.bgYellow.black('$1'));
+        console.log(chalk.white(highlightedSummary));
+        if (entry.directories.length > 0) {
+            console.log(chalk.dim(`  📁 ${entry.directories.join(', ')}`));
+        }
+        console.log(chalk.dim('─'.repeat(60)));
+    }
+    console.log('');
+}
+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();
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/commands/stats.d.ts

@@ -0,0 +1 @@
+export declare function stats(): Promise<void>;

package/dist/commands/stats.js

@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+import { getDb } from '../lib/database.js';
+export async function stats() {
+    const db = getDb();
+    // Total entries
+    const total = db.prepare('SELECT COUNT(*) as count FROM entries').get();
+    // Today
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const todayCount = db.prepare('SELECT COUNT(*) as count FROM entries WHERE timestamp >= ?').get(today.toISOString());
+    // This week
+    const weekAgo = new Date();
+    weekAgo.setDate(weekAgo.getDate() - 7);
+    const weekCount = db.prepare('SELECT COUNT(*) as count FROM entries WHERE timestamp >= ?').get(weekAgo.toISOString());
+    // This month
+    const monthAgo = new Date();
+    monthAgo.setMonth(monthAgo.getMonth() - 1);
+    const monthCount = db.prepare('SELECT COUNT(*) as count FROM entries WHERE timestamp >= ?').get(monthAgo.toISOString());
+    // First and last entry
+    const first = db.prepare('SELECT timestamp FROM entries ORDER BY timestamp ASC LIMIT 1').get();
+    const last = db.prepare('SELECT timestamp FROM entries ORDER BY timestamp DESC LIMIT 1').get();
+    // Most active directories
+    const allDirs = db.prepare('SELECT directories FROM entries').all();
+    const dirCounts = {};
+    for (const row of allDirs) {
+        const dirs = JSON.parse(row.directories);
+        for (const dir of dirs) {
+            dirCounts[dir] = (dirCounts[dir] || 0) + 1;
+        }
+    }
+    const topDirs = Object.entries(dirCounts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5);
+    // Activity by day of week
+    const dayOfWeekCounts = db.prepare(`
+    SELECT
+      CASE CAST(strftime('%w', timestamp) AS INTEGER)
+        WHEN 0 THEN 'Sun'
+        WHEN 1 THEN 'Mon'
+        WHEN 2 THEN 'Tue'
+        WHEN 3 THEN 'Wed'
+        WHEN 4 THEN 'Thu'
+        WHEN 5 THEN 'Fri'
+        WHEN 6 THEN 'Sat'
+      END as day,
+      COUNT(*) as count
+    FROM entries
+    GROUP BY strftime('%w', timestamp)
+    ORDER BY CAST(strftime('%w', timestamp) AS INTEGER)
+  `).all();
+    // Activity by hour
+    const hourCounts = db.prepare(`
+    SELECT
+      CAST(strftime('%H', timestamp) AS INTEGER) as hour,
+      COUNT(*) as count
+    FROM entries
+    GROUP BY strftime('%H', timestamp)
+    ORDER BY hour
+  `).all();
+    // Average summary length
+    const avgLength = db.prepare('SELECT AVG(LENGTH(summary)) as avg FROM entries').get();
+    // Print stats
+    console.log(chalk.bold.green('\n📊 STAKEOUT STATISTICS\n'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log(chalk.bold('\nOverview'));
+    console.log(`  Total entries:     ${chalk.cyan(total.count)}`);
+    console.log(`  Today:             ${chalk.cyan(todayCount.count)}`);
+    console.log(`  This week:         ${chalk.cyan(weekCount.count)}`);
+    console.log(`  This month:        ${chalk.cyan(monthCount.count)}`);
+    if (first && last) {
+        console.log(`  First entry:       ${chalk.dim(new Date(first.timestamp).toLocaleDateString())}`);
+        console.log(`  Latest entry:      ${chalk.dim(new Date(last.timestamp).toLocaleDateString())}`);
+    }
+    console.log(`  Avg summary:       ${chalk.dim(Math.round(avgLength.avg || 0) + ' chars')}`);
+    if (topDirs.length > 0) {
+        console.log(chalk.bold('\nMost Active Directories'));
+        for (const [dir, count] of topDirs) {
+            const bar = '█'.repeat(Math.min(20, Math.round((count / topDirs[0][1]) * 20)));
+            console.log(`  ${chalk.yellow(dir.padEnd(20))} ${chalk.green(bar)} ${count}`);
+        }
+    }
+    if (dayOfWeekCounts.length > 0) {
+        console.log(chalk.bold('\nActivity by Day'));
+        const maxDayCount = Math.max(...dayOfWeekCounts.map(d => d.count));
+        for (const { day, count } of dayOfWeekCounts) {
+            const bar = '█'.repeat(Math.min(15, Math.round((count / maxDayCount) * 15)));
+            console.log(`  ${chalk.cyan(day)}  ${chalk.green(bar)} ${count}`);
+        }
+    }
+    if (hourCounts.length > 0) {
+        console.log(chalk.bold('\nPeak Hours'));
+        const sorted = [...hourCounts].sort((a, b) => b.count - a.count).slice(0, 5);
+        for (const { hour, count } of sorted) {
+            const time = `${hour.toString().padStart(2, '0')}:00`;
+            console.log(`  ${chalk.magenta(time)}  ${count} entries`);
+        }
+    }
+    console.log('');
+}

package/dist/commands/tag.d.ts

@@ -0,0 +1,8 @@
+interface TagOptions {
+    add?: string;
+    remove?: string;
+    list?: boolean;
+}
+export declare function tag(entryId: string, options: TagOptions): Promise<void>;
+export declare function listTags(): Promise<void>;
+export {};

package/dist/commands/tag.js

@@ -0,0 +1,61 @@
+import chalk from 'chalk';
+import { getEntry, updateEntry, getDb } from '../lib/database.js';
+export async function tag(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;
+    }
+    const currentTags = entry.tags || [];
+    if (options.list || (!options.add && !options.remove)) {
+        console.log(chalk.bold(`\nTags for entry #${id}:\n`));
+        if (currentTags.length === 0) {
+            console.log(chalk.dim('  No tags'));
+        }
+        else {
+            currentTags.forEach(t => console.log(chalk.cyan(`  • ${t}`)));
+        }
+        console.log('');
+        return;
+    }
+    if (options.add) {
+        const newTags = options.add.split(',').map(t => t.trim()).filter(t => t);
+        const updated = [...new Set([...currentTags, ...newTags])];
+        updateEntry(id, { tags: updated });
+        console.log(chalk.green(`✓ Added tags to entry #${id}: ${newTags.join(', ')}`));
+    }
+    if (options.remove) {
+        const toRemove = options.remove.split(',').map(t => t.trim().toLowerCase());
+        const updated = currentTags.filter(t => !toRemove.includes(t.toLowerCase()));
+        updateEntry(id, { tags: updated });
+        console.log(chalk.green(`✓ Removed tags from entry #${id}: ${options.remove}`));
+    }
+}
+export async function listTags() {
+    const db = getDb();
+    const rows = db.prepare('SELECT tags FROM entries WHERE tags != "[]"').all();
+    const tagCounts = {};
+    for (const row of rows) {
+        const tags = JSON.parse(row.tags);
+        for (const t of tags) {
+            tagCounts[t] = (tagCounts[t] || 0) + 1;
+        }
+    }
+    const sorted = Object.entries(tagCounts).sort((a, b) => b[1] - a[1]);
+    console.log(chalk.bold('\n📏 All Tags\n'));
+    if (sorted.length === 0) {
+        console.log(chalk.dim('No tags found.'));
+        console.log(chalk.dim('Add tags with: stakeout tag <id> --add "feature,bugfix"'));
+    }
+    else {
+        for (const [tag, count] of sorted) {
+            console.log(`  ${chalk.cyan(tag.padEnd(20))} ${chalk.dim(count + ' entries')}`);
+        }
+    }
+    console.log('');
+}

package/dist/commands/tui.d.ts

@@ -0,0 +1 @@
+export declare function tui(): Promise<void>;

package/dist/commands/tui.js

@@ -0,0 +1,5 @@
+import chalk from 'chalk';
+export async function tui() {
+    console.log(chalk.yellow('\nTUI mode not yet implemented.'));
+    console.log(chalk.dim('Use the web dashboard instead: stakeout dashboard\n'));
+}

package/dist/commands/watch.d.ts

@@ -0,0 +1,6 @@
+interface WatchOptions {
+    path?: string;
+    debounce?: string;
+}
+export declare function watch(options: WatchOptions): Promise<void>;
+export {};

package/dist/commands/watch.js

@@ -0,0 +1,101 @@
+import chalk from 'chalk';
+import { watch as fsWatch } from 'fs';
+import { simpleGit } from 'simple-git';
+import { loadConfig } from '../lib/config.js';
+import { collectDiff } from '../lib/diff.js';
+import { summarize } from '../lib/summarizer.js';
+import { insertEntry, entryExists } from '../lib/database.js';
+export async function watch(options) {
+    const config = loadConfig();
+    const watchPath = options.path || config.watched_path || process.cwd();
+    const debounceMs = options.debounce ? parseInt(options.debounce, 10) * 1000 : 30000; // Default 30s
+    const git = simpleGit(watchPath);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        console.error(chalk.red('Not a git repository: ' + watchPath));
+        process.exit(1);
+    }
+    console.log(chalk.green('🔍 STAKEOUT Watch Mode'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(chalk.dim(`Watching: ${watchPath}`));
+    console.log(chalk.dim(`Debounce: ${debounceMs / 1000}s`));
+    console.log(chalk.dim('Press Ctrl+C to stop'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log('');
+    let timeout = null;
+    let lastRecordTime = 0;
+    const shouldIgnore = (filename) => {
+        const ignorePatterns = [
+            /node_modules/,
+            /\.git/,
+            /dist\//,
+            /build\//,
+            /\.lock$/,
+            /\.log$/,
+            /\.tmp$/,
+            /\.swp$/,
+        ];
+        return ignorePatterns.some(p => p.test(filename));
+    };
+    const tryRecord = async () => {
+        const now = Date.now();
+        // Don't record more often than debounce interval
+        if (now - lastRecordTime < debounceMs) {
+            return;
+        }
+        console.log(chalk.dim(`[${new Date().toLocaleTimeString()}] Checking for changes...`));
+        try {
+            const diff = await collectDiff(watchPath);
+            if (!diff || diff.files.length === 0) {
+                console.log(chalk.dim('  No significant changes'));
+                return;
+            }
+            if (entryExists(diff.diff_hash)) {
+                console.log(chalk.dim('  Already recorded'));
+                return;
+            }
+            console.log(chalk.yellow(`  Found ${diff.files.length} changed files`));
+            console.log(chalk.dim('  Generating summary...'));
+            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
+            };
+            const id = insertEntry(entry);
+            lastRecordTime = now;
+            console.log(chalk.green(`  ✓ Recorded entry #${id}`));
+            console.log(chalk.cyan(`    ${summary.slice(0, 60)}${summary.length > 60 ? '...' : ''}`));
+            console.log('');
+        }
+        catch (err) {
+            console.error(chalk.red(`  Error: ${err.message}`));
+        }
+    };
+    const scheduleRecord = () => {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(tryRecord, 2000); // Wait 2s after last change
+    };
+    // Watch for changes
+    const watcher = fsWatch(watchPath, { recursive: true }, (eventType, filename) => {
+        if (!filename || shouldIgnore(filename)) {
+            return;
+        }
+        console.log(chalk.dim(`[${new Date().toLocaleTimeString()}] ${eventType}: ${filename}`));
+        scheduleRecord();
+    });
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+        console.log(chalk.dim('\nStopping watch...'));
+        watcher.close();
+        process.exit(0);
+    });
+    // Keep the process running
+    await new Promise(() => { });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { record } from './commands/record.js';
+import { log } from './commands/log.js';
+import { config } from './commands/config.js';
+import { dashboard } from './commands/dashboard.js';
+import { tui } from './commands/tui.js';
+import { hook } from './commands/hook.js';
+import { digest } from './commands/digest.js';
+import { watch } from './commands/watch.js';
+import { search } from './commands/search.js';
+import { exportCmd } from './commands/export.js';
+import { stats } from './commands/stats.js';
+import { clear } from './commands/clear.js';
+import { init } from './commands/init.js';
+import { chat } from './commands/chat.js';
+import { tag, listTags } from './commands/tag.js';
+import { note } from './commands/note.js';
+import { repo } from './commands/repo.js';
+import { closeDb } from './lib/database.js';
+const program = new Command();
+program
+    .name('stakeout')
+    .description('🔍 Surveillance ops for your codebase - AI-powered change tracking')
+    .version('0.1.0');
+program
+    .command('init')
+    .description('Initialize STAKEOUT for a repository')
+    .option('-p, --path <path>', 'Path to repository (default: current directory)')
+    .option('--no-hook', 'Skip installing git hook')
+    .action(async (options) => {
+    await init(options);
+    closeDb();
+});
+program
+    .command('record')
+    .description('Record and summarize current changes')
+    .option('-p, --path <path>', 'Path to git repository (default: current directory)')
+    .option('-c, --last-commit', 'Summarize the last commit instead of working changes')
+    .action(async (options) => {
+    await record({
+        path: options.path,
+        lastCommit: options.lastCommit
+    });
+    closeDb();
+});
+program
+    .command('log')
+    .description('View recorded change summaries')
+    .option('-n, --limit <number>', 'Number of entries to show (default: 10)')
+    .option('-s, --since <time>', 'Show entries since (e.g. "3 days", "1 week")')
+    .option('-p, --path <path>', 'Filter by file/directory path')
+    .option('-f, --favorites', 'Show only favorites')
+    .option('-t, --tag <tag>', 'Filter by tag')
+    .action(async (options) => {
+    await log(options);
+    closeDb();
+});
+program
+    .command('search <query>')
+    .description('Search through recorded summaries')
+    .option('-n, --limit <number>', 'Max results to show (default: 20)')
+    .action(async (query, options) => {
+    await search(query, options);
+    closeDb();
+});
+program
+    .command('chat')
+    .description('AI chat - ask questions about your codebase history')
+    .option('--clear', 'Clear chat history')
+    .action(async (options) => {
+    await chat(options);
+    closeDb();
+});
+program
+    .command('stats')
+    .description('Show detailed statistics and analytics')
+    .action(async () => {
+    await stats();
+    closeDb();
+});
+program
+    .command('digest')
+    .description('Generate a high-level digest of recent activity')
+    .option('-s, --since <time>', 'Time period (e.g. "1 week", "2 weeks", "1 month")')
+    .option('-p, --path <path>', 'Filter by file/directory path')
+    .action(async (options) => {
+    await digest(options);
+    closeDb();
+});
+program
+    .command('tag <id>')
+    .description('Manage tags for an entry')
+    .option('-a, --add <tags>', 'Add tags (comma-separated)')
+    .option('-r, --remove <tags>', 'Remove tags (comma-separated)')
+    .option('-l, --list', 'List tags on entry')
+    .action(async (id, options) => {
+    await tag(id, options);
+    closeDb();
+});
+program
+    .command('tags')
+    .description('List all tags')
+    .action(async () => {
+    await listTags();
+    closeDb();
+});
+program
+    .command('note <id>')
+    .description('Add notes or mark entries')
+    .option('-n, --note <text>', 'Set note text')
+    .option('-f, --favorite', 'Mark as favorite')
+    .option('-u, --unfavorite', 'Remove favorite')
+    .option('-b, --breaking', 'Mark as breaking change')
+    .option('--not-breaking', 'Unmark as breaking change')
+    .action(async (id, options) => {
+    await note(id, options);
+    closeDb();
+});
+program
+    .command('repo')
+    .description('Manage tracked repositories')
+    .option('-a, --add <path>', 'Add a repository')
+    .option('-r, --remove <name>', 'Remove a repository')
+    .option('-l, --list', 'List repositories')
+    .action(async (options) => {
+    await repo(options);
+    closeDb();
+});
+program
+    .command('export')
+    .description('Export entries to file')
+    .option('-f, --format <format>', 'Format: markdown, json, csv (default: markdown)')
+    .option('-s, --since <time>', 'Export entries since (e.g. "1 month")')
+    .option('-p, --path <path>', 'Filter by file/directory path')
+    .option('-o, --output <file>', 'Output filename')
+    .action(async (options) => {
+    await exportCmd(options);
+    closeDb();
+});
+program
+    .command('clear')
+    .description('Delete old entries')
+    .option('--before <time>', 'Delete entries before (e.g. "30 days", "2024-01-01")')
+    .option('--all', 'Delete ALL entries')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (options) => {
+    await clear(options);
+    closeDb();
+});
+program
+    .command('config')
+    .description('View or update configuration')
+    .option('--show', 'Show current configuration')
+    .option('--provider <provider>', 'Set LLM provider (ollama or openai)')
+    .option('--ollama-model <model>', 'Set Ollama model (e.g. llama3, mistral, codellama)')
+    .option('--ollama-host <url>', 'Set Ollama host URL')
+    .option('--openai-key <key>', 'Set OpenAI API key')
+    .option('--openai-model <model>', 'Set OpenAI model (e.g. gpt-4o-mini, gpt-4o)')
+    .action(async (options) => {
+    await config(options);
+});
+program
+    .command('dashboard')
+    .alias('dash')
+    .description('Open the STAKEOUT Command Center (web UI)')
+    .option('-p, --port <port>', 'Port to run on (default: 3333)')
+    .action(async (options) => {
+    await dashboard(options);
+});
+program
+    .command('ui')
+    .alias('tui')
+    .description('Open the terminal UI (TUI mode)')
+    .action(async () => {
+    await tui();
+    closeDb();
+});
+program
+    .command('hook')
+    .description('Install/remove git post-commit hook for auto-recording')
+    .option('-p, --path <path>', 'Path to git repository (default: current directory)')
+    .option('-r, --remove', 'Remove the hook instead of installing')
+    .action(async (options) => {
+    await hook(options);
+});
+program
+    .command('watch')
+    .description('Watch for changes and record automatically')
+    .option('-p, --path <path>', 'Path to watch (default: current directory)')
+    .option('-d, --debounce <seconds>', 'Minimum seconds between recordings (default: 30)')
+    .action(async (options) => {
+    await watch(options);
+});
+program.parse();

package/dist/lib/config.d.ts

@@ -0,0 +1,5 @@
+import type { StakeoutConfig } from '../types/index.js';
+export declare function ensureConfigDir(): void;
+export declare function loadConfig(): StakeoutConfig;
+export declare function saveConfig(config: StakeoutConfig): void;
+export declare function getConfigPath(): string;