@rigstate/cli 0.7.32 → 0.7.35

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rigstate/cli",
-    "version": "0.7.32",
+    "version": "0.7.35",
     "description": "Rigstate CLI - Code audit, sync and supervision tool",
     "type": "module",
     "main": "./dist/index.js",
@@ -50,4 +50,4 @@
     ],
     "author": "Rigstate",
     "license": "MIT"
-}
+}

package/src/commands/env.ts

@@ -141,12 +141,9 @@ export function createEnvPullCommand() {
             projectId = getProjectId();
 
             if (!projectId) {
-                try {
-                    const manifestPath = path.join(process.cwd(), '.rigstate');
-                    const content = await fs.readFile(manifestPath, 'utf-8');
-                    const manifest = JSON.parse(content);
-                    projectId = manifest.project_id;
-                } catch (e) { }
+                const { loadManifest } = await import('../utils/manifest.js');
+                const manifest = await loadManifest();
+                if (manifest?.project_id) projectId = manifest.project_id;
             }
 
             if (!projectId) {

package/src/commands/focus.ts

@@ -30,12 +30,9 @@ export function createFocusCommand() {
 
             projectId = getProjectId();
             if (!projectId) {
-                try {
-                    const manifestPath = path.join(process.cwd(), '.rigstate');
-                    const content = await fs.readFile(manifestPath, 'utf-8');
-                    const manifest = JSON.parse(content);
-                    projectId = manifest.project_id;
-                } catch (e) { }
+                const { loadManifest } = await import('../utils/manifest.js');
+                const manifest = await loadManifest();
+                if (manifest?.project_id) projectId = manifest.project_id;
             }
 
             if (!projectId) {

package/src/commands/init.ts

@@ -181,13 +181,12 @@ export function createInitCommand() {
                 setProjectId(projectId);
 
                 // Write local manifest
-                const manifestPath = path.join(process.cwd(), '.rigstate');
-                const manifestContent = {
+                const { saveManifest } = await import('../utils/manifest.js');
+                await saveManifest({
                     project_id: projectId,
-                    last_linked: new Date().toISOString(),
+                    linked_at: new Date().toISOString(),
                     api_url: apiUrl
-                };
-                await fs.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), 'utf-8');
+                });
 
                 // Initialize git if needed
                 try {

package/src/commands/link.ts

@@ -74,33 +74,23 @@ export function createLinkCommand() {
                 }
             }
 
-            const manifestPath = path.join(process.cwd(), '.rigstate');
-
-            const content: any = {
-                project_id: projectId,
-                linked_at: new Date().toISOString()
-            };
-
-            // Only store api_url locally if it's NOT the production default
-            const currentUrl = getApiUrl();
-            if (currentUrl !== 'https://app.rigstate.com') {
-                content.api_url = currentUrl;
-            }
-
+            const cwd = process.cwd();
             try {
-                // Ensure .rigstate dir exists
-                await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+                const { saveManifest } = await import('../utils/manifest.js');
+                const targetFile = await saveManifest({
+                    project_id: projectId,
+                    linked_at: new Date().toISOString(),
+                    api_url: getApiUrl() !== 'https://app.rigstate.com' ? getApiUrl() : undefined
+                });
 
-                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`));
+                console.log(chalk.dim(`Created local identity manifest at ${path.relative(cwd, targetFile)}`));
 
                 // === SMART AUTOMATION ===
                 console.log('');
                 console.log(chalk.bold('🤖 Rigstate Automation Detected'));
                 console.log('');
 
-                const { getApiKey: _getApiKey, getApiUrl: _getApiUrl } = await import('../utils/config.js');
                 const apiKey = getApiKey();
                 const apiUrl = getApiUrl();
 

package/src/commands/plan.ts

@@ -137,15 +137,32 @@ ${taskDescription}
         // 4. Update Status (Optional - maybe set to IN_PROGRESS?)
         // For now, let's keep it pure planning.
 
+        // 4. Trigger Bridge Task (Autonomous Bridge)
+        try {
+            spinner.start('📡 Signaling Frank to start drafting...');
+            await axios.post(`${apiUrl}/api/v1/agent/bridge`, {
+                project_id: projectId,
+                task_id: realId,
+                status: 'APPROVED',
+                proposal: `draft_plan:${taskId}`,
+                summary: `Requesting implementation plan for ${taskTitle}`
+            }, {
+                headers: { 'Authorization': `Bearer ${apiKey}` }
+            });
+            spinner.succeed('Signal sent to Agent Bridge.');
+        } catch (e) {
+            spinner.info(chalk.dim('Agent Bridge signal skipped (non-critical).'));
+        }
+
         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(chalk.green('✨ FRANK IS ON IT!'));
+        console.log(chalk.dim('   He has received the bridge signal and will begin drafting shortly.'));
+        console.log(chalk.dim('   No further manual steps required once he wakes up.'));
         console.log('');
 
     } catch (e: any) {

package/src/commands/sync-rules.ts

@@ -3,8 +3,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { getApiKey, getApiUrl } from '../utils/config.js';
 import axios from 'axios';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
+import { CLI_VERSION } from '../utils/version.js';
 
 interface SyncResult {
     projectId: string;
@@ -14,7 +13,7 @@ interface SyncResult {
 }
 
 // Core Logic (Exported for re-use)
-export async function syncProjectRules(projectId: string, apiKey: string, apiUrl: string, dryRun = false): Promise<boolean> {
+export async function syncProjectRules(projectId: string, apiKey: string, apiUrl: string, dryRun = false, version: string = CLI_VERSION): Promise<boolean> {
     const spinner = ora('🛡️ Frank Protocol: Initializing retroactive sync...').start();
     let success = true;
 
@@ -87,7 +86,7 @@ export async function syncProjectRules(projectId: string, apiKey: string, apiUrl
 
                     const governanceBlock = `${START_MARKER}
 # 🛡️ Rigstate Governance (Do not edit this block manually)
-# The following rules are enforced by the Rigstate Daemon (v${require('../../package.json').version}).
+# The following rules are enforced by the Rigstate Daemon (v${version}).
 # Failure to adhere to these rules will be flagged during the 'work' cycle.
 
 # YOU MUST ADHERE TO THESE PROACTIVE RULES:

package/src/commands/sync.ts

@@ -30,12 +30,9 @@ export function createSyncCommand() {
 
                 // Check local .rigstate manifest
                 if (!projectId) {
-                    try {
-                        const manifestPath = path.join(process.cwd(), '.rigstate');
-                        const manifestContent = await fs.readFile(manifestPath, 'utf-8');
-                        const manifest = JSON.parse(manifestContent);
-                        if (manifest.project_id) projectId = manifest.project_id;
-                    } catch (e) { }
+                    const { loadManifest } = await import('../utils/manifest.js');
+                    const manifest = await loadManifest();
+                    if (manifest?.project_id) projectId = manifest.project_id;
                 }
 
                 // Check global config
@@ -79,14 +76,12 @@ export function createSyncCommand() {
 
                 // 4b. Write Context Manifest (.rigstate) - CONTEXT GUARD
                 try {
-                    const manifestPath = path.join(process.cwd(), '.rigstate');
-                    const manifestContent = {
+                    const { saveManifest } = await import('../utils/manifest.js');
+                    await saveManifest({
                         project_id: projectId,
-                        project_name: project,
-                        last_synced: timestamp,
+                        linked_at: timestamp, // Using timestamp as linked_at for consistency
                         api_url: apiUrl
-                    };
-                    await fs.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), 'utf-8');
+                    });
                 } catch (e) {
                     // Fail silently
                 }

package/src/commands/watch.ts

@@ -42,13 +42,9 @@ export function createWatchCommand() {
 
             projectId = getProjectId();
             if (!projectId) {
-                // Try to read from local manifest
-                try {
-                    const manifestPath = path.join(process.cwd(), '.rigstate');
-                    const content = await fs.readFile(manifestPath, 'utf-8');
-                    const manifest = JSON.parse(content);
-                    projectId = manifest.project_id;
-                } catch (e) { }
+                const { loadManifest } = await import('../utils/manifest.js');
+                const manifest = await loadManifest();
+                if (manifest?.project_id) projectId = manifest.project_id;
             }
 
             if (!projectId) {

package/src/utils/config.ts

@@ -1,6 +1,8 @@
 import Conf from 'conf';
 import axios from 'axios';
 import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
 
 interface RigstateConfig {
     apiKey?: string;
@@ -20,6 +22,29 @@ const config = new Conf<RigstateConfig>({
  * @throws {Error} If no API key is found (user not logged in)
  */
 export function getApiKey(): string {
+    // 1. Check local manifest first (Folder Affinity)
+    try {
+        const cwd = process.cwd();
+        const manifestPaths = [
+            path.join(cwd, '.rigstate', 'identity.json'),
+            path.join(cwd, '.rigstate')
+        ];
+
+        for (const manifestPath of manifestPaths) {
+            if (fs.existsSync(manifestPath) && fs.statSync(manifestPath).isFile()) {
+                const content = fs.readFileSync(manifestPath, 'utf-8');
+                const manifest = JSON.parse(content);
+                if (manifest.api_key) return manifest.api_key;
+            }
+        }
+    } catch (e) { /* Fallback */ }
+
+    // 2. Check environment variable
+    if (process.env.RIGSTATE_API_KEY) {
+        return process.env.RIGSTATE_API_KEY;
+    }
+
+    // 3. Fall back to global config
     const apiKey = config.get('apiKey');
     if (!apiKey) {
         throw new Error(
@@ -40,7 +65,40 @@ export function setApiKey(key: string): void {
  * Get the default project ID (if set)
  */
 export function getProjectId(): string | undefined {
-    return config.get('projectId');
+    // 1. Check local manifest first (Folder Affinity)
+    try {
+        const cwd = process.cwd();
+        const manifestPaths = [
+            path.join(cwd, '.rigstate', 'identity.json'),
+            path.join(cwd, '.rigstate')
+        ];
+
+        for (const manifestPath of manifestPaths) {
+            if (fs.existsSync(manifestPath) && fs.statSync(manifestPath).isFile()) {
+                const content = fs.readFileSync(manifestPath, 'utf-8');
+                const manifest = JSON.parse(content);
+                if (manifest.project_id) {
+                    console.log(chalk.dim(`   [Auth] Context: Project ID ${manifest.project_id.substring(0, 8)}... (from ${path.basename(manifestPath)})`));
+                    return manifest.project_id;
+                }
+            }
+        }
+    } catch (e: any) {
+        console.log(chalk.red(`   [Error] Failed to read context: ${e.message}`));
+    }
+
+    // 2. Check environment variable
+    if (process.env.RIGSTATE_PROJECT_ID) {
+        console.log(chalk.dim(`   [Auth] Context: Project ID ${process.env.RIGSTATE_PROJECT_ID.substring(0, 8)}... (from ENV)`));
+        return process.env.RIGSTATE_PROJECT_ID;
+    }
+
+    // 3. Fall back to global config
+    const globalId = config.get('projectId');
+    if (globalId) {
+        console.log(chalk.dim(`   [Auth] Context: Project ID ${globalId.substring(0, 8)}... (from GLOBAL CONFIG)`));
+    }
+    return globalId;
 }
 
 /**
@@ -55,16 +113,33 @@ export function setProjectId(projectId: string): void {
  * Priority: Environment variable > Stored config > Production default
  */
 export function getApiUrl(): string {
-    // 1. Check environment variable first
+    // 1. Check local manifest first
+    try {
+        const cwd = process.cwd();
+        const manifestPaths = [
+            path.join(cwd, '.rigstate', 'identity.json'),
+            path.join(cwd, '.rigstate')
+        ];
+
+        for (const manifestPath of manifestPaths) {
+            if (fs.existsSync(manifestPath) && fs.statSync(manifestPath).isFile()) {
+                const content = fs.readFileSync(manifestPath, 'utf-8');
+                const manifest = JSON.parse(content);
+                if (manifest.api_url) return manifest.api_url;
+            }
+        }
+    } catch (e) { /* Fallback */ }
+
+    // 2. Check environment variable next
     if (process.env.RIGSTATE_API_URL) {
         return process.env.RIGSTATE_API_URL;
     }
-    // 2. Check stored config
+    // 3. Check stored config
     const storedUrl = config.get('apiUrl');
     if (storedUrl) {
         return storedUrl;
     }
-    // 3. Default to production
+    // 4. Default to production
     return 'https://app.rigstate.com';
 }
 

package/src/utils/manifest.ts

@@ -1,18 +1,69 @@
 import fs from 'fs/promises';
+import fsSync from 'fs';
 import path from 'path';
 
 export interface RigstateManifest {
     project_id: string;
     api_url?: string;
     linked_at?: string;
+    api_key?: string;
 }
 
 export async function loadManifest(): Promise<RigstateManifest | null> {
+    const cwd = process.cwd();
+    const manifestPaths = [
+        path.join(cwd, '.rigstate', 'identity.json'),
+        path.join(cwd, '.rigstate')
+    ];
+
+    for (const p of manifestPaths) {
+        try {
+            if (fsSync.existsSync(p) && fsSync.statSync(p).isFile()) {
+                const content = await fs.readFile(p, 'utf-8');
+                const data = JSON.parse(content);
+
+                // Handle both flat manifest and identity.json schema
+                return {
+                    project_id: data.project?.id || data.project_id,
+                    api_url: data.api_url,
+                    linked_at: data.linked_at || data.project?.created_at,
+                    api_key: data.api_key
+                };
+            }
+        } catch (e) {
+            continue;
+        }
+    }
+    return null;
+}
+
+/**
+ * Saves project context to the local manifest.
+ * Prioritizes .rigstate/identity.json if the directory exists.
+ */
+export async function saveManifest(data: Partial<RigstateManifest>): Promise<string> {
+    const cwd = process.cwd();
+    const rigstatePath = path.join(cwd, '.rigstate');
+    let targetFile = rigstatePath;
+
     try {
-        const manifestPath = path.join(process.cwd(), '.rigstate');
-        const content = await fs.readFile(manifestPath, 'utf-8');
-        return JSON.parse(content);
-    } catch {
-        return null;
+        const stats = await fs.stat(rigstatePath);
+        if (stats.isDirectory()) {
+            targetFile = path.join(rigstatePath, 'identity.json');
+        }
+    } catch (e) {
+        // Doesn't exist, will be created as file/dir below
     }
+
+    // Load existing to merge
+    const existing = await loadManifest() || {} as RigstateManifest;
+    const merged = { ...existing, ...data };
+
+    // If we need to create a directory for identity.json
+    if (targetFile.endsWith('identity.json')) {
+        await fs.mkdir(rigstatePath, { recursive: true });
+    }
+
+    await fs.writeFile(targetFile, JSON.stringify(merged, null, 2), 'utf-8');
+    return targetFile;
 }

package/src/utils/version.ts

@@ -1 +1,6 @@
-export async function checkVersion() {}
+// Single source of truth for version to avoid require/import issues with package.json in ESM/TS
+export const CLI_VERSION = '0.7.34';
+
+export async function checkVersion() {
+    // Placeholder for future update checks
+}