liferewind 0.1.0

package/dist/cli/commands/doctor.js

@@ -0,0 +1,150 @@
+import { Command } from 'commander';
+import { execSync } from 'node:child_process';
+import pc from 'picocolors';
+import { findConfigPath, loadConfig } from '../../config/loader.js';
+import { detectInstalledBrowsers, detectGitInstalled, detectChatbotClients } from '../detect/index.js';
+import { printSuccess, printError, printInfo } from '../utils/output.js';
+function checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0] ?? '0', 10);
+    if (major >= 20) {
+        return { ok: true, message: `Node.js ${version}` };
+    }
+    return {
+        ok: false,
+        message: `Node.js ${version} (requires >= 20)`,
+        suggestion: 'Upgrade to Node.js 20 or later',
+    };
+}
+function checkConfigExists(customPath) {
+    const configPath = findConfigPath(customPath);
+    if (configPath) {
+        return { ok: true, message: `Found at ${configPath}` };
+    }
+    return {
+        ok: false,
+        message: 'No config file found',
+        suggestion: "Run 'liferewind init' to create one",
+    };
+}
+async function checkApiConnection(customPath) {
+    try {
+        const config = loadConfig(customPath);
+        const healthUrl = new URL('/api/health', config.api.baseUrl).toString();
+        const response = await fetch(healthUrl, {
+            method: 'GET',
+            signal: AbortSignal.timeout(5000),
+        });
+        if (response.ok) {
+            return { ok: true, message: `API reachable at ${config.api.baseUrl}` };
+        }
+        return {
+            ok: false,
+            message: `API returned ${response.status}`,
+            suggestion: 'Check if the web server is running',
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('No configuration')) {
+            return { ok: false, message: 'Cannot check - no config', suggestion: "Run 'liferewind init' first" };
+        }
+        // Special handling for timeout errors
+        if (error instanceof Error && (error.name === 'TimeoutError' || error.message.includes('timeout'))) {
+            return {
+                ok: false,
+                message: 'Connection timeout (5s)',
+                suggestion: 'Check if the web server is running and accessible',
+            };
+        }
+        return {
+            ok: false,
+            message: `Cannot reach API: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            suggestion: 'Check if the web server is running and accessible',
+        };
+    }
+}
+function checkGitCommand() {
+    if (detectGitInstalled()) {
+        try {
+            const version = execSync('git --version', { encoding: 'utf-8' }).trim();
+            return { ok: true, message: version };
+        }
+        catch {
+            return { ok: true, message: 'Git installed' };
+        }
+    }
+    return {
+        ok: false,
+        message: 'Git not found',
+        suggestion: 'Install Git if you want to collect git commits',
+    };
+}
+function checkBrowserAccess() {
+    const browsers = detectInstalledBrowsers();
+    if (browsers.length > 0) {
+        return { ok: true, message: `Detected: ${browsers.join(', ')}` };
+    }
+    return {
+        ok: false,
+        message: 'No supported browsers found',
+        suggestion: 'Install Chrome, Safari, or Arc for browser history collection',
+    };
+}
+function checkChatbotAccess() {
+    const clients = detectChatbotClients();
+    if (clients.length > 0) {
+        return { ok: true, message: `Detected: ${clients.join(', ')}` };
+    }
+    return {
+        ok: false,
+        message: 'No chatbot clients found',
+        suggestion: 'Install ChatWise for chatbot history collection',
+    };
+}
+export const doctorCommand = new Command('doctor')
+    .description('Diagnose environment and configuration issues')
+    .action(async (_options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const customPath = globalOpts.config;
+    console.log('Running diagnostics...\n');
+    // Synchronous checks
+    const syncChecks = [
+        { name: 'Node.js version', result: checkNodeVersion() },
+        { name: 'Configuration file', result: checkConfigExists(customPath) },
+        { name: 'Git availability', result: checkGitCommand() },
+        { name: 'Browser databases', result: checkBrowserAccess() },
+        { name: 'Chatbot clients', result: checkChatbotAccess() },
+    ];
+    let hasIssues = false;
+    for (const { name, result } of syncChecks) {
+        if (result.ok) {
+            printSuccess(`${name}: ${result.message}`);
+        }
+        else {
+            printError(`${name}: ${result.message}`);
+            if (result.suggestion) {
+                console.log(`  ${pc.dim('Suggestion:')} ${result.suggestion}`);
+            }
+            hasIssues = true;
+        }
+    }
+    // Async check for API
+    const apiResult = await checkApiConnection(customPath);
+    if (apiResult.ok) {
+        printSuccess(`API connectivity: ${apiResult.message}`);
+    }
+    else {
+        printError(`API connectivity: ${apiResult.message}`);
+        if (apiResult.suggestion) {
+            console.log(`  ${pc.dim('Suggestion:')} ${apiResult.suggestion}`);
+        }
+        hasIssues = true;
+    }
+    console.log();
+    if (hasIssues) {
+        printInfo('Some issues were found. Address them for full functionality.');
+    }
+    else {
+        printSuccess('All checks passed! The collector is ready to run.');
+    }
+});

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const initCommand: Command;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoBpC,eAAO,MAAM,WAAW,SAwPpB,CAAC"}

package/dist/cli/commands/init.js

@@ -0,0 +1,244 @@
+import { Command } from 'commander';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { input, confirm, select, checkbox, password } from '@inquirer/prompts';
+import { detectInstalledBrowsers, detectGitInstalled, detectChatbotClients } from '../detect/index.js';
+import { writeConfig } from '../../config/writer.js';
+import { getUserConfigPath } from '../../config/paths.js';
+import { printBanner, printSection, printSuccess, printInfo, printDim, printWarning } from '../utils/output.js';
+import { expandPath, parsePaths } from '../utils/path.js';
+function warnMissingPaths(paths) {
+    for (const p of paths) {
+        const expanded = expandPath(p);
+        if (!existsSync(expanded)) {
+            printWarning(`Path does not exist: ${p}`);
+        }
+    }
+}
+export const initCommand = new Command('init')
+    .description('Initialize configuration with interactive wizard')
+    .option('--force', 'overwrite existing configuration')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const configPath = globalOpts.config || getUserConfigPath();
+    // Check if config already exists
+    if (existsSync(configPath) && !options.force) {
+        printInfo(`Configuration already exists at ${configPath}`);
+        const overwrite = await confirm({
+            message: 'Overwrite existing configuration?',
+            default: false,
+        });
+        if (!overwrite) {
+            printInfo('Aborted.');
+            return;
+        }
+    }
+    printBanner();
+    const config = {
+        api: { baseUrl: '', apiKey: '', timeout: 30000, retryAttempts: 3 },
+        sources: {
+            git: { enabled: false, schedule: 'daily', options: { scanPaths: [], sinceDays: 30 } },
+            browser: { enabled: false, schedule: 'daily', options: { browsers: [], excludeDomains: [], sinceDays: 7 } },
+            filesystem: {
+                enabled: false,
+                schedule: 'daily',
+                options: {
+                    watchPaths: [],
+                    excludePatterns: ['**/node_modules/**', '**/.git/**', '**/Library/**'],
+                    sinceDays: 7,
+                    includeContent: true,
+                },
+            },
+            chatbot: { enabled: false, schedule: 'daily', options: { clients: [], sinceDays: 30, includeContent: true } },
+        },
+        logging: { level: 'info' },
+    };
+    // Step 1: API Configuration
+    printSection('Step 1/5: API Configuration');
+    config.api.baseUrl = await input({
+        message: 'API Base URL:',
+        default: 'http://localhost:3000',
+        validate: (value) => {
+            try {
+                new URL(value);
+                return true;
+            }
+            catch {
+                return 'Please enter a valid URL';
+            }
+        },
+    });
+    config.api.apiKey = await password({
+        message: 'API Key:',
+        validate: (value) => (value.length > 0 ? true : 'API Key is required'),
+    });
+    // Step 2: Browser History
+    printSection('Step 2/5: Browser History');
+    const detectedBrowsers = detectInstalledBrowsers();
+    if (detectedBrowsers.length > 0) {
+        printDim(`  Detected: ${detectedBrowsers.join(', ')}`);
+    }
+    else {
+        printDim('  No supported browsers detected');
+    }
+    const enableBrowser = await confirm({
+        message: 'Enable browser history collection?',
+        default: true,
+    });
+    if (enableBrowser) {
+        const selectedBrowsers = await checkbox({
+            message: 'Select browsers to collect:',
+            choices: [
+                { name: 'Chrome', value: 'chrome', checked: detectedBrowsers.includes('chrome') },
+                { name: 'Safari', value: 'safari', checked: detectedBrowsers.includes('safari') },
+                { name: 'Arc', value: 'arc', checked: detectedBrowsers.includes('arc') },
+                { name: 'Dia', value: 'dia', checked: detectedBrowsers.includes('dia') },
+                { name: 'Comet', value: 'comet', checked: detectedBrowsers.includes('comet') },
+            ],
+        });
+        // If no browsers selected, disable the source
+        if (selectedBrowsers.length === 0) {
+            printWarning('No browsers selected, browser collection will be disabled.');
+        }
+        else {
+            const browserSchedule = await select({
+                message: 'Collection schedule:',
+                choices: [
+                    { name: 'Hourly', value: 'hourly' },
+                    { name: 'Daily (recommended)', value: 'daily' },
+                    { name: 'Weekly', value: 'weekly' },
+                    { name: 'Manual only', value: 'manual' },
+                ],
+                default: 'daily',
+            });
+            config.sources.browser = {
+                enabled: true,
+                schedule: browserSchedule,
+                options: {
+                    browsers: selectedBrowsers,
+                    excludeDomains: ['localhost', '127.0.0.1'],
+                    sinceDays: 7,
+                },
+            };
+        }
+    }
+    // Step 3: Git Commits
+    printSection('Step 3/5: Git Commits');
+    const gitInstalled = detectGitInstalled();
+    printDim(gitInstalled ? '  Git is installed' : '  Git not found');
+    const enableGit = await confirm({
+        message: 'Enable git commit collection?',
+        default: true,
+    });
+    if (enableGit) {
+        const defaultPaths = [`${homedir()}/Projects`, `${homedir()}/Documents`].filter(existsSync);
+        const scanPathsInput = await input({
+            message: 'Paths to scan for git repositories (comma-separated):',
+            default: defaultPaths.join(',') || `${homedir()}/Projects`,
+        });
+        const scanPaths = parsePaths(scanPathsInput);
+        if (scanPaths.length === 0) {
+            printWarning('No paths specified, git collection will be disabled.');
+        }
+        else {
+            warnMissingPaths(scanPaths);
+            const gitSchedule = await select({
+                message: 'Collection schedule:',
+                choices: [
+                    { name: 'Hourly', value: 'hourly' },
+                    { name: 'Daily (recommended)', value: 'daily' },
+                    { name: 'Weekly', value: 'weekly' },
+                    { name: 'Manual only', value: 'manual' },
+                ],
+                default: 'daily',
+            });
+            config.sources.git = {
+                enabled: true,
+                schedule: gitSchedule,
+                options: {
+                    scanPaths,
+                    sinceDays: 30,
+                },
+            };
+        }
+    }
+    // Step 4: Filesystem (Optional)
+    printSection('Step 4/5: Filesystem Changes');
+    const enableFilesystem = await confirm({
+        message: 'Enable filesystem monitoring?',
+        default: true,
+    });
+    if (enableFilesystem) {
+        const watchPathsInput = await input({
+            message: 'Paths to monitor (comma-separated):',
+            default: `${homedir()}/Documents,${homedir()}/Desktop`,
+        });
+        const watchPaths = parsePaths(watchPathsInput);
+        if (watchPaths.length === 0) {
+            printWarning('No paths specified, filesystem monitoring will be disabled.');
+        }
+        else {
+            warnMissingPaths(watchPaths);
+            config.sources.filesystem = {
+                enabled: true,
+                schedule: 'daily',
+                options: {
+                    watchPaths,
+                    excludePatterns: ['**/node_modules/**', '**/.git/**', '**/Library/**'],
+                    sinceDays: 7,
+                    includeContent: true,
+                },
+            };
+        }
+    }
+    // Step 5: Chatbot (Optional)
+    printSection('Step 5/5: Chatbot History');
+    const detectedChatbots = detectChatbotClients();
+    if (detectedChatbots.length > 0) {
+        printDim(`  Detected: ${detectedChatbots.join(', ')}`);
+    }
+    else {
+        printDim('  No supported chatbot clients detected');
+    }
+    const enableChatbot = await confirm({
+        message: 'Enable chatbot history collection?',
+        default: true,
+    });
+    if (enableChatbot) {
+        config.sources.chatbot = {
+            enabled: true,
+            schedule: 'daily',
+            options: {
+                clients: detectedChatbots.length > 0 ? detectedChatbots : ['chatwise'],
+                sinceDays: 30,
+                includeContent: true,
+            },
+        };
+    }
+    // Summary
+    printSection('Configuration Summary');
+    console.log(`  API: ${config.api.baseUrl}`);
+    console.log('  Sources enabled:');
+    console.log(`    ${config.sources.browser.enabled ? '✓' : '✗'} Browser`);
+    console.log(`    ${config.sources.git.enabled ? '✓' : '✗'} Git`);
+    console.log(`    ${config.sources.filesystem.enabled ? '✓' : '✗'} Filesystem`);
+    console.log(`    ${config.sources.chatbot.enabled ? '✓' : '✗'} Chatbot`);
+    // Save
+    const shouldSave = await confirm({
+        message: `Save configuration to ${configPath}?`,
+        default: true,
+    });
+    if (shouldSave) {
+        writeConfig(config, configPath);
+        printSuccess('Configuration saved!');
+        console.log(`
+  Next steps:
+    Run 'liferewind start' to begin collecting data
+    Run 'liferewind collect' for immediate collection
+    Run 'liferewind config edit' to modify settings
+`);
+    }
+    else {
+        printInfo('Configuration not saved.');
+    }
+});

package/dist/cli/commands/start.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const startCommand: Command;
+//# sourceMappingURL=start.d.ts.map

package/dist/cli/commands/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/start.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,eAAO,MAAM,YAAY,SA8DrB,CAAC"}

package/dist/cli/commands/start.js

@@ -0,0 +1,59 @@
+import { Command } from 'commander';
+import { Collector } from '../../core/collector.js';
+import { loadConfig } from '../../config/loader.js';
+import { createLogger } from '../../utils/logger.js';
+import { registerBuiltinSources } from '../../sources/index.js';
+import { printError, printInfo, printSuccess } from '../utils/output.js';
+export const startCommand = new Command('start')
+    .description('Start the collector service')
+    .option('--run-once', 'collect once and exit')
+    .option('--run-on-start', 'run collection immediately on start')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    try {
+        const config = loadConfig(globalOpts.config);
+        // Apply global log level overrides
+        let logLevel = config.logging.level;
+        if (globalOpts.verbose)
+            logLevel = 'debug';
+        if (globalOpts.quiet)
+            logLevel = 'error';
+        const logger = createLogger({ level: logLevel });
+        registerBuiltinSources();
+        const collector = new Collector(config, logger);
+        await collector.validateSources();
+        const enabledSources = collector.getEnabledSources();
+        if (enabledSources.length === 0) {
+            printError('No data sources enabled or validated.');
+            process.exit(1);
+        }
+        printInfo(`Enabled sources: ${enabledSources.join(', ')}`);
+        if (options.runOnce) {
+            printInfo('Running one-time collection...');
+            await collector.collectAll();
+            printSuccess('Collection complete.');
+            return;
+        }
+        // Setup graceful shutdown
+        const shutdown = async (signal) => {
+            printInfo(`Received ${signal}, shutting down...`);
+            await collector.stop();
+            process.exit(0);
+        };
+        process.on('SIGTERM', () => {
+            shutdown('SIGTERM').catch(console.error);
+        });
+        process.on('SIGINT', () => {
+            shutdown('SIGINT').catch(console.error);
+        });
+        await collector.start();
+        if (options.runOnStart) {
+            await collector.collectAll();
+        }
+        printSuccess('Collector started. Press Ctrl+C to stop.');
+    }
+    catch (error) {
+        printError(`Failed to start: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});

package/dist/cli/commands/status.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const statusCommand: Command;
+//# sourceMappingURL=status.d.ts.map

package/dist/cli/commands/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,eAAO,MAAM,aAAa,SAmDtB,CAAC"}

package/dist/cli/commands/status.js

@@ -0,0 +1,49 @@
+import { Command } from 'commander';
+import { loadConfig, findConfigPath } from '../../config/loader.js';
+import { printInfo, printSuccess, printError, printDim } from '../utils/output.js';
+export const statusCommand = new Command('status')
+    .description('Show collector status')
+    .option('--json', 'output as JSON')
+    .action((options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    try {
+        const configPath = findConfigPath(globalOpts.config);
+        if (!configPath) {
+            printError('No configuration found.');
+            printInfo("Run 'liferewind init' to create one.");
+            process.exit(1);
+        }
+        const config = loadConfig(globalOpts.config);
+        const enabledSources = Object.entries(config.sources)
+            .filter(([, cfg]) => cfg.enabled)
+            .map(([name, cfg]) => ({ name, schedule: cfg.schedule }));
+        const status = {
+            configPath,
+            apiUrl: config.api.baseUrl,
+            logLevel: config.logging.level,
+            sources: enabledSources,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        printSuccess('Configuration loaded');
+        printDim(`  Config: ${configPath}`);
+        printDim(`  API: ${config.api.baseUrl}`);
+        printDim(`  Log level: ${config.logging.level}`);
+        console.log();
+        if (enabledSources.length === 0) {
+            printInfo('No data sources enabled.');
+        }
+        else {
+            printInfo(`Enabled sources (${enabledSources.length}):`);
+            for (const src of enabledSources) {
+                console.log(`    - ${src.name} (${src.schedule})`);
+            }
+        }
+    }
+    catch (error) {
+        printError(`Failed to load status: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});

package/dist/cli/detect/browsers.d.ts

@@ -0,0 +1,3 @@
+export type BrowserType = 'chrome' | 'safari' | 'arc' | 'dia' | 'comet';
+export declare function detectInstalledBrowsers(): BrowserType[];
+//# sourceMappingURL=browsers.d.ts.map

package/dist/cli/detect/browsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browsers.d.ts","sourceRoot":"","sources":["../../../src/cli/detect/browsers.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,CAAC;AAUxE,wBAAgB,uBAAuB,IAAI,WAAW,EAAE,CAUvD"}

package/dist/cli/detect/browsers.js

@@ -0,0 +1,19 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const BROWSER_PATHS = {
+    chrome: join(homedir(), 'Library/Application Support/Google/Chrome'),
+    arc: join(homedir(), 'Library/Application Support/Arc/User Data'),
+    safari: join(homedir(), 'Library/Safari'),
+    dia: join(homedir(), 'Library/Application Support/Dia/User Data'),
+    comet: join(homedir(), 'Library/Application Support/Comet'),
+};
+export function detectInstalledBrowsers() {
+    const detected = [];
+    for (const [browser, path] of Object.entries(BROWSER_PATHS)) {
+        if (existsSync(path)) {
+            detected.push(browser);
+        }
+    }
+    return detected;
+}

package/dist/cli/detect/chatbot.d.ts

@@ -0,0 +1,3 @@
+export type ChatbotClient = 'chatwise';
+export declare function detectChatbotClients(): ChatbotClient[];
+//# sourceMappingURL=chatbot.d.ts.map

package/dist/cli/detect/chatbot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatbot.d.ts","sourceRoot":"","sources":["../../../src/cli/detect/chatbot.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAMvC,wBAAgB,oBAAoB,IAAI,aAAa,EAAE,CAUtD"}

package/dist/cli/detect/chatbot.js

@@ -0,0 +1,15 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CHATBOT_PATHS = {
+    chatwise: join(homedir(), 'Library', 'Application Support', 'app.chatwise', 'app.db'),
+};
+export function detectChatbotClients() {
+    const detected = [];
+    for (const [client, path] of Object.entries(CHATBOT_PATHS)) {
+        if (existsSync(path)) {
+            detected.push(client);
+        }
+    }
+    return detected;
+}

package/dist/cli/detect/git.d.ts

@@ -0,0 +1,2 @@
+export declare function detectGitInstalled(): boolean;
+//# sourceMappingURL=git.d.ts.map

package/dist/cli/detect/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../src/cli/detect/git.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,IAAI,OAAO,CAO5C"}

package/dist/cli/detect/git.js

@@ -0,0 +1,10 @@
+import { execSync } from 'node:child_process';
+export function detectGitInstalled() {
+    try {
+        execSync('git --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/detect/index.d.ts

@@ -0,0 +1,4 @@
+export { detectInstalledBrowsers, type BrowserType } from './browsers.js';
+export { detectGitInstalled } from './git.js';
+export { detectChatbotClients, type ChatbotClient } from './chatbot.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/detect/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/detect/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/cli/detect/index.js

@@ -0,0 +1,3 @@
+export { detectInstalledBrowsers } from './browsers.js';
+export { detectGitInstalled } from './git.js';
+export { detectChatbotClients } from './chatbot.js';

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { startCommand } from './commands/start.js';
+import { collectCommand } from './commands/collect.js';
+import { configCommand } from './commands/config.js';
+import { statusCommand } from './commands/status.js';
+import { doctorCommand } from './commands/doctor.js';
+// Read version from package.json
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packagePath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+const program = new Command();
+program
+    .name('liferewind')
+    .description('LifeRewind data collector - capture your digital footprint')
+    .version(packageJson.version)
+    .option('-c, --config <path>', 'path to config file')
+    .option('--verbose', 'enable verbose output')
+    .option('--quiet', 'suppress non-essential output');
+program.addCommand(initCommand);
+program.addCommand(startCommand);
+program.addCommand(collectCommand);
+program.addCommand(configCommand);
+program.addCommand(statusCommand);
+program.addCommand(doctorCommand);
+program.parse();

package/dist/cli/utils/output.d.ts

@@ -0,0 +1,8 @@
+export declare function printBanner(): void;
+export declare function printSection(title: string): void;
+export declare function printSuccess(message: string): void;
+export declare function printError(message: string): void;
+export declare function printInfo(message: string): void;
+export declare function printWarning(message: string): void;
+export declare function printDim(message: string): void;
+//# sourceMappingURL=output.d.ts.map