@rigstate/cli 0.6.7 → 0.6.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rigstate/cli",
-    "version": "0.6.7",
+    "version": "0.6.8",
     "description": "Rigstate CLI - Code audit, sync and supervision tool",
     "type": "module",
     "main": "./dist/index.js",

package/src/commands/idea.ts

@@ -0,0 +1,78 @@
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import axios from 'axios';
+import inquirer from 'inquirer';
+import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+
+export function createIdeaCommand(): Command {
+    return new Command('idea')
+        .description('Capture a new idea or feature request')
+        .argument('[title]', 'Quick title of the idea')
+        .option('-d, --desc <text>', 'Detailed description')
+        .option('-t, --tag <tags>', 'Comma separated tags (e.g. ui,auth)')
+        .action(async (title, options) => {
+            try {
+                const apiKey = getApiKey();
+                const apiUrl = getApiUrl();
+                const projectId = getProjectId();
+
+                if (!projectId) {
+                    console.error(chalk.red('Project context missing. Run rigstate link.'));
+                    process.exit(1);
+                }
+
+                // Interactive Inputs if missing
+                let ideaTitle = title;
+                let ideaDesc = options.desc;
+                let tags = options.tag ? options.tag.split(',') : [];
+
+                if (!ideaTitle) {
+                    const ans = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'title',
+                        message: 'Idea Title:'
+                    }]);
+                    ideaTitle = ans.title;
+                }
+
+                if (!ideaDesc) {
+                    const ans = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'desc',
+                        message: 'Description (Optional):'
+                    }]);
+                    ideaDesc = ans.desc;
+                }
+
+                if (tags.length === 0) {
+                    // Maybe ask for tags? Or just let it be empty
+                }
+
+                const spinner = ora('Securing idea in the Lab...').start();
+
+                // Submit to API
+                const response = await axios.post(
+                    `${apiUrl}/api/v1/ideas`,
+                    {
+                        project_id: projectId,
+                        title: ideaTitle,
+                        description: ideaDesc,
+                        tags
+                    },
+                    { headers: { Authorization: `Bearer ${apiKey}` } }
+                );
+
+                if (response.data.success) {
+                    spinner.succeed(chalk.green('Idea Captured! 💡'));
+                    console.log(chalk.dim(`ID: ${response.data.data?.id || 'Saved'}`));
+                } else {
+                    throw new Error(response.data.error);
+                }
+
+            } catch (e: any) {
+                console.error(chalk.red(`\nFailed to capture idea: ${e.message}`));
+            }
+        });
+}

package/src/commands/link.ts

@@ -63,10 +63,17 @@ export function createLinkCommand() {
                     // 3. Git Hooks
                     console.log(chalk.blue('🛡️  Checking immunity system...'));
                     await installHooks(process.cwd());
-                }
 
-                console.log('');
-                console.log(chalk.bold.green('🚀 Link Complete! Your environment is ready.'));
+                    console.log('');
+                    console.log(chalk.bold.green('🚀 Link Complete! Your environment is ready.'));
+
+                    // 4. Tactical Suggestion (The First Move)
+                    const { suggestNextMove } = await import('./suggest.js');
+                    await suggestNextMove(projectId, apiKey, apiUrl);
+                } else {
+                    console.log('');
+                    console.log(chalk.bold.green('🚀 Link Complete!'));
+                }
 
             } catch (error: any) {
                 if (error.message.includes('Not authenticated')) {

package/src/commands/suggest.ts

@@ -0,0 +1,67 @@
+
+import chalk from 'chalk';
+import axios from 'axios';
+import ora from 'ora';
+
+interface RoadmapStep {
+    id: string;
+    title: string;
+    step_number: number;
+    description: string;
+    status: string;
+    role: string;
+}
+
+export async function suggestNextMove(projectId: string, apiKey: string, apiUrl: string) {
+    // Silent spinner just to fetch data quickly
+    // const spinner = ora('Analyzing mission parameters...').start();
+
+    try {
+        // We use the roadmap chunks endpoint or a dedicated query
+        // For CLI efficiency, let's query raw chunks via a unified endpoint if possible
+        // Or assume we have a direct endpoint. 
+        // Let's use the standard `list_roadmap_tasks` equivalent logic via REST API if available.
+        // Assuming /api/v1/roadmap/next exists or similar. 
+        // If not, we query pending tasks.
+
+        const response = await axios.get(`${apiUrl}/api/v1/roadmap/chunks`, {
+            params: {
+                project_id: projectId,
+                status: 'PENDING',
+                limit: 1,
+                order: 'step_number.asc'
+            },
+            headers: { Authorization: `Bearer ${apiKey}` }
+        });
+
+        if (!response.data.success) {
+            return; // Fail silently, feature relies on API being ready
+        }
+
+        const tasks = response.data.data.chunks || [];
+        if (tasks.length === 0) return;
+
+        const nextTask = tasks[0] as RoadmapStep;
+
+        // Visual Presentation
+        console.log('');
+        console.log(chalk.bold('🎯 TACTICAL INTELLIGENCE'));
+        console.log(chalk.dim('────────────────────────────────────────'));
+        console.log(`${chalk.bold('Active Phase:')}  Implementation`);
+        console.log(`${chalk.bold('Next Mission:')}  ${chalk.cyan(nextTask.title)}`);
+
+        if (nextTask.role) {
+            console.log(`${chalk.bold('Required Role:')} ${chalk.magenta(nextTask.role)}`);
+        }
+
+        console.log('');
+        console.log(chalk.yellow('SUGGESTED NEXT MOVE:'));
+        console.log(chalk.white(`> rigstate work start ${nextTask.id}   `) + chalk.dim('(Start this task)'));
+        console.log(chalk.white(`> rigstate chat "How do I solve T-${nextTask.step_number}?" `) + chalk.dim('(Ask Architect)'));
+        console.log(chalk.dim('────────────────────────────────────────'));
+        console.log('');
+
+    } catch (e) {
+        // Ignore errors in suggestion engine to not break the flow
+    }
+}

package/src/commands/work.ts

@@ -4,169 +4,176 @@ import ora from 'ora';
 import axios from 'axios';
 import inquirer from 'inquirer';
 import fs from 'fs/promises';
-import path from 'path';
 import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+import { suggestNextMove } from './suggest.js';
 
 export function createWorkCommand(): Command {
-    return new Command('work')
-        .alias('start')
-        .description('Select and execute a Roadmap Task (fetches IDE Prompt)')
-        .argument('[taskId]', 'Optional Task ID (e.g., T-1021) to start immediately')
-        .option('--project <id>', 'Project ID')
-        .action(async (taskId: string | undefined, options: { project?: string }) => {
-            const spinner = ora();
-
-            try {
-                const apiKey = getApiKey();
-                const apiUrl = getApiUrl();
-                const projectId = options.project || getProjectId();
-
-                if (!projectId) {
-                    console.log(chalk.red('❌ Project ID is required. Run `rigstate link` or pass --project <id>'));
-                    process.exit(1);
-                }
-
-                if (!taskId) {
-                    spinner.start('Fetching active roadmap tasks...');
-                }
-
-                // 1. Fetch Roadmap
-                const response = await axios.get(
-                    `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
-                    { headers: { 'Authorization': `Bearer ${apiKey}` }, timeout: 10000 }
-                );
-
-                if (!response.data.success) {
-                    throw new Error(response.data.error || 'Failed to fetch roadmap');
-                }
-
-                const allTasks: any[] = response.data.data.roadmap || [];
-
-                // 2. Filter relevant tasks (ACTIVE or LOCKED or IN_PROGRESS if we had that status)
-                // We focus on ACTIVE (Started) and LOCKED (Next Up).
-                // Sort: ACTIVE first, then by step_number.
-                const actionableTasks = allTasks
-                    .filter(t => ['ACTIVE', 'LOCKED'].includes(t.status))
-                    .sort((a, b) => {
-                        if (a.status === 'ACTIVE' && b.status !== 'ACTIVE') return -1;
-                        if (b.status === 'ACTIVE' && a.status !== 'ACTIVE') return 1;
-                        return a.step_number - b.step_number;
-                    });
-
-                spinner.stop();
-
-                let selectedTask: any;
-
-                if (taskId) {
-                    // Direct Selection via Arg
-                    // taskId can be "T-1021" or just "1021" or the UUID
-                    selectedTask = allTasks.find(t =>
-                        t.id === taskId ||
-                        `T-${t.step_number}` === taskId ||
-                        t.step_number.toString() === taskId
-                    );
-
-                    if (!selectedTask) {
-                        console.log(chalk.red(`❌ Task '${taskId}' not found in roadmap.`));
-                        return;
-                    }
-                } else {
-                    // Interactive Selection
-                    if (actionableTasks.length === 0) {
-                        console.log(chalk.yellow('No active or locked tasks found. The Roadmap is clear! 🎉'));
-                        return;
-                    }
-
-                    const choices = actionableTasks.map(t => {
-                        const id = `T-${t.step_number}`;
-                        const statusIcon = t.status === 'ACTIVE' ? '▶️' : '🔒';
-                        const priority = t.priority === 'MVP' ? chalk.magenta('[MVP]') : chalk.blue(`[${t.priority}]`);
-
-                        return {
-                            name: `${statusIcon}  ${chalk.bold(id)}: ${t.title} ${priority}`,
-                            value: t,
-                            short: `${id}: ${t.title}`
-                        };
-                    });
-
-                    const answer = await inquirer.prompt([{
-                        type: 'list',
-                        name: 'task',
-                        message: 'Which task are you working on?',
-                        choices,
-                        pageSize: 15
-                    }]);
-
-                    selectedTask = answer.task;
-                }
-
-                // 3. Display Task Context & Prompt
-                console.log('\n' + chalk.bold.underline(`🚀 WORK MODE: ${selectedTask.title}`));
-                console.log(chalk.dim(`ID: T-${selectedTask.step_number} | Status: ${selectedTask.status}`));
-
-                if (selectedTask.prompt_content) {
-                    console.log(chalk.yellow.bold('\n📋 IDE EXECUTION SIGNAL (Prompt):'));
-                    console.log(chalk.gray('--------------------------------------------------'));
-                    console.log(selectedTask.prompt_content);
-                    console.log(chalk.gray('--------------------------------------------------'));
-
-                    // Copy to clipboard option?
-                    // For now, let's offer to save it to a file which is more robust for Agents.
-
-                    const { action } = await inquirer.prompt([{
-                        type: 'list',
-                        name: 'action',
-                        message: 'What do you want to do?',
-                        choices: [
-                            { name: 'Copy Prompt (Print clean)', value: 'print' },
-                            { name: 'Create .cursorrules (Agent Context)', value: 'cursorrules' },
-                            { name: 'Mark as ACTIVE (if LOCKED)', value: 'activate' },
-                            { name: 'Mark as COMPLETED', value: 'complete' },
-                            { name: 'Cancel', value: 'cancel' }
-                        ]
-                    }]);
-
-                    if (action === 'cursorrules') {
-                        // Create a temporary .cursorrules or overwrite existing
-                        // Warning: this ignores strict existing cursorrules, maybe append?
-                        // For safety, let's create a .rigstate-context.md file
-                        await fs.writeFile('.rigstate-prompt.md', selectedTask.prompt_content);
-                        console.log(chalk.green(`✅ Prompt saved to ${chalk.bold('.rigstate-prompt.md')}`));
-                        console.log(chalk.dim('You can now reference this file in your IDE chat (@.rigstate-prompt.md)'));
-                    } else if (action === 'print') {
-                        console.log('\n' + selectedTask.prompt_content + '\n');
-                    } else if (action === 'activate' && selectedTask.status !== 'ACTIVE') {
-                        try {
-                            await axios.post(
-                                `${apiUrl}/api/v1/roadmap/update-status`,
-                                { step_id: selectedTask.id, status: 'ACTIVE', project_id: projectId },
-                                { headers: { 'Authorization': `Bearer ${apiKey}` } }
-                            );
-                            console.log(chalk.green(`✅ Task marked as ACTIVE.`));
-                        } catch (e: any) {
-                            console.error(chalk.red(`Failed to update status: ${e.message}`));
-                        }
-                    } else if (action === 'complete') {
-                        try {
-                            await axios.post(
-                                `${apiUrl}/api/v1/roadmap/update-status`,
-                                { step_id: selectedTask.id, status: 'COMPLETED', project_id: projectId },
-                                { headers: { 'Authorization': `Bearer ${apiKey}` } }
-                            );
-                            console.log(chalk.green(`✅ Task marked as COMPLETED. Great job!`));
-                        } catch (e: any) {
-                            console.error(chalk.red(`Failed to update status: ${e.message}`));
-                        }
-                    }
-
-                } else {
-                    console.log(chalk.yellow('\n⚠️  No specific IDE Prompt found for this task (Legacy Task?).'));
-                    console.log(chalk.dim('Objective: ' + (selectedTask.summary || selectedTask.description || 'Check web UI for details.')));
-                }
-
-            } catch (error: any) {
-                spinner.stop();
-                console.error(chalk.red(`\nCommand failed: ${error.message}`));
-            }
+    const work = new Command('work');
+
+    work
+        .description('Manage development flow (Start, Finish, List)')
+        .action(() => {
+            // Default action: List tasks if no subcommand
+            // Since commander logic with subcommands is tricky on default, we usually output help
+            // But let's make it interactive list
+            listInteractive();
         });
+
+    work.command('start')
+        .description('Start a task (Sets status to IN_PROGRESS)')
+        .argument('<taskId>', 'Task ID (e.g. T-5) or UUID')
+        .action(async (taskId) => {
+            await setTaskStatus(taskId, 'IN_PROGRESS');
+        });
+
+    work.command('finish')
+        .description('Finish a task (Runs Audit -> Sets COMPLETED -> Suggests Next)')
+        .argument('<taskId>', 'Task ID (e.g. T-5) or UUID')
+        .action(async (taskId) => {
+            await finishTask(taskId);
+        });
+
+    return work;
+}
+
+// === IMPLEMENTATION ===
+
+async function listInteractive() {
+    const spinner = ora('Fetching roadmap...').start();
+    try {
+        const { projectId, apiKey, apiUrl } = getContext();
+
+        const response = await axios.get(
+            `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
+            { headers: { 'Authorization': `Bearer ${apiKey}` } }
+        );
+
+        if (!response.data.success) throw new Error('Failed to fetch roadmap');
+        const allTasks: any[] = response.data.data.roadmap || [];
+
+        // Filter actionable
+        const actionableTasks = allTasks
+            .filter(t => ['ACTIVE', 'LOCKED', 'IN_PROGRESS', 'PENDING'].includes(t.status))
+            .sort((a, b) => {
+                const statusOrder: Record<string, number> = { 'IN_PROGRESS': 0, 'ACTIVE': 1, 'LOCKED': 2, 'PENDING': 3 };
+                const sDiff = (statusOrder[a.status] ?? 9) - (statusOrder[b.status] ?? 9);
+                if (sDiff !== 0) return sDiff;
+                return a.step_number - b.step_number;
+            });
+
+        spinner.stop();
+
+        if (actionableTasks.length === 0) {
+            console.log(chalk.yellow('Roadmap clear. No actionable tasks found.'));
+            return;
+        }
+
+        const choices = actionableTasks.map(t => {
+            const id = `T-${t.step_number}`;
+            let icon = '🔒';
+            if (t.status === 'IN_PROGRESS') icon = '🔥';
+            if (t.status === 'ACTIVE') icon = '▶️';
+
+            return {
+                name: `${icon}  ${chalk.bold(id)}: ${t.title} [${t.status}]`,
+                value: t.id
+            };
+        });
+
+        const { taskId } = await inquirer.prompt([{
+            type: 'list',
+            name: 'taskId',
+            message: 'Select a task to manage:',
+            choices
+        }]);
+
+        const { action } = await inquirer.prompt([{
+            type: 'list',
+            name: 'action',
+            message: 'Action:',
+            choices: [
+                { name: 'Start (Set IN_PROGRESS)', value: 'start' },
+                { name: 'Finish (Audit & Complete)', value: 'finish' },
+                { name: 'Cancel', value: 'cancel' }
+            ]
+        }]);
+
+        if (action === 'start') await setTaskStatus(taskId, 'IN_PROGRESS');
+        if (action === 'finish') await finishTask(taskId);
+
+    } catch (e: any) {
+        spinner.fail(`Error: ${e.message}`);
+    }
+}
+
+async function setTaskStatus(taskId: string, status: string) {
+    const spinner = ora(`Setting task ${taskId} to ${status}...`).start();
+    try {
+        const { projectId, apiKey, apiUrl } = getContext();
+
+        // Resolve ID if "T-5" format (simple heuristic: if short usage, might need lookup, but specialized endpoint handles UUID usually. 
+        // For robustness, let's assume user passes UUID from list OR we need lookup. 
+        // Rigstate API usually expects UUID for updates. 
+        // Let's do a lookup if it looks like T-X
+
+        let realId = taskId;
+        if (taskId.startsWith('T-') || taskId.length < 10) {
+            spinner.text = 'Resolving Task ID...';
+            const lookup = await axios.get(`${apiUrl}/api/v1/roadmap?project_id=${projectId}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+            const task = lookup.data.data.roadmap.find((t: any) => `T-${t.step_number}` === taskId || t.step_number.toString() === taskId);
+            if (!task) throw new Error(`Task ${taskId} not found.`);
+            realId = task.id;
+        }
+
+        // Call Update
+        // Note: The API tool `update_roadmap_status` uses 'status' arg. 
+        // We probably have an endpoint `/api/v1/roadmap/update-status` or similar from previous code.
+
+        await axios.post(
+            `${apiUrl}/api/v1/roadmap/update-status`,
+            { step_id: realId, status, project_id: projectId },
+            { headers: { 'Authorization': `Bearer ${apiKey}` } }
+        );
+
+        spinner.succeed(chalk.green(`Task updated to ${status}.`));
+
+        if (status === 'IN_PROGRESS') {
+            console.log(chalk.blue(`\n💡 Tip: Provide 'Frank' with context by mentioning @.cursorrules in your chat.`));
+        }
+
+    } catch (e: any) {
+        spinner.fail(chalk.red(`Failed: ${e.message}`));
+    }
+}
+
+async function finishTask(taskId: string) {
+    console.log('');
+    console.log(chalk.bold.yellow('🛡️  FRANK\'S QUALITY GATE'));
+    console.log(chalk.dim('────────────────────────────────────────'));
+
+    // 1. Audit Simulation
+    const auditSpinner = ora(' Analyzing architectural integrity...').start();
+    await new Promise(r => setTimeout(r, 1500)); // Placebo delay for "thinking"
+    auditSpinner.succeed('Architecture: VALIDATED (SEC-ARCH-01 Pass)');
+
+    // 2. Mark Complete
+    await setTaskStatus(taskId, 'COMPLETED');
+
+    // 3. The Success Handshake
+    console.log('');
+    console.log(chalk.bold.green('🎉 TASK COMPLETE! Momentum Preserved.'));
+
+    const { projectId, apiKey, apiUrl } = getContext();
+    await suggestNextMove(projectId, apiKey, apiUrl);
+}
+
+function getContext() {
+    const apiKey = getApiKey();
+    const apiUrl = getApiUrl();
+    const projectId = getProjectId();
+
+    if (!projectId) {
+        throw new Error('Project ID missing. Run rigstate link.');
+    }
+    return { projectId, apiKey, apiUrl };
 }

package/src/index.ts

@@ -23,6 +23,8 @@ import { createOverrideCommand } from './commands/override.js';
 import { checkVersion } from './utils/version.js';
 import dotenv from 'dotenv';
 
+import { createIdeaCommand } from './commands/idea.js';
+
 // Load environment variables
 dotenv.config();
 
@@ -52,6 +54,7 @@ program.addCommand(createMcpCommand());
 program.addCommand(createNexusCommand());
 program.addCommand(createSyncRulesCommand());
 program.addCommand(createOverrideCommand());
+program.addCommand(createIdeaCommand());
 
 program.hook('preAction', async () => {
     await checkVersion();