profclaw 2.0.0 → 2.3.0

package/dist/cli/commands/doctor.js

@@ -1,24 +1,33 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import * as os from 'os';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { api } from '../utils/api.js';
 import { success, error, info, spinner } from '../utils/output.js';
+import { isServerRunning } from '../../utils/pid-file.js';
 const execFileAsync = promisify(execFile);
 async function checkNode() {
     const version = process.version;
     const major = parseInt(version.slice(1).split('.')[0], 10);
-    if (major >= 22) {
-        return { name: 'Node.js', status: 'pass', message: `${version}` };
+    if (major >= 20) {
+        return { name: 'Node.js', status: 'pass', message: `${version} (>= 18 required)` };
+    }
+    if (major >= 18) {
+        return {
+            name: 'Node.js',
+            status: 'warn',
+            message: `${version} (>= 20 recommended for best performance)`,
+            fix: 'nvm install 20',
+        };
     }
     return {
         name: 'Node.js',
         status: 'fail',
-        message: `${version} (requires >= 22)`,
-        fix: 'nvm install 22',
+        message: `${version} (requires >= 18)`,
+        fix: 'nvm install 20',
     };
 }
 async function checkRedis() {
@@ -203,6 +212,173 @@ async function checkDiskSpace() {
         return { name: 'Disk', status: 'warn', message: 'Could not check disk space' };
     }
 }
+async function checkDatabaseIntegrity() {
+    const result = await api.get('/api/setup/db-integrity');
+    if (!result.ok) {
+        // Try a direct PRAGMA if server is unavailable
+        try {
+            const { existsSync: fsExists } = await import('node:fs');
+            const dbPath = join(process.cwd(), '.profclaw', 'profclaw.db');
+            if (!fsExists(dbPath)) {
+                return { name: 'DB Integrity', status: 'warn', message: 'Database file not found (server may not have run yet)' };
+            }
+            // Dynamically attempt SQLite integrity check (optional dep)
+            const betterSqlite3 = 'better-sqlite3';
+            const { default: Database } = await import(/* @vite-ignore */ betterSqlite3);
+            const db = new Database(dbPath, { readonly: true });
+            const row = db.prepare('PRAGMA integrity_check').get();
+            db.close();
+            const integrity = row?.integrity_check ?? 'unknown';
+            if (integrity === 'ok') {
+                return { name: 'DB Integrity', status: 'pass', message: 'ok' };
+            }
+            return { name: 'DB Integrity', status: 'fail', message: integrity, fix: 'Backup and recreate the database' };
+        }
+        catch {
+            return { name: 'DB Integrity', status: 'warn', message: 'Cannot check (server not running, SQLite unavailable)' };
+        }
+    }
+    const integrity = result.data?.integrity ?? 'ok';
+    if (integrity === 'ok') {
+        return { name: 'DB Integrity', status: 'pass', message: 'ok' };
+    }
+    return { name: 'DB Integrity', status: 'fail', message: integrity, fix: 'Backup and recreate the database' };
+}
+async function checkApiKeyValidation() {
+    const result = await api.get('/api/chat/providers');
+    if (!result.ok) {
+        return [{ name: 'API Keys', status: 'warn', message: 'Cannot check (server not running)', fix: 'profclaw serve' }];
+    }
+    const configured = result.data?.providers?.filter((p) => p.enabled) ?? [];
+    if (configured.length === 0) {
+        return [{ name: 'API Keys', status: 'fail', message: 'No AI providers configured', fix: 'profclaw provider add anthropic' }];
+    }
+    return configured.map((p) => {
+        const label = p.type.charAt(0).toUpperCase() + p.type.slice(1);
+        if (p.healthy) {
+            return { name: label, status: 'pass', message: 'configured' };
+        }
+        return { name: label, status: 'warn', message: `configured but unreachable${p.message ? ` (${p.message})` : ''}` };
+    });
+}
+async function checkPortAvailability() {
+    const port = parseInt(process.env.PORT || '3000', 10);
+    const net = await import('net');
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve({ name: 'Port availability', status: 'pass', message: `Port ${port} in use (server likely running)` });
+            }
+            else {
+                resolve({ name: 'Port availability', status: 'warn', message: `Port ${port}: ${err.message}` });
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve({ name: 'Port availability', status: 'pass', message: `Port ${port} available` });
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+async function checkMissingDependencies() {
+    const required = ['ink', 'react', 'chalk', 'commander'];
+    const missing = [];
+    for (const dep of required) {
+        try {
+            await import(dep);
+        }
+        catch {
+            missing.push(dep);
+        }
+    }
+    if (missing.length === 0) {
+        return { name: 'Dependencies', status: 'pass', message: `${required.length} required packages present` };
+    }
+    return {
+        name: 'Dependencies',
+        status: 'fail',
+        message: `Missing: ${missing.join(', ')}`,
+        fix: `npm install ${missing.join(' ')}`,
+    };
+}
+async function checkConfigFileValidity() {
+    const cwd = process.cwd();
+    const errors = [];
+    const configJsonPath = join(cwd, '.profclaw', 'config.json');
+    if (existsSync(configJsonPath)) {
+        try {
+            JSON.parse(readFileSync(configJsonPath, 'utf-8'));
+        }
+        catch {
+            errors.push('config.json: invalid JSON');
+        }
+    }
+    // settings.yml validation — check it parses as basic YAML (key: value lines, no tabs)
+    const settingsYmlPath = join(cwd, 'config', 'settings.yml');
+    if (existsSync(settingsYmlPath)) {
+        try {
+            const content = readFileSync(settingsYmlPath, 'utf-8');
+            if (content.includes('\t')) {
+                errors.push('settings.yml: contains tab characters (YAML requires spaces)');
+            }
+        }
+        catch {
+            errors.push('settings.yml: unreadable');
+        }
+    }
+    if (errors.length > 0) {
+        return {
+            name: 'Config files',
+            status: 'fail',
+            message: errors.join('; '),
+            fix: 'Fix the reported config files',
+        };
+    }
+    return { name: 'Config files', status: 'pass', message: 'valid' };
+}
+async function checkPidFileStatus() {
+    const status = isServerRunning();
+    if (status.running) {
+        return {
+            name: 'PID file',
+            status: 'pass',
+            message: `Server running (PID ${status.pid}, port ${status.port})`,
+        };
+    }
+    // Check if a stale PID file was present (isServerRunning cleans it up automatically)
+    return { name: 'PID file', status: 'pass', message: 'No server process found' };
+}
+async function checkDiskSpaceBytes() {
+    // macOS / Linux: use `df -k` to get kibibyte blocks for a numeric threshold check
+    try {
+        const { stdout } = await execFileAsync('df', ['-k', process.cwd()], { timeout: 5000 });
+        const lines = stdout.trim().split('\n');
+        if (lines.length >= 2) {
+            const parts = lines[1].split(/\s+/);
+            const availKB = parseInt(parts[3] || '0', 10);
+            const availMB = availKB / 1024;
+            const availGB = (availKB / 1024 / 1024).toFixed(1);
+            const usePct = parseInt(parts[4] || '0', 10);
+            if (availMB < 500) {
+                return {
+                    name: 'Disk space',
+                    status: 'warn',
+                    message: `${availGB} GB free (< 500 MB threshold)`,
+                    fix: 'Free up disk space',
+                };
+            }
+            if (usePct > 95) {
+                return { name: 'Disk space', status: 'fail', message: `${availGB} GB free (${usePct}% used)`, fix: 'Free up disk space' };
+            }
+            return { name: 'Disk space', status: 'pass', message: `${availGB} GB free` };
+        }
+        return { name: 'Disk space', status: 'pass', message: 'Readable' };
+    }
+    catch {
+        return { name: 'Disk space', status: 'warn', message: 'Could not check disk space' };
+    }
+}
 async function checkTailscale() {
     const result = await api.get('/api/tunnels/status');
     if (!result.ok) {
@@ -235,28 +411,36 @@ export function doctorCommand() {
         .option('--json', 'Output as JSON')
         .action(async (options) => {
         console.log(chalk.bold('\nprofClaw Doctor\n'));
-        const checks = [
+        // Static (single-result) checks
+        const singleChecks = [
             { name: 'Node.js', fn: checkNode },
+            { name: 'Disk space', fn: checkDiskSpaceBytes },
+            { name: 'Port availability', fn: checkPortAvailability },
+            { name: 'DB Integrity', fn: checkDatabaseIntegrity },
+            { name: 'Ollama', fn: checkOllama },
+            { name: 'Redis', fn: checkRedis },
+            { name: 'Config files', fn: checkConfigFileValidity },
+            { name: 'Dependencies', fn: checkMissingDependencies },
+            { name: 'PID file', fn: checkPidFileStatus },
             { name: 'Config', fn: checkConfigFiles },
             { name: 'Port', fn: checkPort },
-            { name: 'Redis', fn: checkRedis },
-            { name: 'Ollama', fn: checkOllama },
             { name: 'Server', fn: checkServer },
             { name: 'Database', fn: checkDatabase },
-            { name: 'AI Provider', fn: checkProvider },
             { name: 'Memory', fn: checkMemory },
             { name: 'Disk', fn: checkDiskSpace },
             { name: 'Cloudflared', fn: checkCloudflared },
             { name: 'Tailscale', fn: checkTailscale },
         ];
         const results = [];
-        for (const check of checks) {
+        // Run single-result checks
+        for (const check of singleChecks) {
             const spin = spinner(`Checking ${check.name}...`).start();
             try {
                 const result = await check.fn();
                 results.push(result);
                 spin.stop();
-                formatCheck(result);
+                if (!options.json)
+                    formatCheck(result);
             }
             catch (err) {
                 spin.stop();
@@ -266,7 +450,30 @@ export function doctorCommand() {
                     message: err instanceof Error ? err.message : 'Unknown error',
                 };
                 results.push(result);
-                formatCheck(result);
+                if (!options.json)
+                    formatCheck(result);
+            }
+        }
+        // Run multi-result check: API key validation per provider
+        {
+            const spin = spinner('Checking API keys...').start();
+            try {
+                const apiKeyResults = await checkApiKeyValidation();
+                results.push(...apiKeyResults);
+                spin.stop();
+                if (!options.json)
+                    apiKeyResults.forEach(formatCheck);
+            }
+            catch (err) {
+                spin.stop();
+                const result = {
+                    name: 'API Keys',
+                    status: 'fail',
+                    message: err instanceof Error ? err.message : 'Unknown error',
+                };
+                results.push(result);
+                if (!options.json)
+                    formatCheck(result);
             }
         }
         if (options.json) {
@@ -277,15 +484,14 @@ export function doctorCommand() {
         const warnings = results.filter((r) => r.status === 'warn').length;
         const failed = results.filter((r) => r.status === 'fail').length;
         console.log('');
-        const total = results.length;
         if (failed === 0 && warnings === 0) {
-            success(`All ${total} checks passed`);
+            success(`${passed} passed`);
         }
         else if (failed === 0) {
-            info(`${passed}/${total} passed, ${warnings} warnings`);
+            info(`${passed} passed | ${warnings} warning${warnings !== 1 ? 's' : ''} | 0 failed`);
         }
         else {
-            error(`${passed}/${total} passed, ${warnings} warnings, ${failed} failed`);
+            error(`${passed} passed | ${warnings} warning${warnings !== 1 ? 's' : ''} | ${failed} failed`);
             process.exitCode = 1;
         }
         console.log('');

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function historyCommands(): Command;
+//# sourceMappingURL=history.d.ts.map

package/dist/cli/commands/history.js

@@ -0,0 +1,138 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { TranscriptStore } from '../../agents/transcript.js';
+import { createTable, error, formatRelativeTime, truncate, } from '../utils/output.js';
+function getStore() {
+    return new TranscriptStore(process.cwd());
+}
+export function historyCommands() {
+    const cmd = new Command('history').description('View and search conversation history');
+    // -------------------------------------------------------------------
+    // profclaw history
+    // -------------------------------------------------------------------
+    cmd
+        .command('list', { isDefault: true })
+        .alias('ls')
+        .description('List recent conversation sessions')
+        .option('-l, --limit <n>', 'Max sessions to show', '20')
+        .option('--offset <n>', 'Skip first N sessions', '0')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const store = getStore();
+        const sessions = store.listSessions({
+            limit: parseInt(options.limit, 10),
+            offset: parseInt(options.offset, 10),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(sessions, null, 2));
+            return;
+        }
+        if (sessions.length === 0) {
+            console.log(chalk.dim('No sessions found.'));
+            return;
+        }
+        const table = createTable(['Session ID', 'Title', 'Messages', 'Tokens', 'Last Active']);
+        for (const s of sessions) {
+            table.push([
+                chalk.dim(s.sessionId.slice(0, 12)),
+                truncate(s.title, 40),
+                String(s.messageCount),
+                chalk.dim(String(s.tokensUsed)),
+                formatRelativeTime(new Date(s.lastActivityAt)),
+            ]);
+        }
+        console.log(`\n${chalk.bold('Conversation History')}`);
+        console.log(table.toString());
+        console.log(chalk.dim(`\nShowing ${sessions.length} session(s)`));
+    });
+    // -------------------------------------------------------------------
+    // profclaw history search <query>
+    // -------------------------------------------------------------------
+    cmd
+        .command('search <query>')
+        .description('Search across all transcript entries')
+        .option('-s, --session <sessionId>', 'Restrict search to a specific session')
+        .option('-l, --limit <n>', 'Max results to return', '20')
+        .option('--json', 'Output as JSON')
+        .action(async (query, options) => {
+        const store = getStore();
+        const results = store.search(query, {
+            sessionId: options.session,
+            limit: parseInt(options.limit, 10),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(results, null, 2));
+            return;
+        }
+        if (results.length === 0) {
+            console.log(chalk.dim(`No matches found for "${query}".`));
+            return;
+        }
+        const table = createTable(['Session', 'Line', 'Type', 'Content']);
+        for (const r of results) {
+            table.push([
+                chalk.dim(r.sessionId.slice(0, 12)),
+                chalk.dim(String(r.lineNumber)),
+                chalk.cyan(r.entry.type),
+                truncate(r.entry.content, 60),
+            ]);
+        }
+        console.log(`\n${chalk.bold(`Search results for "${query}"`)}`);
+        console.log(table.toString());
+        console.log(chalk.dim(`\nFound ${results.length} match(es)`));
+    });
+    // -------------------------------------------------------------------
+    // profclaw history show <sessionId>
+    // -------------------------------------------------------------------
+    cmd
+        .command('show <sessionId>')
+        .description('Show the full transcript for a session')
+        .option('--json', 'Output as JSON')
+        .option('--no-color', 'Disable color output')
+        .action(async (sessionId, options) => {
+        const store = getStore();
+        const entries = store.getSession(sessionId);
+        if (entries.length === 0) {
+            error(`No transcript found for session: ${sessionId}`);
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(entries, null, 2));
+            return;
+        }
+        console.log(`\n${chalk.bold('Transcript')} ${chalk.dim(sessionId)}\n`);
+        for (const entry of entries) {
+            const ts = new Date(entry.timestamp).toLocaleTimeString();
+            const label = entryLabel(entry.type);
+            console.log(`${chalk.dim(ts)} ${label}`);
+            console.log(chalk.white(entry.content));
+            if (entry.metadata?.toolName) {
+                console.log(chalk.dim(`  tool: ${entry.metadata.toolName}`));
+            }
+            if (entry.metadata?.tokensUsed) {
+                console.log(chalk.dim(`  tokens: ${entry.metadata.tokensUsed}`));
+            }
+            console.log();
+        }
+    });
+    return cmd;
+}
+function entryLabel(type) {
+    switch (type) {
+        case 'user':
+            return chalk.green('> User');
+        case 'assistant':
+            return chalk.blue('~ Assistant');
+        case 'tool_call':
+            return chalk.yellow('# Tool Call');
+        case 'tool_result':
+            return chalk.yellow('# Tool Result');
+        case 'system':
+            return chalk.dim('* System');
+        case 'error':
+            return chalk.red('! Error');
+        default:
+            return chalk.dim(type);
+    }
+}
+//# sourceMappingURL=history.js.map

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

@@ -0,0 +1,44 @@
+/**
+ * Import/Migration CLI Command
+ *
+ * Imports data from other AI assistants into profClaw:
+ *   - OpenClaw: memories, skills, conversation history
+ *   - ChatGPT: exported conversations (JSON)
+ *   - Aider: chat history
+ *
+ * Usage:
+ *   profclaw import --from openclaw [--path ~/.openclaw]
+ *   profclaw import --from chatgpt --file conversations.json
+ *   profclaw import --from aider [--path .]
+ */
+import { Command } from 'commander';
+export type ImportSource = 'openclaw' | 'chatgpt' | 'aider';
+export interface ImportResult {
+    source: ImportSource;
+    memories: number;
+    conversations: number;
+    skills: number;
+    preferences: number;
+    errors: string[];
+    duration: number;
+}
+/**
+ * Import data from another AI assistant into profClaw.
+ * Returns a summary of what was imported.
+ */
+export declare function importFrom(source: ImportSource, options?: {
+    path?: string;
+    file?: string;
+    dryRun?: boolean;
+}): Promise<ImportResult>;
+/**
+ * List available import sources and their expected paths.
+ */
+export declare function listImportSources(): Array<{
+    source: ImportSource;
+    description: string;
+    defaultPath: string;
+    format: string;
+}>;
+export declare function importCommands(): Command;
+//# sourceMappingURL=import.d.ts.map