@rigstate/cli 0.7.26 → 0.7.30

package/package.json

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

package/src/commands/link.ts

@@ -9,9 +9,9 @@ import { getApiUrl, getApiKey } from '../utils/config.js';
 export function createLinkCommand() {
     return new Command('link')
         .description('Link current directory to a Rigstate project')
-        .argument('<projectId>', 'Project ID to link')
+        .argument('[projectId]', 'Project ID to link')
         .action(async (projectId) => {
-            // Check Global Override (Rigstate v2.7)
+            // Check Global Override first
             try {
                 const globalPath = path.join(os.homedir(), '.rigstate', 'config.json');
                 const globalData = await fs.readFile(globalPath, 'utf-8').catch(() => null);
@@ -20,14 +20,60 @@ export function createLinkCommand() {
                     const cwd = process.cwd();
                     if (config.overrides && config.overrides[cwd]) {
                         const overrideId = config.overrides[cwd];
-                        if (overrideId !== projectId) {
-                            console.warn(chalk.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
+                        console.warn(chalk.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
+                        if (!projectId) projectId = overrideId;
+                        else if (projectId !== overrideId) {
+                            console.warn(chalk.red(`Ignoring provided ID ${projectId}. Using override.`));
                             projectId = overrideId;
                         }
                     }
                 }
             } catch (e) { }
 
+            // Interactive Selection if no ID
+            if (!projectId) {
+                try {
+                    const inquirer = (await import('inquirer')).default;
+                    const { getApiKey: _getApiKey, getApiUrl: _getApiUrl } = await import('../utils/config.js');
+                    const apiKey = getApiKey();
+                    const apiUrl = getApiUrl();
+
+                    if (!apiKey) {
+                        console.error(chalk.red('Not authenticated. Please run "rigstate login" or provide a Project ID.'));
+                        process.exit(1);
+                    }
+
+                    console.log(chalk.dim('Fetching your projects...'));
+                    const axios = (await import('axios')).default;
+                    const response = await axios.get(`${apiUrl}/api/v1/projects`, {
+                        headers: { Authorization: `Bearer ${apiKey}` }
+                    });
+
+                    if (!response.data.success || !response.data.data.projects?.length) {
+                        console.error(chalk.yellow('No projects found. Create one at https://app.rigstate.com'));
+                        process.exit(1);
+                    }
+
+                    const choices = response.data.data.projects.map((p: any) => ({
+                        name: `${p.name} (${p.id})`,
+                        value: p.id
+                    }));
+
+                    const answer = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'id',
+                        message: 'Select project to link:',
+                        choices
+                    }]);
+                    projectId = answer.id;
+
+                } catch (e: any) {
+                    console.error(chalk.red(`Failed to fetch projects: ${e.message}`));
+                    console.error('Please provide project ID manually: rigstate link <id>');
+                    process.exit(1);
+                }
+            }
+
             const manifestPath = path.join(process.cwd(), '.rigstate');
 
             const content: any = {
@@ -42,6 +88,9 @@ export function createLinkCommand() {
             }
 
             try {
+                // Ensure .rigstate dir exists
+                await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+
                 await fs.writeFile(manifestPath, JSON.stringify(content, null, 2), 'utf-8');
                 console.log(chalk.green(`✔ Linked to project ID: ${projectId}`));
                 console.log(chalk.dim(`Created local context manifest at .rigstate`));
@@ -52,7 +101,7 @@ export function createLinkCommand() {
                 console.log('');
 
                 const { getApiKey: _getApiKey, getApiUrl: _getApiUrl } = await import('../utils/config.js');
-                const apiKey = getApiKey(); // Might throw if not logged in
+                const apiKey = getApiKey();
                 const apiUrl = getApiUrl();
 
                 if (apiKey) {
@@ -67,19 +116,14 @@ export function createLinkCommand() {
                     await syncProjectRules(projectId, apiKey, apiUrl);
 
                     // 3. Git Hooks (Auto-Vaccine)
-                    console.log(chalk.blue('🛡️  Injecting Guardian hooks...'));
-                    const { createHooksCommand } = await import('./hooks.js');
-                    // We can't easily invoke the command action directly without refactoring, 
-                    // but we can reuse the logic. For now, let's replicate the simple install logic
-                    // or better yet, make a shared utility.
-                    // Actually, the simplest way for v0.7.25 is to call the install logic directly if possible.
-                    // Let's use the helper function at the bottom of this file which I see exists.
+                    console.log(chalk.blue('🛡️  Injecting Guardian hooks & Safety nets...'));
                     await installHooks(process.cwd());
+                    await hardenGitIgnore(process.cwd());
 
                     console.log('');
                     console.log(chalk.bold.green('🚀 Link Complete! Your environment is ready.'));
 
-                    // 4. Tactical Suggestion (The First Move)
+                    // 4. Tactical Suggestion
                     const { suggestNextMove } = await import('./suggest.js');
                     await suggestNextMove(projectId, apiKey, apiUrl);
                 } else {
@@ -88,7 +132,7 @@ export function createLinkCommand() {
                 }
 
             } catch (error: any) {
-                if (error.message.includes('Not authenticated')) {
+                if (error.message?.includes('Not authenticated')) {
                     console.warn(chalk.yellow('⚠️  Not authenticated. Run "rigstate login" to enable automation features.'));
                 } else {
                     console.error(chalk.red(`Failed to link project: ${error.message}`));
@@ -97,6 +141,47 @@ export function createLinkCommand() {
         });
 }
 
+async function hardenGitIgnore(cwd: string) {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const ignorePath = path.join(cwd, '.gitignore');
+
+    const REQUIRED_IGNORES = [
+        '# Rigstate - Runtime Artifacts (Do not commit)',
+        '.rigstate/ACTIVE_VIOLATIONS.md',
+        '.rigstate/CURRENT_CONTEXT.md',
+        '.rigstate/daemon.pid',
+        '.rigstate/daemon.state.json',
+        '.rigstate/*.log',
+        '.rigstate/*.bak',
+        '# Keep identity tracked',
+        '!.rigstate/identity.json'
+    ];
+
+    try {
+        let content = '';
+        try {
+            content = await fs.readFile(ignorePath, 'utf-8');
+        } catch {
+            // No .gitignore, start fresh
+            content = '';
+        }
+
+        const missing = REQUIRED_IGNORES.filter(line => !content.includes(line) && !line.startsWith('#'));
+
+        if (missing.length > 0) {
+            console.log(chalk.dim('   Configuring .gitignore for Rigstate safety...'));
+            const toAppend = '\n\n' + REQUIRED_IGNORES.join('\n') + '\n';
+            await fs.writeFile(ignorePath, content + toAppend, 'utf-8');
+            console.log(chalk.green('   ✔ .gitignore updated (Artifacts protected)'));
+        } else {
+            console.log(chalk.green('   ✔ .gitignore already hardened'));
+        }
+    } catch (e: any) {
+        console.warn(chalk.yellow(`   Could not update .gitignore: ${e.message}`));
+    }
+}
+
 async function installHooks(cwd: string) {
     const fs = await import('fs/promises');
     const path = await import('path');

package/src/commands/plan.ts

@@ -0,0 +1,165 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import axios from 'axios';
+import fs from 'fs/promises';
+import path from 'path';
+import inquirer from 'inquirer';
+import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+
+export function createPlanCommand(): Command {
+    const plan = new Command('plan');
+
+    plan
+        .description('Generate an implementation plan for a roadmap task')
+        .argument('[taskId]', 'Task ID (e.g. T-10) or UUID')
+        .action(async (taskId) => {
+            await executePlan(taskId);
+        });
+
+    return plan;
+}
+
+export async function executePlan(taskId?: string) {
+    const spinner = ora('Initializing Planning Mode...').start();
+
+    try {
+        const { projectId, apiKey, apiUrl } = getContext();
+
+        // 1. Resolve Task ID if missing or short
+        let realId = taskId;
+        let taskTitle = '';
+        let taskDescription = '';
+
+        if (!taskId) {
+            spinner.text = 'Fetching actionable tasks...';
+            // Interactive selection
+            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 tasks: any[] = response.data.data.roadmap || [];
+
+            const choices = tasks
+                .filter(t => ['ACTIVE', 'IN_PROGRESS', 'PENDING'].includes(t.status))
+                .map(t => ({
+                    name: `T-${t.step_number}: ${t.title}`,
+                    value: t
+                }));
+
+            if (choices.length === 0) {
+                spinner.fail('No actionable tasks found in roadmap.');
+                return;
+            }
+
+            spinner.stop();
+            const answer = await inquirer.prompt([{
+                type: 'list',
+                name: 'task',
+                message: 'Select a task to plan:',
+                choices
+            }]);
+
+            realId = answer.task.id;
+            taskTitle = answer.task.title;
+            taskDescription = answer.task.description;
+            taskId = `T-${answer.task.step_number}`;
+        } else {
+            // Fetch specific task details
+            spinner.text = `Fetching details for ${taskId}...`;
+            const response = await axios.get(
+                `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
+                { headers: { 'Authorization': `Bearer ${apiKey}` } }
+            );
+            const task = response.data.data.roadmap.find((t: any) =>
+                t.id === taskId ||
+                `T-${t.step_number}` === taskId ||
+                t.step_number.toString() === taskId
+            );
+
+            if (!task) throw new Error(`Task ${taskId} not found.`);
+            realId = task.id;
+            taskTitle = task.title;
+            taskDescription = task.description;
+        }
+
+        // 2. Generate Context File
+        spinner.start('Generating Context for Frank...');
+        const contextPath = path.join(process.cwd(), '.rigstate', 'CURRENT_CONTEXT.md');
+        const contextContent = `
+# 🎯 Active Mission: ${taskTitle}
+**ID:** ${taskId}
+
+## 📝 Description
+${taskDescription}
+
+## 🛡️ Architectural Constraints
+- Follow strictly the rules in .cursor/rules/
+- Ensure zero violations in ACTIVE_VIOLATIONS.md
+- Update IMPLEMENTATION_PLAN.md before writing code.
+
+*Generated by Rigstate CLI at ${new Date().toLocaleString()}*
+`;
+        await fs.mkdir(path.dirname(contextPath), { recursive: true });
+        await fs.writeFile(contextPath, contextContent.trim());
+
+        // 3. Generate Plan Template
+        const planPath = path.join(process.cwd(), 'IMPLEMENTATION_PLAN.md');
+        const planExists = await fs.stat(planPath).then(() => true).catch(() => false);
+
+        if (!planExists) {
+            const planTemplate = `
+# 📋 Implementation Plan: ${taskTitle}
+
+## 1. 🔍 Analysis
+- [ ] Understand the requirements in .rigstate/CURRENT_CONTEXT.md
+- [ ] Check for existing architectural patterns
+
+## 2. 🏗️ Proposed Changes
+[Frank: List the files you intend to modify and the nature of the changes]
+
+## 3. ✅ Verification
+- [ ] Run tests
+- [ ] Verification Step 1...
+
+## 4. 🚀 Execution
+[Frank: Log your progress here]
+`;
+            await fs.writeFile(planPath, planTemplate.trim());
+            spinner.succeed(chalk.green('Created new IMPLEMENTATION_PLAN.md'));
+        } else {
+            spinner.info(chalk.yellow('IMPLEMENTATION_PLAN.md already exists. Preserving it.'));
+            // Optionally append or just leave it
+        }
+
+        // 4. Update Status (Optional - maybe set to IN_PROGRESS?)
+        // For now, let's keep it pure planning.
+
+        console.log('');
+        console.log(chalk.bold.blue('🚀 Planning Mode Activated'));
+        console.log(chalk.dim('────────────────────────────────────────'));
+        console.log(`1. Context loaded into: ${chalk.bold('.rigstate/CURRENT_CONTEXT.md')}`);
+        console.log(`2. Plan template ready: ${chalk.bold('IMPLEMENTATION_PLAN.md')}`);
+        console.log('');
+        console.log(chalk.yellow('👉 NEXT STEP:'));
+        console.log(`   Open ${chalk.bold('IMPLEMENTATION_PLAN.md')} in your IDE.`);
+        console.log(`   Tell Frank: ${chalk.italic('"Read the context and draft the plan."')}`);
+        console.log('');
+
+    } catch (e: any) {
+        spinner.fail(chalk.red(`Planning failed: ${e.message}`));
+    }
+}
+
+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/commands/work.ts

@@ -6,6 +6,7 @@ import inquirer from 'inquirer';
 import fs from 'fs/promises';
 import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
 import { suggestNextMove } from './suggest.js';
+import { executePlan } from './plan.js';
 
 export function createWorkCommand(): Command {
     const work = new Command('work');
@@ -92,12 +93,17 @@ async function listInteractive() {
             name: 'action',
             message: 'Action:',
             choices: [
+                { name: 'Plan (Draft Blueprint - RECOMMENDED)', value: 'plan' },
                 { name: 'Start (Set IN_PROGRESS)', value: 'start' },
                 { name: 'Finish (Audit & Complete)', value: 'finish' },
                 { name: 'Cancel', value: 'cancel' }
             ]
         }]);
 
+        if (action === 'plan') {
+            await executePlan(taskId);
+            // After planning, maybe ask to start? For now, just exit as plan command does sufficient logging.
+        }
         if (action === 'start') await setTaskStatus(taskId, 'IN_PROGRESS');
         if (action === 'finish') await finishTask(taskId);
 

package/src/index.ts

@@ -22,6 +22,7 @@ import { createIdeaCommand } from './commands/idea.js';
 import { createReleaseCommand } from './commands/release.js';
 import { createRoadmapCommand } from './commands/roadmap.js';
 import { createCouncilCommand } from './commands/council.js';
+import { createPlanCommand } from './commands/plan.js';
 import { checkVersion } from './utils/version.js';
 import dotenv from 'dotenv';
 
@@ -61,6 +62,7 @@ program.addCommand(createIdeaCommand());
 program.addCommand(createReleaseCommand());
 program.addCommand(createRoadmapCommand());
 program.addCommand(createCouncilCommand());
+program.addCommand(createPlanCommand());
 
 program.hook('preAction', async () => {
     await checkVersion();