profclaw 0.0.1-beta.1

package/dist/cli/commands/skill.js

@@ -0,0 +1,191 @@
+/**
+ * Skill CLI Commands
+ *
+ * Manage profClaw skills from the command line.
+ *
+ * Usage:
+ *   profclaw skill list
+ *   profclaw skill info <name>
+ *   profclaw skill enable <name>
+ *   profclaw skill disable <name>
+ *   profclaw skill reload
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { api } from '../utils/api.js';
+import { createTable, success, error, info, spinner, truncate } from '../utils/output.js';
+export function skillCommands() {
+    const cmd = new Command('skill')
+        .description('Manage profClaw skills');
+    // profclaw skill list
+    cmd
+        .command('list')
+        .alias('ls')
+        .description('List all skills')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching skills...').start();
+        const result = await api.get('/api/skills');
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch skills');
+            process.exit(1);
+        }
+        const { skills, stats } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        if (skills.length === 0) {
+            info('No skills found.');
+            return;
+        }
+        const table = createTable(['Name', 'Enabled', 'Source', 'Description']);
+        for (const s of skills) {
+            const enabledDisplay = s.enabled
+                ? chalk.green('✓ yes')
+                : chalk.red('✗ no');
+            table.push([
+                s.name,
+                enabledDisplay,
+                s.source,
+                truncate(s.description, 50),
+            ]);
+        }
+        console.log(table.toString());
+        const disabledCount = stats.total - stats.enabled;
+        console.log(chalk.dim(`\n${stats.enabled} enabled, ${disabledCount} disabled, ${stats.total} total`));
+    });
+    // profclaw skill info <name>
+    cmd
+        .command('info <name>')
+        .description('Show detailed information about a skill')
+        .option('--json', 'Output as JSON')
+        .action(async (name, options) => {
+        const spin = spinner(`Fetching skill ${name}...`).start();
+        const result = await api.get(`/api/skills/${name}`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || `Skill not found: ${name}`);
+            process.exit(1);
+        }
+        const skill = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(skill, null, 2));
+            return;
+        }
+        const label = (text) => chalk.bold.white(text + ':');
+        const val = (text) => text ? text : chalk.dim('none');
+        console.log('');
+        console.log(`${label('Name')}         ${chalk.cyan(skill.name)}`);
+        console.log(`${label('Description')}  ${val(skill.description)}`);
+        console.log(`${label('Enabled')}      ${skill.enabled ? chalk.green('yes') : chalk.red('no')}`);
+        console.log(`${label('Source')}       ${val(skill.source)}`);
+        if (skill.eligible != null) {
+            console.log(`${label('Eligible')}     ${skill.eligible ? chalk.green('yes') : chalk.yellow('no')}`);
+        }
+        if (skill.capabilities && skill.capabilities.length > 0) {
+            console.log(`${label('Capabilities')} ${skill.capabilities.join(', ')}`);
+        }
+        if (skill.dependencies && skill.dependencies.length > 0) {
+            console.log(`${label('Dependencies')} ${skill.dependencies.join(', ')}`);
+        }
+        if (skill.stats) {
+            console.log('');
+            console.log(chalk.bold.white('Stats:'));
+            if (skill.stats.invocations != null) {
+                console.log(`  Invocations: ${skill.stats.invocations}`);
+            }
+            if (skill.stats.avgDurationMs != null) {
+                console.log(`  Avg duration: ${skill.stats.avgDurationMs}ms`);
+            }
+            if (skill.stats.lastUsed) {
+                console.log(`  Last used: ${skill.stats.lastUsed}`);
+            }
+        }
+        console.log('');
+    });
+    // profclaw skill enable <name>
+    cmd
+        .command('enable <name>')
+        .description('Enable a skill')
+        .option('--json', 'Output as JSON')
+        .action(async (name, options) => {
+        const checkSpin = spinner(`Checking skill ${name}...`).start();
+        const checkResult = await api.get(`/api/skills/${name}`);
+        checkSpin.stop();
+        if (!checkResult.ok) {
+            error(checkResult.error || `Skill not found: ${name}`);
+            process.exit(1);
+        }
+        if (checkResult.data.enabled) {
+            info(`Skill ${chalk.cyan(name)} is already enabled`);
+            return;
+        }
+        const spin = spinner(`Enabling ${name}...`).start();
+        const result = await api.post(`/api/skills/${name}/toggle`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || `Failed to enable ${name}`);
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        success(`Skill ${chalk.cyan(name)} enabled`);
+    });
+    // profclaw skill disable <name>
+    cmd
+        .command('disable <name>')
+        .description('Disable a skill')
+        .option('--json', 'Output as JSON')
+        .action(async (name, options) => {
+        const checkSpin = spinner(`Checking skill ${name}...`).start();
+        const checkResult = await api.get(`/api/skills/${name}`);
+        checkSpin.stop();
+        if (!checkResult.ok) {
+            error(checkResult.error || `Skill not found: ${name}`);
+            process.exit(1);
+        }
+        if (!checkResult.data.enabled) {
+            info(`Skill ${chalk.cyan(name)} is already disabled`);
+            return;
+        }
+        const spin = spinner(`Disabling ${name}...`).start();
+        const result = await api.post(`/api/skills/${name}/toggle`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || `Failed to disable ${name}`);
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        success(`Skill ${chalk.cyan(name)} disabled`);
+    });
+    // profclaw skill reload
+    cmd
+        .command('reload')
+        .description('Reload all skills from disk')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Reloading skills...').start();
+        const result = await api.post('/api/skills/reload');
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to reload skills');
+            process.exit(1);
+        }
+        const { message, stats } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        success(message);
+        console.log(chalk.dim(`${stats.loaded} loaded, ${stats.failed} failed, ${stats.total} total`));
+    });
+    return cmd;
+}
+//# sourceMappingURL=skill.js.map

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

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

package/dist/cli/commands/status.js

@@ -0,0 +1,71 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { api } from '../utils/api.js';
+import { spinner } from '../utils/output.js';
+export function statusCommand() {
+    const cmd = new Command('status')
+        .description('System status overview')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching system status...').start();
+        const [health, providers, skills, memory, tunnels] = await Promise.all([
+            api.get('/health'),
+            api.get('/api/chat/providers'),
+            api.get('/api/skills'),
+            api.get('/api/memory/stats'),
+            api.get('/api/tunnels/status'),
+        ]);
+        spin.stop();
+        if (options.json) {
+            console.log(JSON.stringify({
+                health: health.data,
+                providers: providers.data,
+                skills: skills.data,
+                memory: memory.data,
+                tunnels: tunnels.data,
+            }, null, 2));
+            return;
+        }
+        const version = health.data?.version || '?';
+        const mode = health.data?.mode ||
+            health.data?.system?.deploymentMode ||
+            process.env['PROFCLAW_MODE'] ||
+            'mini';
+        const statusText = health.ok
+            ? chalk.green('healthy')
+            : chalk.red('unhealthy');
+        console.log(`\nprofClaw v${version} | Mode: ${mode} | Status: ${statusText}\n`);
+        if (providers.ok && providers.data) {
+            const active = providers.data.providers.filter((p) => p.enabled || p.configured);
+            const healthySummary = active
+                .map((p) => p.healthy ? chalk.green(p.type) : chalk.red(p.type))
+                .join(', ');
+            console.log(`${chalk.bold('Providers')}    ${active.length} configured (${healthySummary})`);
+        }
+        else {
+            console.log(`${chalk.bold('Providers')}    ${chalk.dim('unavailable')}`);
+        }
+        if (skills.ok && skills.data) {
+            const { stats } = skills.data;
+            console.log(`${chalk.bold('Skills')}       ${stats.total} loaded, ${stats.enabled} enabled`);
+        }
+        if (memory.ok && memory.data) {
+            const s = memory.data.stats;
+            console.log(`${chalk.bold('Memory')}       ${(s.totalChunks ?? 0).toLocaleString()} chunks across ${s.totalFiles ?? 0} files`);
+        }
+        if (tunnels.ok && tunnels.data) {
+            const cf = tunnels.data.cloudflare?.running
+                ? chalk.green('active')
+                : chalk.dim('not running');
+            const ts = tunnels.data.tailscale?.available
+                ? tunnels.data.tailscale.serving
+                    ? chalk.green('serving')
+                    : chalk.dim('connected')
+                : chalk.dim('not running');
+            console.log(`${chalk.bold('Tunnels')}      Cloudflare: ${cf} | Tailscale: ${ts}`);
+        }
+        console.log();
+    });
+    return cmd;
+}
+//# sourceMappingURL=status.js.map

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

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

package/dist/cli/commands/summary.js

@@ -0,0 +1,160 @@
+import { Command } from 'commander';
+import { api } from '../utils/api.js';
+import { createTable, formatRelativeTime, truncate, error, spinner, } from '../utils/output.js';
+export function summaryCommands() {
+    const summary = new Command('summary')
+        .description('Browse AI work summaries');
+    // List summaries
+    summary
+        .command('list')
+        .alias('ls')
+        .description('List recent summaries')
+        .option('-a, --agent <agent>', 'Filter by agent')
+        .option('-l, --limit <n>', 'Limit results', '20')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching summaries...').start();
+        const params = new URLSearchParams();
+        if (options.agent)
+            params.set('agent', options.agent);
+        params.set('limit', options.limit);
+        const result = await api.get(`/api/summaries/recent?${params}`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch summaries');
+            process.exit(1);
+        }
+        const { summaries } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(summaries, null, 2));
+            return;
+        }
+        if (summaries.length === 0) {
+            console.log('No summaries found.');
+            return;
+        }
+        const table = createTable(['ID', 'Title', 'Agent', 'Type', 'Created']);
+        for (const s of summaries) {
+            table.push([
+                s.id.slice(0, 8),
+                truncate(s.title, 35),
+                s.agent,
+                s.taskType || '-',
+                formatRelativeTime(s.createdAt),
+            ]);
+        }
+        console.log(table.toString());
+    });
+    // Show summary details
+    summary
+        .command('show <id>')
+        .alias('get')
+        .description('Show summary details')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        const spin = spinner('Fetching summary...').start();
+        const result = await api.get(`/api/summaries/${id}`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Summary not found');
+            process.exit(1);
+        }
+        const { summary } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(summary, null, 2));
+            return;
+        }
+        console.log(`\n## ${summary.title}\n`);
+        console.log(`Agent: ${summary.agent}`);
+        console.log(`Type: ${summary.taskType || 'Unknown'}`);
+        console.log(`Created: ${formatRelativeTime(summary.createdAt)}\n`);
+        console.log('### What Changed');
+        console.log(summary.whatChanged);
+        if (summary.whyChanged) {
+            console.log('\n### Why');
+            console.log(summary.whyChanged);
+        }
+        if (summary.howChanged) {
+            console.log('\n### How');
+            console.log(summary.howChanged);
+        }
+        if (summary.filesChanged && summary.filesChanged.length > 0) {
+            console.log('\n### Files Changed');
+            for (const f of summary.filesChanged) {
+                console.log(`  - ${typeof f === 'string' ? f : f.path}`);
+            }
+        }
+    });
+    // Search summaries
+    summary
+        .command('search <query>')
+        .description('Search summaries')
+        .option('-l, --limit <n>', 'Limit results', '10')
+        .option('--json', 'Output as JSON')
+        .action(async (query, options) => {
+        const spin = spinner('Searching...').start();
+        const params = new URLSearchParams();
+        params.set('q', query);
+        params.set('limit', options.limit);
+        const result = await api.get(`/api/summaries/search?${params}`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Search failed');
+            process.exit(1);
+        }
+        const { summaries } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(summaries, null, 2));
+            return;
+        }
+        if (summaries.length === 0) {
+            console.log(`No results for "${query}"`);
+            return;
+        }
+        const table = createTable(['ID', 'Title', 'Agent', 'Created']);
+        for (const s of summaries) {
+            table.push([
+                s.id.slice(0, 8),
+                truncate(s.title, 40),
+                s.agent,
+                formatRelativeTime(s.createdAt),
+            ]);
+        }
+        console.log(table.toString());
+        console.log(`\nFound ${summaries.length} results for "${query}"`);
+    });
+    // Stats
+    summary
+        .command('stats')
+        .description('Show summary statistics')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching stats...').start();
+        const result = await api.get('/api/summaries/stats');
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch stats');
+            process.exit(1);
+        }
+        const stats = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(stats, null, 2));
+            return;
+        }
+        console.log('\n## Summary Statistics\n');
+        console.log(`Total Summaries: ${stats.totalCount}`);
+        console.log(`Total Tokens: ${stats.totalTokens?.toLocaleString() || 0}`);
+        console.log(`Total Cost: $${(stats.totalCost || 0).toFixed(4)}`);
+        console.log(`Files Changed: ${stats.filesChangedCount}`);
+        if (stats.byAgent && Object.keys(stats.byAgent).length > 0) {
+            console.log('\n### By Agent');
+            const table = createTable(['Agent', 'Count']);
+            for (const [agent, count] of Object.entries(stats.byAgent)) {
+                table.push([agent, String(count)]);
+            }
+            console.log(table.toString());
+        }
+    });
+    return summary;
+}
+//# sourceMappingURL=summary.js.map

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

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

package/dist/cli/commands/task.js

@@ -0,0 +1,170 @@
+import { Command } from 'commander';
+import { api } from '../utils/api.js';
+import { createTable, formatStatus, formatRelativeTime, truncate, success, error, spinner, } from '../utils/output.js';
+export function taskCommands() {
+    const task = new Command('task')
+        .description('Manage tasks');
+    // List tasks
+    task
+        .command('list')
+        .alias('ls')
+        .description('List all tasks')
+        .option('-s, --status <status>', 'Filter by status')
+        .option('-l, --limit <n>', 'Limit results', '20')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching tasks...').start();
+        const params = new URLSearchParams();
+        if (options.status)
+            params.set('status', options.status);
+        params.set('limit', options.limit);
+        const result = await api.get(`/api/tasks?${params}`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch tasks');
+            process.exit(1);
+        }
+        const { tasks, count } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(tasks, null, 2));
+            return;
+        }
+        if (tasks.length === 0) {
+            console.log('No tasks found.');
+            return;
+        }
+        const table = createTable(['ID', 'Title', 'Status', 'Agent', 'Updated']);
+        for (const t of tasks) {
+            table.push([
+                t.id.slice(0, 8),
+                truncate(t.title, 40),
+                formatStatus(t.status),
+                t.assignedAgent || '-',
+                formatRelativeTime(t.updatedAt),
+            ]);
+        }
+        console.log(table.toString());
+        console.log(`\nShowing ${tasks.length} of ${count} tasks`);
+    });
+    // Get task details
+    task
+        .command('show <id>')
+        .alias('get')
+        .description('Show task details')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        const spin = spinner('Fetching task...').start();
+        const result = await api.get(`/api/tasks/${id}`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch task');
+            process.exit(1);
+        }
+        const { task } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(task, null, 2));
+            return;
+        }
+        console.log(`\nTask: ${task.id}`);
+        console.log(`Title: ${task.title}`);
+        console.log(`Status: ${formatStatus(task.status)}`);
+        console.log(`Priority: ${task.priority}`);
+        console.log(`Agent: ${task.assignedAgent || 'Not assigned'}`);
+        console.log(`Created: ${formatRelativeTime(task.createdAt)}`);
+        console.log(`Updated: ${formatRelativeTime(task.updatedAt)}`);
+    });
+    // Create task
+    task
+        .command('create <title>')
+        .description('Create a new task')
+        .option('-d, --description <desc>', 'Task description')
+        .option('-p, --priority <n>', 'Priority (1-5)', '3')
+        .option('-a, --agent <agent>', 'Assign to agent')
+        .option('--json', 'Output as JSON')
+        .action(async (title, options) => {
+        const spin = spinner('Creating task...').start();
+        const result = await api.post('/api/tasks', {
+            title,
+            description: options.description,
+            prompt: options.description || title,
+            priority: parseInt(options.priority),
+            source: 'cli',
+            assignedAgent: options.agent,
+        });
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to create task');
+            process.exit(1);
+        }
+        const { task } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(task, null, 2));
+            return;
+        }
+        success(`Task created: ${task.id}`);
+        console.log(`  Title: ${task.title}`);
+        console.log(`  Status: ${formatStatus(task.status)}`);
+    });
+    // Cancel task
+    task
+        .command('cancel <id>')
+        .description('Cancel a running or pending task')
+        .action(async (id) => {
+        const spin = spinner('Cancelling task...').start();
+        const result = await api.post(`/api/tasks/${id}/cancel`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to cancel task');
+            process.exit(1);
+        }
+        success(`Task ${id} cancelled`);
+    });
+    // Retry task
+    task
+        .command('retry <id>')
+        .description('Retry a failed task')
+        .action(async (id) => {
+        const spin = spinner('Retrying task...').start();
+        const result = await api.post(`/api/tasks/${id}/retry`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to retry task');
+            process.exit(1);
+        }
+        const { task } = result.data;
+        success(`Task queued for retry: ${task.id}`);
+    });
+    // Task status (quick status check)
+    task
+        .command('status [id]')
+        .description('Check task status')
+        .action(async (id) => {
+        if (id) {
+            const result = await api.get(`/api/tasks/${id}`);
+            if (!result.ok) {
+                error(result.error || 'Task not found');
+                process.exit(1);
+            }
+            console.log(formatStatus(result.data.task.status));
+        }
+        else {
+            // Show overall status summary
+            const result = await api.get('/api/tasks?limit=1000');
+            if (!result.ok) {
+                error(result.error || 'Failed to fetch tasks');
+                process.exit(1);
+            }
+            const counts = {};
+            for (const t of result.data.tasks) {
+                counts[t.status] = (counts[t.status] || 0) + 1;
+            }
+            const table = createTable(['Status', 'Count']);
+            for (const [status, count] of Object.entries(counts)) {
+                table.push([formatStatus(status), count.toString()]);
+            }
+            console.log(table.toString());
+        }
+    });
+    return task;
+}
+//# sourceMappingURL=task.js.map

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

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