@rigstate/cli 0.7.37 → 0.7.39

package/package.json

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

package/src/commands/ask.ts

@@ -0,0 +1,100 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { searchMemories, getMemoryStats } from '../utils/memory-store.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// rigstate ask "<query>"
+// Searches local memories in .rigstate/memories/ using keyword matching.
+// Response time: <10ms (no API calls, no LLM, pure local search).
+//
+// Examples:
+//   rigstate ask "Why Supabase?"
+//   rigstate ask "typescript patterns"
+//   rigstate ask "security" --limit 10
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function createAskCommand(): Command {
+    return new Command('ask')
+        .description('Search local memories instantly (<10ms, offline)')
+        .argument('<query>', 'Natural language query to search memories')
+        .option('-n, --limit <n>', 'Maximum results to return', '5')
+        .action(async (query: string, options) => {
+            const limit = parseInt(options.limit, 10) || 5;
+            const startTime = performance.now();
+            const results = searchMemories(query, limit);
+            const elapsed = (performance.now() - startTime).toFixed(1);
+
+            console.log('');
+
+            if (results.length === 0) {
+                const stats = getMemoryStats();
+                console.log(chalk.yellow(`🔍 No memories found for: "${query}"`));
+                console.log(chalk.dim(`   Searched ${stats.total} memories in ${elapsed}ms.`));
+
+                if (stats.total === 0) {
+                    console.log('');
+                    console.log(chalk.dim('   No memories yet. Start with:'));
+                    console.log(chalk.white('   rigstate remember "We chose Supabase for real-time and RLS"'));
+                }
+                console.log('');
+                return;
+            }
+
+            console.log(chalk.bold(`🧠 ${results.length} memor${results.length === 1 ? 'y' : 'ies'} found`) + chalk.dim(` (${elapsed}ms)`));
+            console.log(chalk.dim('────────────────────────────────────────'));
+
+            for (const { memory, score, matchedFields } of results) {
+                const categoryColor = getCategoryColor(memory.category);
+                const stars = '⭐'.repeat(Math.min(5, Math.ceil((memory.importance || 5) / 2)));
+
+                console.log('');
+                console.log(`  ${categoryColor(memory.category)} ${chalk.bold(memory.title)} ${chalk.dim(`[${stars}]`)}`);
+
+                // Show a truncated preview of content
+                const preview = memory.content.length > 120
+                    ? memory.content.substring(0, 120) + '...'
+                    : memory.content;
+                console.log(`  ${chalk.white(preview)}`);
+
+                // Tags
+                if (memory.tags && memory.tags.length > 0) {
+                    console.log(`  ${memory.tags.map(t => chalk.yellow(`#${t}`)).join(' ')}`);
+                }
+
+                // Metadata line
+                const meta = [
+                    chalk.dim(`score:${score.toFixed(1)}`),
+                    chalk.dim(`matched:${matchedFields.join(',')}`),
+                    chalk.dim(`source:${memory.source}`),
+                ];
+                if (memory.created_at) {
+                    const date = new Date(memory.created_at).toLocaleDateString('nb-NO');
+                    meta.push(chalk.dim(`date:${date}`));
+                }
+                console.log(`  ${meta.join('  ')}`);
+            }
+
+            console.log('');
+            console.log(chalk.dim('────────────────────────────────────────'));
+
+            const stats = getMemoryStats();
+            console.log(chalk.dim(`Searched ${stats.total} memories in ${elapsed}ms`));
+            console.log('');
+        });
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function getCategoryColor(category: string): (text: string) => string {
+    const colors: Record<string, (text: string) => string> = {
+        'ADR': chalk.bgBlue.white,
+        'DECISION': chalk.bgCyan.black,
+        'LESSON': chalk.bgYellow.black,
+        'CONTEXT': chalk.bgGreen.black,
+        'INSTRUCTION': chalk.bgMagenta.white,
+        'PATTERN': chalk.bgWhite.black,
+        'GOTCHA': chalk.bgRed.white,
+    };
+    return colors[category] || chalk.dim;
+}

package/src/commands/genesis.ts

@@ -32,6 +32,7 @@ interface GenesisStatusResponse {
 
 interface GenesisTriggerResponse {
     success: boolean;
+    simulation?: boolean;
     data: {
         project_name: string;
         template: string;
@@ -51,6 +52,7 @@ export function createGenesisCommand(): Command {
     return new Command('genesis')
         .description('Initialize project foundation (Phase 0). Detects stack and injects foundation steps.')
         .option('--force', 'Re-run genesis even if already initialized (use with caution)')
+        .option('--simulate', 'Dry-run: Calculate plan without modifying database')
         .option('--status', 'Check genesis status without triggering')
         .option('--project-id <id>', 'Override project ID (defaults to linked project)')
         .action(async (options) => {
@@ -71,7 +73,7 @@ export function createGenesisCommand(): Command {
             if (options.status) {
                 await checkGenesisStatus(projectId, apiKey, apiUrl);
             } else {
-                await triggerGenesis(projectId, apiKey, apiUrl, options.force ?? false);
+                await triggerGenesis(projectId, apiKey, apiUrl, options.force ?? false, options.simulate ?? false);
             }
         });
 }
@@ -161,11 +163,17 @@ export async function triggerGenesis(
     projectId: string,
     apiKey: string,
     apiUrl: string,
-    force = false
+    force = false,
+    simulate = false
 ): Promise<boolean> {
     console.log('');
-    console.log(chalk.bold.blue('🏗️  GENESIS PROTOCOL'));
-    console.log(chalk.dim('Initializing project foundation...'));
+    if (simulate) {
+        console.log(chalk.bold.magenta('🔮 GENESIS SIMULATION'));
+        console.log(chalk.dim('Dry-run: Calculating plan without executing changes...'));
+    } else {
+        console.log(chalk.bold.blue('🏗️  GENESIS PROTOCOL'));
+        console.log(chalk.dim('Initializing project foundation...'));
+    }
     console.log('');
 
     const spinner = ora('Detecting tech stack...').start();
@@ -201,7 +209,7 @@ export async function triggerGenesis(
         // Step 2: Trigger Genesis
         const response = await axios.post<GenesisTriggerResponse>(
             `${apiUrl}/api/v1/genesis`,
-            { project_id: projectId, force },
+            { project_id: projectId, force, simulate },
             {
                 headers: { Authorization: `Bearer ${apiKey}` },
                 timeout: 60000 // AI enrichment can take time
@@ -230,6 +238,34 @@ export async function triggerGenesis(
 
         const { data } = response.data;
 
+        // ── Simulation Output ─────────────────────────────────────────────────
+        if (response.data.simulation) {
+            console.log(chalk.bold.magenta('🔮 SIMULATION RESULTS'));
+            console.log(chalk.dim('────────────────────────────────────────'));
+            console.log(`${chalk.bold('Project:')}      ${chalk.cyan(data.project_name)}`);
+            console.log(`${chalk.bold('Stack:')}        ${chalk.magenta(data.template)}`);
+            console.log(`${chalk.bold('Will Create:')}  ${chalk.white(data.steps_created)} foundation steps`);
+
+            if (data.existing_steps_shifted > 0) {
+                console.log(`${chalk.bold('Will Shift:')}   ${chalk.yellow(`${data.existing_steps_shifted} existing steps down`)}`);
+            }
+
+            console.log('');
+            console.log(chalk.bold('📋 Planner Preview:'));
+            data.steps.forEach(step => {
+                const stepNum = step.step_number;
+                // In simulation, step numbers returned might be 1-based index relative to insert, 
+                // but usually the AI/Builder assigns them relative to start.
+                console.log(`  ${step.icon || '🔹'}  ${chalk.bold(`T-${stepNum}`)}: ${step.title}`);
+                if (step.verification_path) {
+                    console.log(`       ${chalk.dim(`Verify: ${step.verification_path}`)}`);
+                }
+            });
+            console.log('');
+            console.log(chalk.dim('To execute this plan, run without --simulate.'));
+            return true;
+        }
+
         // ── Success Output ────────────────────────────────────────────────────
         console.log(chalk.bold.green('✅ GENESIS COMPLETE'));
         console.log(chalk.dim('────────────────────────────────────────'));

package/src/commands/remember.ts

@@ -0,0 +1,67 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { saveMemory, getMemoryStats } from '../utils/memory-store.js';
+import type { MemoryCategory } from '@rigstate/shared';
+import { getProjectId } from '../utils/config.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// rigstate remember "<text>"
+// Saves a memory to the local .rigstate/memories/ directory.
+//
+// Examples:
+//   rigstate remember "We chose Supabase for real-time and RLS"
+//   rigstate remember "Never use 'any' in shared types" --category LESSON --tags "typescript,shared"
+//   rigstate remember "ADR-001: Monorepo over polyrepo" --category ADR --importance 9
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function createRememberCommand(): Command {
+    return new Command('remember')
+        .description('Save a memory to the local knowledge base (.rigstate/memories/)')
+        .argument('<text>', 'The memory content to save')
+        .option('-t, --title <title>', 'Title for the memory (defaults to first 60 chars of text)')
+        .option('-c, --category <category>', 'Category: ADR, DECISION, LESSON, CONTEXT, INSTRUCTION, PATTERN, GOTCHA', 'CONTEXT')
+        .option('--tags <tags>', 'Comma-separated tags (e.g. "supabase,architecture")')
+        .option('-i, --importance <n>', 'Importance 1-10 (default: 5)', '5')
+        .option('--source <source>', 'Source: USER, AGENT, COUNCIL, GOVERNANCE, HARVEST, IMPORT', 'USER')
+        .action(async (text: string, options) => {
+            try {
+                const projectId = getProjectId();
+
+                const title = options.title || text.substring(0, 60) + (text.length > 60 ? '...' : '');
+                const tags = options.tags ? options.tags.split(',').map((t: string) => t.trim()) : [];
+                const importance = Math.min(10, Math.max(1, parseInt(options.importance, 10) || 5));
+
+                const memory = saveMemory({
+                    title,
+                    content: text,
+                    category: (options.category as MemoryCategory) || 'CONTEXT',
+                    source: options.source || 'USER',
+                    tags,
+                    importance,
+                    project_id: projectId || undefined,
+                });
+
+                console.log('');
+                console.log(chalk.bold.green('🧠 Memory Saved'));
+                console.log(chalk.dim('────────────────────────────────────────'));
+                console.log(`${chalk.bold('ID:')}         ${chalk.dim(memory.id)}`);
+                console.log(`${chalk.bold('Title:')}      ${chalk.cyan(memory.title)}`);
+                console.log(`${chalk.bold('Category:')}   ${chalk.magenta(memory.category)}`);
+                console.log(`${chalk.bold('Importance:')} ${'⭐'.repeat(Math.min(5, Math.ceil(importance / 2)))} (${importance}/10)`);
+                if (tags.length > 0) {
+                    console.log(`${chalk.bold('Tags:')}       ${tags.map((t: string) => chalk.yellow(`#${t}`)).join(' ')}`);
+                }
+                console.log(chalk.dim('────────────────────────────────────────'));
+
+                // Show stats
+                const stats = getMemoryStats();
+                console.log(chalk.dim(`Total memories: ${stats.total}`));
+                console.log('');
+
+            } catch (err: any) {
+                console.error(chalk.red(`❌ Failed to save memory: ${err.message}`));
+                process.exit(1);
+            }
+        });
+}

package/src/index.ts

@@ -24,6 +24,8 @@ import { createRoadmapCommand } from './commands/roadmap.js';
 import { createCouncilCommand } from './commands/council.js';
 import { createPlanCommand } from './commands/plan.js';
 import { createGenesisCommand } from './commands/genesis.js';
+import { createRememberCommand } from './commands/remember.js';
+import { createAskCommand } from './commands/ask.js';
 import { checkVersion } from './utils/version.js';
 import dotenv from 'dotenv';
 
@@ -65,6 +67,8 @@ program.addCommand(createRoadmapCommand());
 program.addCommand(createCouncilCommand());
 program.addCommand(createPlanCommand());
 program.addCommand(createGenesisCommand());
+program.addCommand(createRememberCommand());
+program.addCommand(createAskCommand());
 
 program.hook('preAction', async () => {
     await checkVersion();

package/src/utils/memory-store.ts

@@ -0,0 +1,183 @@
+/* eslint-disable no-console */
+import * as fs from 'fs';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+import type { Memory, MemoryInput } from '@rigstate/shared';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Memory Store: Local file-based storage for Decentralized Intelligence.
+// Memories are stored as individual JSON files in .rigstate/memories/
+// ─────────────────────────────────────────────────────────────────────────────
+
+const MEMORIES_DIR = '.rigstate/memories';
+
+function getMemoriesDir(): string {
+    const dir = path.resolve(process.cwd(), MEMORIES_DIR);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+
+// ── Save ─────────────────────────────────────────────────────────────────────
+
+export function saveMemory(input: MemoryInput): Memory {
+    const dir = getMemoriesDir();
+    const now = new Date().toISOString();
+
+    const memory: Memory = {
+        id: randomUUID(),
+        ...input,
+        title: input.title,
+        content: input.content,
+        category: input.category || 'CONTEXT',
+        source: input.source || 'USER',
+        tags: input.tags || [],
+        importance: input.importance || 5,
+        confidence: input.confidence || 1.0,
+        created_at: now,
+        updated_at: now,
+        expires_at: input.expires_at || null,
+    };
+
+    const filename = `${memory.id}.json`;
+    const filepath = path.join(dir, filename);
+    fs.writeFileSync(filepath, JSON.stringify(memory, null, 2), 'utf-8');
+
+    return memory;
+}
+
+// ── Load All ─────────────────────────────────────────────────────────────────
+
+export function loadAllMemories(): Memory[] {
+    const dir = getMemoriesDir();
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+
+    const memories: Memory[] = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), 'utf-8');
+            memories.push(JSON.parse(raw) as Memory);
+        } catch {
+            // Skip corrupted files silently
+        }
+    }
+
+    return memories;
+}
+
+// ── Search (Keyword-based, <10ms) ────────────────────────────────────────────
+
+export interface SearchResult {
+    memory: Memory;
+    score: number;
+    matchedFields: string[];
+}
+
+export function searchMemories(query: string, limit = 5): SearchResult[] {
+    const memories = loadAllMemories();
+    const tokens = tokenize(query);
+
+    if (tokens.length === 0) return [];
+
+    const results: SearchResult[] = [];
+
+    for (const memory of memories) {
+        // Check expiry
+        if (memory.expires_at && new Date(memory.expires_at) < new Date()) {
+            continue;
+        }
+
+        let score = 0;
+        const matchedFields: string[] = [];
+
+        // Title match (high weight)
+        const titleTokens = tokenize(memory.title);
+        const titleMatches = tokens.filter(t => titleTokens.includes(t)).length;
+        if (titleMatches > 0) {
+            score += titleMatches * 3;
+            matchedFields.push('title');
+        }
+
+        // Content match (medium weight)
+        const contentLower = memory.content.toLowerCase();
+        const contentMatches = tokens.filter(t => contentLower.includes(t)).length;
+        if (contentMatches > 0) {
+            score += contentMatches * 1;
+            matchedFields.push('content');
+        }
+
+        // Tag match (high weight)
+        const tagLower = memory.tags.map(t => t.toLowerCase());
+        const tagMatches = tokens.filter(t => tagLower.includes(t)).length;
+        if (tagMatches > 0) {
+            score += tagMatches * 4;
+            matchedFields.push('tags');
+        }
+
+        // Category match (bonus)
+        if (tokens.includes(memory.category.toLowerCase())) {
+            score += 2;
+            matchedFields.push('category');
+        }
+
+        // Importance boost
+        score *= (memory.importance / 5); // importance 10 = 2x multiplier
+
+        if (score > 0) {
+            results.push({ memory, score, matchedFields });
+        }
+    }
+
+    // Sort by score descending, return top N
+    return results
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+}
+
+// ── Stats ────────────────────────────────────────────────────────────────────
+
+export function getMemoryStats(): { total: number; byCategory: Record<string, number> } {
+    const memories = loadAllMemories();
+    const byCategory: Record<string, number> = {};
+
+    for (const m of memories) {
+        byCategory[m.category] = (byCategory[m.category] || 0) + 1;
+    }
+
+    return { total: memories.length, byCategory };
+}
+
+// ── Delete ───────────────────────────────────────────────────────────────────
+
+export function deleteMemory(id: string): boolean {
+    const dir = getMemoriesDir();
+    const filepath = path.join(dir, `${id}.json`);
+    if (fs.existsSync(filepath)) {
+        fs.unlinkSync(filepath);
+        return true;
+    }
+    return false;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+const STOP_WORDS = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'in', 'on', 'at', 'to',
+    'for', 'of', 'with', 'by', 'from', 'and', 'or', 'not', 'this', 'that',
+    'it', 'we', 'you', 'they', 'my', 'our', 'your', 'its', 'his', 'her',
+    'how', 'what', 'why', 'when', 'where', 'which', 'who', 'do', 'does',
+    'did', 'has', 'have', 'had', 'be', 'been', 'being', 'will', 'would',
+    'can', 'could', 'should', 'shall', 'may', 'might', 'must',
+    'vi', 'er', 'var', 'har', 'den', 'det', 'en', 'et', 'og', 'i', 'på',
+    'til', 'fra', 'med', 'som', 'om', 'for', 'av', 'ikke',
+    'hvorfor', 'hvordan', 'hva', 'når', 'hvor',
+]);
+
+function tokenize(text: string): string[] {
+    return text
+        .toLowerCase()
+        .replace(/[^a-zA-Z0-9æøåÆØÅ\s]/g, ' ')
+        .split(/\s+/)
+        .filter(t => t.length > 1 && !STOP_WORDS.has(t));
+}