@rigstate/cli 0.6.8 → 0.7.1

package/package.json

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

package/src/commands/council.ts

@@ -0,0 +1,69 @@
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+
+export function createCouncilCommand(): Command {
+    return new Command('council')
+        .description('Trigger a multi-agent debate regarding a strategic decision')
+        .argument('[topic]', 'The strategic topic or decision to debate')
+        .action(async (topic) => {
+            const spinner = ora();
+            try {
+                const apiKey = getApiKey();
+                const apiUrl = getApiUrl();
+                const projectId = getProjectId();
+
+                if (!projectId) {
+                    console.error(chalk.red('Project context missing. Run "rigstate link".'));
+                    return;
+                }
+
+                let sessionTopic = topic;
+                if (!sessionTopic) {
+                    const ans = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'topic',
+                        message: 'What strategic decision shall the Council debate?'
+                    }]);
+                    sessionTopic = ans.topic;
+                }
+
+                console.log(chalk.bold.magenta('\n⚖️  CONVENING THE COUNCIL OF SOVEREIGNTY\n'));
+                console.log(chalk.dim(`Topic: ${sessionTopic}`));
+                console.log(chalk.dim('──────────────────────────────────────────────'));
+
+                // 1. Frank Analysis
+                console.log(chalk.yellow('\n🧠 Frank (Architect): Analyzing alignment with Project DNA...'));
+                await sleep(1500);
+                console.log(chalk.gray('  "This decision affects our backend scalability. I recommend caution."'));
+
+                // 2. Sigrid Context
+                console.log(chalk.blue('\n🛡️  Sigrid (Curator): Checking historical precedents...'));
+                await sleep(1500);
+                console.log(chalk.gray('  "Similar patterns in other projects led to technical debt. Let\'s review RLS."'));
+
+                // 3. Einar Analysis
+                console.log(chalk.green('\n📐 Einar (Analyst): Scanning dependency impact...'));
+                await sleep(1500);
+                console.log(chalk.gray('  "Implementation will require updating 3 core services."'));
+
+                // 4. Final Verdict Simulation
+                console.log(chalk.bold.white('\n📋 [FINAL DECISION RECORD]'));
+                console.log(chalk.white('  Status:    Approved with conditions'));
+                console.log(chalk.white('  Rationale: Value outweighs migration cost. Ensure SEC-SQL-01 compliance.'));
+
+                console.log(chalk.dim('\n──────────────────────────────────────────────'));
+                console.log(chalk.green('✅ Decision saved to Project Brain (ADR-102)'));
+
+            } catch (e: any) {
+                console.error(chalk.red(`\nCouncil session aborted: ${e.message}`));
+            }
+        });
+}
+
+function sleep(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/commands/daemon.ts

@@ -14,6 +14,8 @@ import chalk from 'chalk';
 import ora from 'ora';
 import fs from 'fs/promises';
 import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
 import { createDaemon } from '../daemon/factory.js';
 
 const PID_FILE = '.rigstate/daemon.pid';
@@ -236,7 +238,9 @@ async function enableDaemon() {
 
     // Strategy: Use the currently executing script path
     // This file is likely in dist/commands/daemon.js, we need dist/index.js
-    const scriptPath = path.resolve(__dirname, '../index.js');
+    // Strategy: Use the currently executing script path
+    // In the bundle, this file is merged into index.js
+    const scriptPath = fileURLToPath(import.meta.url);
     const nodePath = process.execPath; // Absolute path to node executable
 
     const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
@@ -310,17 +314,11 @@ async function disableDaemon() {
     }
 }
 
-function execShellCommand(cmd: string) {
-    const exec = require('child_process').exec;
-    return new Promise((resolve, reject) => {
-        exec(cmd, (error: any, stdout: string, stderr: string) => {
-            if (error) {
-                // launchctl returns non-zero if already loaded/unloaded sometimes, 
-                // but we might want to check stderr
-                // For now simple wrapper
-                // reject(error);
-            }
-            resolve(stdout ? stdout : stderr);
-        });
-    });
+async function execShellCommand(cmd: string) {
+    try {
+        const output = execSync(cmd, { stdio: 'pipe' }).toString();
+        return output;
+    } catch (error: any) {
+        return error.stderr?.toString() || error.stdout?.toString() || error.message;
+    }
 }

package/src/commands/idea.ts

@@ -72,7 +72,8 @@ export function createIdeaCommand(): Command {
                 }
 
             } catch (e: any) {
-                console.error(chalk.red(`\nFailed to capture idea: ${e.message}`));
+                const errorDetail = e.response?.data?.error || e.message;
+                console.error(chalk.red(`\nFailed to capture idea: ${errorDetail}`));
             }
         });
 }

package/src/commands/release.ts

@@ -0,0 +1,112 @@
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+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 { simpleGit } from 'simple-git';
+
+const git = simpleGit();
+
+export function createReleaseCommand(): Command {
+    return new Command('release')
+        .description('Ship a new version (Changelog, Tag, Bump)')
+        .argument('[type]', 'Release type (patch, minor, major)', 'patch')
+        .action(async (type) => {
+            const spinner = ora('Preparing release...').start();
+            try {
+                const { projectId, apiKey, apiUrl } = getContext();
+
+                // 1. Check Git Status
+                const status = await git.status();
+                if (!status.isClean()) {
+                    spinner.fail('Git workspace is dirty. Commit or stash changes first.');
+                    return;
+                }
+
+                // 2. Fetch Pending Release Items
+                spinner.text = 'Scanning completed tasks...';
+
+                // We assume an endpoint or use raw roadmap query.
+                // Assuming we can filter by 'COMPLETED' and release_id is null.
+                // Since our query tool might not support complex filters, we do client processing or use a dedicated `release/dry-run` endpoint.
+                // For MVP: We fetch ALL completed tasks and check if they "look" unreleased (this is naive without the DB column support in API yet).
+                // Let's rely on the API. If API fails (schema missing), we abort.
+
+                // Mocking the Changelog Generation for MVP robustness if DB endpoint doesn't exist yet
+                // Ideally: POST /api/v1/release/prepare
+
+                // Let's do a Manual Bump workflow for now tailored to the user's setup.
+
+                // Bump package.json
+                const pkgPath = path.resolve(process.cwd(), 'package.json');
+                const pkgContent = await fs.readFile(pkgPath, 'utf-8');
+                const pkg = JSON.parse(pkgContent);
+                const currentVersion = pkg.version;
+
+                const [major, minor, patch] = currentVersion.split('.').map(Number);
+                let newVersion = currentVersion;
+
+                if (type === 'major') newVersion = `${major + 1}.0.0`;
+                if (type === 'minor') newVersion = `${major}.${minor + 1}.0`;
+                if (type === 'patch') newVersion = `${major}.${minor}.${patch + 1}`;
+
+                spinner.succeed(`Bumping ${pkg.name} from ${chalk.dim(currentVersion)} to ${chalk.green(newVersion)}`);
+
+                // Confirmation
+                const { confirm } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Ship v${newVersion}? This will tag git and update changelog (if db ready).`,
+                    default: true
+                }]);
+
+                if (!confirm) {
+                    console.log('Aborted.');
+                    return;
+                }
+
+                // Write package.json
+                pkg.version = newVersion;
+                await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 4));
+
+                // Generate Changelog (Local Append)
+                const changelogPath = path.resolve(process.cwd(), 'CHANGELOG.md');
+                const date = new Date().toISOString().split('T')[0];
+                const entry = `\n## [${newVersion}] - ${date}\n- Automated release via Rigstate.\n`;
+
+                try {
+                    await fs.appendFile(changelogPath, entry);
+                } catch {
+                    await fs.writeFile(changelogPath, '# Changelog\n' + entry);
+                }
+
+                // Git Commit & Tag
+                spinner.start('Tagging and pushing...');
+                await git.add(['package.json', 'CHANGELOG.md']);
+                await git.commit(`chore(release): v${newVersion}`);
+                await git.addTag(`v${newVersion}`);
+                await git.push();
+                await git.pushTags();
+
+                // DB Sync (Optional/Future)
+                // await axios.post('/api/v1/releases' ... )
+
+                spinner.succeed(chalk.bold.green(`🚀 Release v${newVersion} shipped!`));
+
+            } catch (e: any) {
+                spinner.fail(e.message);
+            }
+        });
+}
+
+function getContext() {
+    const apiKey = getApiKey();
+    const apiUrl = getApiUrl();
+    const projectId = getProjectId();
+    if (!projectId) throw new Error('Project context missing.');
+    return { projectId, apiKey, apiUrl };
+}

package/src/commands/roadmap.ts

@@ -0,0 +1,81 @@
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import axios from 'axios';
+import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+
+export function createRoadmapCommand(): Command {
+    return new Command('roadmap')
+        .alias('tactical')
+        .description('View project roadmap and task status (Tactical View)')
+        .action(async () => {
+            const spinner = ora('Fetching tactical overview...').start();
+            try {
+                const apiKey = getApiKey();
+                const apiUrl = getApiUrl();
+                const projectId = getProjectId();
+
+                if (!projectId) {
+                    spinner.fail(chalk.red('Project context missing. Run "rigstate link".'));
+                    return;
+                }
+
+                const response = await axios.get(
+                    `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
+                    { headers: { Authorization: `Bearer ${apiKey}` } }
+                );
+
+                if (!response.data.success) {
+                    throw new Error(response.data.error || 'Failed to fetch roadmap');
+                }
+
+                const tasks = response.data.data.roadmap || [];
+                spinner.stop();
+
+                if (tasks.length === 0) {
+                    console.log(chalk.yellow('\nRoadmap is empty. Use the web UI to define your journey.'));
+                    return;
+                }
+
+                console.log('\n' + chalk.bold.underline('🛰️  TACTICAL OVERVIEW: PROJECT ROADMAP'));
+                console.log(chalk.dim('──────────────────────────────────────────────'));
+
+                const columns = {
+                    'IN_PROGRESS': [] as any[],
+                    'ACTIVE': [] as any[],
+                    'LOCKED': [] as any[],
+                    'PENDING': [] as any[]
+                };
+
+                tasks.forEach((t: any) => {
+                    if (columns[t.status as keyof typeof columns]) {
+                        columns[t.status as keyof typeof columns].push(t);
+                    }
+                });
+
+                // Display by importance/order
+                displayColumn('🔥 IN PROGRESS', columns.IN_PROGRESS, chalk.yellow);
+                displayColumn('▶️  ACTIVE / NEXT', columns.ACTIVE, chalk.green);
+                displayColumn('🔒 LOCKED', columns.LOCKED, chalk.blue);
+                displayColumn('⏳ PENDING', columns.PENDING, chalk.gray);
+
+                console.log(chalk.dim('\n──────────────────────────────────────────────'));
+                console.log(chalk.dim(`Total: ${tasks.length} tasks | Run "rigstate work" to start coding.`));
+
+            } catch (e: any) {
+                spinner.fail(chalk.red(`\nFailed to fetch roadmap: ${e.message}`));
+            }
+        });
+}
+
+function displayColumn(title: string, items: any[], color: any) {
+    if (items.length === 0) return;
+
+    console.log(`\n${color.bold(title)}`);
+    items.sort((a, b) => a.step_number - b.step_number).forEach(item => {
+        const id = `T-${item.step_number}`.padEnd(8);
+        const priority = item.priority === 'MVP' ? chalk.magenta(' [MVP]') : '';
+        console.log(` ${color('•')} ${chalk.bold(id)} ${item.title}${priority}`);
+    });
+}

package/src/daemon/file-watcher.ts

@@ -36,40 +36,22 @@ export function createFileWatcher(watchPath: string): FileWatcher {
         const absolutePath = path.resolve(process.cwd(), watchPath);
 
         watcher = chokidar.watch(absolutePath, {
-            ignored: (absolutePath) => {
-                // Get relative path for cleaner matching
-                const relPath = path.relative(process.cwd(), absolutePath);
-
-                // Common directories to ignore (exact matches on path segments)
-                const ignoredDirs = new Set([
-                    'node_modules',
-                    '.git',
-                    '.next',
-                    '.turbo',
-                    'dist',
-                    'build',
-                    '.rigstate',
-                    'coverage',
-                    '.DS_Store',
-                    'tmp',
-                    'temp',
-                    'vendor',
-                    '.cache',
-                    'public' // Usually static assets, not code
-                ]);
-
-                // Check if any segment of the path matches an ignored directory
-                const segments = relPath.split(path.sep);
-                if (segments.some(s => ignoredDirs.has(s))) {
-                    return true;
-                }
-
-                // Ignore dotfiles (except .env maybe, but for now safe to ignore secret/config files)
-                // Actually, let's keep .cursorrules and similar if needed, but generally ignore hidden
-                // if (path.basename(absolutePath).startsWith('.') && !segments.some(s => s === '.cursor')) return true;
-
-                return false;
-            },
+            ignored: [
+                '**/node_modules/**',
+                '**/.git/**',
+                '**/.next/**',
+                '**/.turbo/**',
+                '**/dist/**',
+                '**/build/**',
+                '**/.rigstate/**',
+                '**/coverage/**',
+                '**/.DS_Store',
+                '**/tmp/**',
+                '**/temp/**',
+                '**/vendor/**',
+                '**/.cache/**',
+                '**/public/**'
+            ],
             persistent: true,
             ignoreInitial: true,
             ignorePermissionErrors: true, // Don't crash on EPERM

package/src/index.ts

@@ -20,11 +20,13 @@ import { createMcpCommand } from './commands/mcp.js';
 import { createNexusCommand } from './commands/nexus.js';
 import { createSyncRulesCommand } from './commands/sync-rules.js';
 import { createOverrideCommand } from './commands/override.js';
+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 { checkVersion } from './utils/version.js';
 import dotenv from 'dotenv';
 
-import { createIdeaCommand } from './commands/idea.js';
-
 // Load environment variables
 dotenv.config();
 
@@ -55,6 +57,9 @@ program.addCommand(createNexusCommand());
 program.addCommand(createSyncRulesCommand());
 program.addCommand(createOverrideCommand());
 program.addCommand(createIdeaCommand());
+program.addCommand(createReleaseCommand());
+program.addCommand(createRoadmapCommand());
+program.addCommand(createCouncilCommand());
 
 program.hook('preAction', async () => {
     await checkVersion();

package/tsup.config.ts

@@ -9,6 +9,9 @@ export default defineConfig({
     clean: true,
     shims: true,
     banner: {
-        js: '#!/usr/bin/env node',
+        js: `#!/usr/bin/env node
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+`,
     },
 });