profclaw 0.0.1-beta.1 → 0.0.1-beta.2

package/dist/cli/commands/setup.js

@@ -11,7 +11,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import figlet from 'figlet';
-import { createInterface } from 'readline/promises';
+import { select, input, password as passwordPrompt, confirm } from '@inquirer/prompts';
 import { randomUUID } from 'crypto';
 import { eq } from 'drizzle-orm';
 import { initStorage, getDb, saveProviderConfig } from '../../storage/index.js';
@@ -28,36 +28,8 @@ function showBanner() {
     console.log(chalk.cyan(banner));
     console.log(chalk.dim('  Setup Wizard\n'));
 }
-async function prompt(rl, question) {
-    const answer = await rl.question(chalk.bold(question));
-    return answer.trim();
-}
-async function promptPassword(rl, question) {
-    // readline/promises doesn't natively hide input, but for a CLI wizard this is acceptable
-    const answer = await rl.question(chalk.bold(question));
-    return answer.trim();
-}
-async function promptChoice(rl, question, options) {
-    console.log('');
-    console.log(chalk.bold(question));
-    for (const opt of options) {
-        console.log(`  ${chalk.cyan(opt.key)}) ${opt.label}`);
-    }
-    const validKeys = options.map((o) => o.key);
-    while (true) {
-        const answer = await prompt(rl, `Choice [${validKeys.join('/')}]: `);
-        if (validKeys.includes(answer))
-            return answer;
-        console.log(chalk.red(`  Invalid choice. Options: ${validKeys.join(', ')}`));
-    }
-}
-async function promptYesNo(rl, question, defaultYes = false) {
-    const hint = defaultYes ? 'Y/n' : 'y/N';
-    const answer = await prompt(rl, `${question} [${hint}]: `);
-    if (!answer)
-        return defaultYes;
-    return answer.toLowerCase().startsWith('y');
-}
+// Inquirer theme for consistent prefix
+const theme = { prefix: '  ', style: { highlight: (text) => chalk.cyan.bold(text) } };
 async function checkRedis() {
     try {
         const IORedis = (await import('ioredis')).default;
@@ -172,43 +144,72 @@ async function stepSystemCheck(db) {
     return { redisOk, hasAdmin, hasAnthropicKey, hasOpenAIKey };
 }
 // Step 2: AI Provider
-async function stepAiProvider(rl, status) {
+async function stepAiProvider(status) {
     if (status.hasAnthropicKey || status.hasOpenAIKey) {
         const provider = status.hasAnthropicKey ? 'Anthropic' : 'OpenAI';
         info(`AI provider already configured (${provider} from env).`);
-        const reconfigure = await promptYesNo(rl, '  Reconfigure AI provider?', false);
-        if (!reconfigure)
+        try {
+            const reconfigure = await confirm({
+                message: 'Reconfigure AI provider?',
+                default: false,
+                theme,
+            });
+            if (!reconfigure)
+                return 'skip';
+        }
+        catch {
             return 'skip';
+        }
+    }
+    let choice;
+    try {
+        choice = await select({
+            message: 'Select AI Provider',
+            choices: [
+                { name: `Anthropic ${chalk.green('(recommended)')}`, value: 'anthropic', description: 'Claude 4.x, 3.5 Sonnet' },
+                { name: 'OpenAI', value: 'openai', description: 'GPT-4o, o1, o3' },
+                { name: `Ollama ${chalk.cyan('(free, local)')}`, value: 'ollama', description: 'Llama, Mistral, Qwen - runs on your machine' },
+                { name: chalk.dim('Skip for now'), value: 'skip', description: 'Configure later in Settings' },
+            ],
+            theme,
+        });
+    }
+    catch {
+        return 'skip';
     }
-    const choice = await promptChoice(rl, '  Select AI Provider:', [
-        { key: '1', label: 'Anthropic API Key (recommended)' },
-        { key: '2', label: 'OpenAI API Key' },
-        { key: '3', label: 'Ollama (free, local AI)' },
-        { key: '4', label: 'Skip for now' },
-    ]);
-    if (choice === '4') {
+    if (choice === 'skip') {
         info('AI provider skipped. You can configure it later in Settings.');
         return 'skip';
     }
-    if (choice === '1') {
-        const apiKey = await prompt(rl, '  Anthropic API Key: ');
-        if (!apiKey) {
-            warn('No key provided, skipping.');
+    if (choice === 'anthropic') {
+        try {
+            const apiKey = await input({ message: 'Anthropic API Key', theme });
+            if (!apiKey) {
+                warn('No key provided, skipping.');
+                return 'skip';
+            }
+            await saveProviderConfig({ type: 'anthropic', apiKey, enabled: true });
+            success('Anthropic provider configured.');
+            return 'anthropic';
+        }
+        catch {
             return 'skip';
         }
-        await saveProviderConfig({ type: 'anthropic', apiKey, enabled: true });
-        success('Anthropic provider configured.');
-        return 'anthropic';
-    }
-    if (choice === '2') {
-        const apiKey = await prompt(rl, '  OpenAI API Key: ');
-        if (!apiKey) {
-            warn('No key provided, skipping.');
+    }
+    if (choice === 'openai') {
+        try {
+            const apiKey = await input({ message: 'OpenAI API Key', theme });
+            if (!apiKey) {
+                warn('No key provided, skipping.');
+                return 'skip';
+            }
+            await saveProviderConfig({ type: 'openai', apiKey, enabled: true });
+            success('OpenAI provider configured.');
+            return 'openai';
+        }
+        catch {
             return 'skip';
         }
-        await saveProviderConfig({ type: 'openai', apiKey, enabled: true });
-        success('OpenAI provider configured.');
-        return 'openai';
     }
     // Ollama
     const ollamaUrl = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
@@ -261,7 +262,7 @@ function showRecoveryCodes(codes) {
     console.log('');
     warn('These codes cannot be shown again!');
 }
-async function stepAdminAccount(rl, db) {
+async function stepAdminAccount(db) {
     if (!db) {
         error('Database not available. Cannot create admin account.');
         return null;
@@ -271,37 +272,58 @@ async function stepAdminAccount(rl, db) {
     if (existingAdmins.length > 0) {
         console.log(chalk.dim('  Existing admin accounts:'));
         for (const admin of existingAdmins) {
-            console.log(`    ${chalk.green('•')} ${admin.name} ${chalk.dim(`<${admin.email}>`)}`);
+            console.log(`    ${chalk.green('\u2022')} ${admin.name} ${chalk.dim(`<${admin.email}>`)}`);
         }
         console.log('');
-        console.log('  What would you like to do?');
-        console.log(`    ${chalk.bold('1)')} Keep existing — no changes`);
-        console.log(`    ${chalk.bold('2)')} Reset password for an existing admin`);
-        console.log(`    ${chalk.bold('3)')} Create an additional admin`);
-        console.log('');
-        const choice = await prompt(rl, '  Choice [1]: ');
-        const picked = choice || '1';
-        if (picked === '1') {
+        let picked;
+        try {
+            picked = await select({
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'Keep existing - no changes', value: 'keep' },
+                    { name: 'Reset password for an existing admin', value: 'reset' },
+                    { name: 'Create an additional admin', value: 'create' },
+                ],
+                theme,
+            });
+        }
+        catch {
+            return existingAdmins[0].email;
+        }
+        if (picked === 'keep') {
             success(`Keeping ${existingAdmins.length} existing admin(s).`);
             return existingAdmins[0].email;
         }
-        if (picked === '2') {
-            // Reset password for existing admin
+        if (picked === 'reset') {
             let targetAdmin = existingAdmins[0];
             if (existingAdmins.length > 1) {
-                console.log('');
-                for (let i = 0; i < existingAdmins.length; i++) {
-                    console.log(`    ${chalk.bold(`${i + 1})`)} ${existingAdmins[i].email}`);
+                try {
+                    const adminId = await select({
+                        message: 'Which admin?',
+                        choices: existingAdmins.map(a => ({
+                            name: `${a.name} ${chalk.dim(`<${a.email}>`)}`,
+                            value: a.id,
+                        })),
+                        theme,
+                    });
+                    targetAdmin = existingAdmins.find(a => a.id === adminId) || existingAdmins[0];
                 }
-                const idx = await prompt(rl, `  Which admin? [1]: `);
-                const n = parseInt(idx || '1', 10) - 1;
-                if (n >= 0 && n < existingAdmins.length) {
-                    targetAdmin = existingAdmins[n];
+                catch {
+                    return existingAdmins[0].email;
                 }
             }
             let newPassword = '';
             while (true) {
-                newPassword = await promptPassword(rl, '  New password (min 8 chars, 1 letter, 1 number): ');
+                try {
+                    newPassword = await passwordPrompt({
+                        message: 'New password (min 8 chars, 1 letter, 1 number)',
+                        mask: '*',
+                        theme,
+                    });
+                }
+                catch {
+                    return existingAdmins[0].email;
+                }
                 const strengthError = validatePasswordStrength(newPassword);
                 if (!strengthError)
                     break;
@@ -321,18 +343,30 @@ async function stepAdminAccount(rl, db) {
             showRecoveryCodes(recoveryCodes);
             return targetAdmin.email;
         }
-        // picked === '3' — fall through to create new admin
+        // picked === 'create' - fall through to create new admin
         console.log('');
     }
     // Create new admin
-    const name = await prompt(rl, '  Name: ');
+    let name;
+    try {
+        name = await input({ message: 'Name', theme });
+    }
+    catch {
+        return existingAdmins.length > 0 ? existingAdmins[0].email : null;
+    }
     if (!name) {
         warn('Admin account creation skipped.');
         return existingAdmins.length > 0 ? existingAdmins[0].email : null;
     }
-    const email = await prompt(rl, '  Email: ');
-    if (!email || !email.includes('@')) {
-        error('Invalid email address.');
+    let email;
+    try {
+        email = await input({
+            message: 'Email',
+            validate: (val) => val.includes('@') || 'Must be a valid email address',
+            theme,
+        });
+    }
+    catch {
         return existingAdmins.length > 0 ? existingAdmins[0].email : null;
     }
     // Check email uniqueness
@@ -345,10 +379,19 @@ async function stepAdminAccount(rl, db) {
         error(`User with email ${email} already exists.`);
         return existingAdmins.length > 0 ? existingAdmins[0].email : null;
     }
-    let password = '';
+    let pw = '';
     while (true) {
-        password = await promptPassword(rl, '  Password (min 8 chars, 1 letter, 1 number): ');
-        const strengthError = validatePasswordStrength(password);
+        try {
+            pw = await passwordPrompt({
+                message: 'Password (min 8 chars, 1 letter, 1 number)',
+                mask: '*',
+                theme,
+            });
+        }
+        catch {
+            return existingAdmins.length > 0 ? existingAdmins[0].email : null;
+        }
+        const strengthError = validatePasswordStrength(pw);
         if (!strengthError)
             break;
         console.log(chalk.red(`  ${strengthError}`));
@@ -356,7 +399,7 @@ async function stepAdminAccount(rl, db) {
     // Prefer server API (avoids cross-process LibSQL issues in Docker)
     const serverUrl = await getServerBaseUrl();
     if (serverUrl) {
-        const apiResult = await createAdminViaApi(serverUrl, email, password, name);
+        const apiResult = await createAdminViaApi(serverUrl, email, pw, name);
         if (apiResult) {
             success(`Admin account created: ${apiResult.email}`);
             showRecoveryCodes(apiResult.recoveryCodes);
@@ -364,26 +407,45 @@ async function stepAdminAccount(rl, db) {
         }
     }
     // Fall back to direct DB
-    const result = await createAdminUser(db, name, email, password);
+    const result = await createAdminUser(db, name, email, pw);
     success(`Admin account created: ${result.email}`);
     showRecoveryCodes(result.recoveryCodes);
     return result.email;
 }
 // Step 4: Registration Mode
-async function stepRegistrationMode(rl, db) {
+async function stepRegistrationMode(db) {
     console.log(chalk.bold.white('\n  Step 4: Registration Mode\n'));
-    const choice = await promptChoice(rl, '  How should new users register?', [
-        { key: '1', label: 'Invite only (default, more secure)' },
-        { key: '2', label: 'Open registration' },
-    ]);
-    const mode = choice === '1' ? 'invite' : 'open';
+    let mode;
+    try {
+        mode = await select({
+            message: 'How should new users register?',
+            choices: [
+                { name: 'Invite only (more secure)', value: 'invite', description: 'Users need an invite code to sign up' },
+                { name: 'Open registration', value: 'open', description: 'Anyone can create an account' },
+            ],
+            theme,
+        });
+    }
+    catch {
+        mode = 'invite';
+    }
     await updateSettings({
         system: { registrationMode: mode },
     });
     success(`Registration mode set to ${chalk.bold(mode)}.`);
     const codes = [];
     if (mode === 'invite' && db) {
-        const generate = await promptYesNo(rl, '  Generate 3 invite codes now?', true);
+        let generate;
+        try {
+            generate = await confirm({
+                message: 'Generate 3 invite codes now?',
+                default: true,
+                theme,
+            });
+        }
+        catch {
+            generate = false;
+        }
         if (generate) {
             for (let i = 0; i < 3; i++) {
                 const code = generateInviteCode();
@@ -409,9 +471,19 @@ async function stepRegistrationMode(rl, db) {
     return { mode, codes };
 }
 // Step 5: GitHub OAuth (optional)
-async function stepGitHubOAuth(rl) {
+async function stepGitHubOAuth() {
     console.log(chalk.bold.white('\n  Step 5: GitHub OAuth (Optional)\n'));
-    const configure = await promptYesNo(rl, '  Configure GitHub OAuth login?', false);
+    let configure;
+    try {
+        configure = await confirm({
+            message: 'Configure GitHub OAuth login?',
+            default: false,
+            theme,
+        });
+    }
+    catch {
+        return false;
+    }
     if (!configure) {
         info('GitHub OAuth skipped. Configure later in Settings.');
         return false;
@@ -421,8 +493,15 @@ async function stepGitHubOAuth(rl) {
     info(`Callback URL: ${chalk.cyan(`http://localhost:${port}/api/auth/github/callback`)}`);
     info('Create a GitHub OAuth App at: https://github.com/settings/developers');
     console.log('');
-    const clientId = await prompt(rl, '  GitHub Client ID: ');
-    const clientSecret = await prompt(rl, '  GitHub Client Secret: ');
+    let clientId;
+    let clientSecret;
+    try {
+        clientId = await input({ message: 'GitHub Client ID', theme });
+        clientSecret = await input({ message: 'GitHub Client Secret', theme });
+    }
+    catch {
+        return false;
+    }
     if (!clientId || !clientSecret) {
         warn('Incomplete credentials, skipping GitHub OAuth.');
         return false;
@@ -602,20 +681,17 @@ export function setupCommand() {
                 error('Failed to initialize database.');
                 process.exit(1);
             }
-            // Create a single readline interface for all steps
-            const rl = createInterface({ input: process.stdin, output: process.stdout });
             // Step 1: System Check
             const status = await stepSystemCheck(db);
             // Step 2: AI Provider
             console.log(chalk.bold.white('\n  Step 2: AI Provider\n'));
-            const aiProvider = await stepAiProvider(rl, status);
+            const aiProvider = await stepAiProvider(status);
             // Step 3: Admin Account
-            const adminEmail = await stepAdminAccount(rl, db);
+            const adminEmail = await stepAdminAccount(db);
             // Step 4: Registration Mode
-            const regResult = await stepRegistrationMode(rl, db);
+            const regResult = await stepRegistrationMode(db);
             // Step 5: GitHub OAuth
-            const githubOAuth = await stepGitHubOAuth(rl);
-            rl.close();
+            const githubOAuth = await stepGitHubOAuth();
             // Step 6: Summary
             showSummary({
                 redisOk: status.redisOk,

package/dist/cron/issue-poller.js

@@ -84,7 +84,7 @@ ${issue.body || 'No description provided.'}
 
 Closes #${issue.number}
 
-Co-Authored-By: profClaw <bot@profclaw.dev>"
+Co-Authored-By: profClaw <bot@profclaw.ai>"
 8. Push: git push -u origin HEAD
 9. Create PR: gh pr create --title "<title>" --body "Closes #${issue.number}"
 

package/dist/hooks/agent-webhook.js

@@ -7,6 +7,8 @@
 import { randomUUID } from 'crypto';
 import { createHmac, timingSafeEqual } from 'crypto';
 import { z } from 'zod';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('AgentWebhook');
 // Schemas
 /**
  * Generic agent completion payload
@@ -62,7 +64,7 @@ function verifySignature(agent, rawBody, signature) {
     const secret = WEBHOOK_SECRETS[agent] || WEBHOOK_SECRETS.generic;
     // Skip verification if no secret configured
     if (!secret) {
-        console.warn(`[Webhook] No secret configured for ${agent}, skipping verification`);
+        log.warn('No secret configured for agent, skipping verification', { agent });
         return true;
     }
     if (!signature) {
@@ -103,7 +105,7 @@ export async function handleOpenClawWebhook(c) {
     }
     const parsed = OpenClawCompletionSchema.safeParse(payload);
     if (!parsed.success) {
-        console.error('[Webhook] OpenClaw validation failed:', parsed.error.flatten());
+        log.error('OpenClaw validation failed', new Error(parsed.error.message));
         throw new Error(`Validation failed: ${parsed.error.message}`);
     }
     return processAgentCompletion(parsed.data);
@@ -129,7 +131,7 @@ export async function handleGenericAgentWebhook(c) {
     }
     const parsed = AgentCompletionSchema.safeParse(payload);
     if (!parsed.success) {
-        console.error('[Webhook] Agent validation failed:', parsed.error.flatten());
+        log.error('Agent validation failed', new Error(parsed.error.message));
         throw new Error(`Validation failed: ${parsed.error.message}`);
     }
     return processAgentCompletion(parsed.data);
@@ -158,10 +160,11 @@ function processAgentCompletion(completion) {
         taskReports.set(report.taskId, reports);
     }
     // Log
-    console.log(`[Webhook] Agent ${completion.agent} reported: ${completion.status}`);
-    if (completion.artifacts?.length) {
-        console.log(`[Webhook] Artifacts: ${completion.artifacts.length} items`);
-    }
+    log.info('Agent reported completion', {
+        agent: completion.agent,
+        status: completion.status,
+        artifacts: completion.artifacts?.length,
+    });
     return report;
 }
 // Query Functions

package/dist/hooks/prompt-submit.js

@@ -13,6 +13,8 @@
  */
 import { randomUUID } from 'crypto';
 import { UserPromptSubmitPayloadSchema } from './schemas.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('PromptSubmit');
 // In-memory storage for prompt events
 const promptEvents = new Map();
 /**
@@ -35,7 +37,7 @@ export async function handlePromptSubmit(c) {
         }
         const parsed = UserPromptSubmitPayloadSchema.safeParse(payload);
         if (!parsed.success) {
-            console.error('[Hook] Prompt submit validation failed:', parsed.error.flatten());
+            log.error('Prompt submit validation failed', new Error(parsed.error.message));
             return {
                 success: false,
                 eventId: '',
@@ -56,17 +58,14 @@ export async function handlePromptSubmit(c) {
         storePromptEvent(event);
         // Log for debugging
         const promptPreview = event.prompt.slice(0, 50) + (event.prompt.length > 50 ? '...' : '');
-        console.log(`[Hook] UserPromptSubmit: "${promptPreview}"`);
-        if (event.context?.file) {
-            console.log(`[Hook] Context file: ${event.context.file}`);
-        }
+        log.info('UserPromptSubmit', { promptPreview, contextFile: event.context?.file });
         return {
             success: true,
             eventId: event.id,
         };
     }
     catch (error) {
-        console.error('[Hook] Error processing prompt submit:', error);
+        log.error('Error processing prompt submit', error instanceof Error ? error : new Error(String(error)));
         return {
             success: false,
             eventId: '',

package/dist/hooks/session-end.js

@@ -8,6 +8,8 @@ import { randomUUID } from 'crypto';
 import { SessionEndPayloadSchema } from './schemas.js';
 import { getSessionEvents, clearSessionEvents, getSessionSummary } from './tool-use.js';
 import { aggregateInferences } from '../intelligence/rules.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('SessionEnd');
 // Session aggregates storage
 const sessionAggregates = new Map();
 /**
@@ -30,7 +32,7 @@ export async function handleSessionEnd(c) {
         }
         const parsed = SessionEndPayloadSchema.safeParse(payload);
         if (!parsed.success) {
-            console.error('[Hook] Session end validation failed:', parsed.error.flatten());
+            log.error('Session end validation failed', new Error(parsed.error.message));
             return {
                 success: false,
                 eventId: '',
@@ -67,10 +69,12 @@ export async function handleSessionEnd(c) {
         // Store aggregate
         sessionAggregates.set(sessionId, aggregate);
         // Log session summary
-        console.log(`[Hook] Session ended: ${sessionId}`);
-        console.log(`[Hook] Files modified: ${aggregate.filesModified.length}`);
-        console.log(`[Hook] Files created: ${aggregate.filesCreated.length}`);
-        console.log(`[Hook] Total tool uses: ${Object.values(summary.toolUseCounts).reduce((a, b) => a + b, 0)}`);
+        log.info('Session ended', {
+            sessionId,
+            filesModified: aggregate.filesModified.length,
+            filesCreated: aggregate.filesCreated.length,
+            totalToolUses: Object.values(summary.toolUseCounts).reduce((a, b) => a + b, 0),
+        });
         // Clear in-memory events (we have the aggregate now)
         clearSessionEvents(sessionId);
         return {
@@ -80,7 +84,7 @@ export async function handleSessionEnd(c) {
         };
     }
     catch (error) {
-        console.error('[Hook] Error processing session end:', error);
+        log.error('Error processing session end', error instanceof Error ? error : new Error(String(error)));
         return {
             success: false,
             eventId: '',

package/dist/hooks/tool-use.js

@@ -14,6 +14,8 @@
 import { randomUUID } from 'crypto';
 import { PostToolUsePayloadSchema } from './schemas.js';
 import { inferFromToolUse } from '../intelligence/rules.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('ToolUse');
 // In-memory storage for hook events (will be replaced with DB later)
 const hookEvents = new Map();
 const sessionEvents = new Map();
@@ -42,7 +44,7 @@ export async function handlePostToolUse(c) {
         // Validate payload
         const parsed = PostToolUsePayloadSchema.safeParse(payload);
         if (!parsed.success) {
-            console.error('[Hook] Validation failed:', parsed.error.flatten());
+            log.error('Validation failed', new Error(parsed.error.message));
             return {
                 success: false,
                 eventId: '',
@@ -67,10 +69,11 @@ export async function handlePostToolUse(c) {
         // Store event
         storeEvent(event);
         // Log for debugging
-        console.log(`[Hook] PostToolUse: ${hookPayload.tool} on ${eventData.filePath || 'N/A'}`);
-        if (inference.confidence > 0) {
-            console.log(`[Hook] Inference: ${JSON.stringify(inference)}`);
-        }
+        log.info('PostToolUse', {
+            tool: hookPayload.tool,
+            filePath: eventData.filePath || 'N/A',
+            inference: inference.confidence > 0 ? inference : undefined,
+        });
         return {
             success: true,
             eventId: event.id,
@@ -78,7 +81,7 @@ export async function handlePostToolUse(c) {
         };
     }
     catch (error) {
-        console.error('[Hook] Error processing PostToolUse:', error);
+        log.error('Error processing PostToolUse', error instanceof Error ? error : new Error(String(error)));
         return {
             success: false,
             eventId: '',