@hivehub/rulebook 4.3.1 → 5.0.0

package/dist/cli/commands.js

@@ -54,6 +54,10 @@ export async function initCommand(options) {
         const spinner = ora('Detecting project structure...').start();
         const detection = await detectProject(cwd);
         spinner.succeed('Project detection complete');
+        // Assess project complexity for calibrated generation (v5)
+        const { assessComplexity } = await import('../core/complexity-detector.js');
+        const complexity = assessComplexity(cwd);
+        console.log(chalk.gray(`  Complexity: ${complexity.tier.toUpperCase()} (${complexity.metrics.estimatedLoc.toLocaleString()} LOC, ${complexity.metrics.languageCount} languages)`));
         // Show detection results
         if (detection.languages.length > 0) {
             console.log(chalk.green('\n✓ Detected languages:'));
@@ -265,6 +269,43 @@ export async function initCommand(options) {
         // Write AGENTS.md
         await writeFile(agentsPath, finalContent);
         console.log(chalk.green(`\n✅ AGENTS.md written to ${agentsPath}`));
+        // Install canonical rules based on complexity tier (v5)
+        {
+            const { installRule, projectRules } = await import('../core/rule-engine.js');
+            const { getTemplatesDir } = await import('../core/generator.js');
+            const templatesDir = getTemplatesDir();
+            // Tier 1 rules — always installed
+            const tier1Rules = ['no-shortcuts', 'git-safety', 'sequential-editing', 'research-first', 'follow-task-sequence'];
+            // Tier 2 rules — installed for medium+ complexity
+            const tier2Rules = ['task-decomposition', 'incremental-tests', 'no-deferred', 'session-workflow'];
+            const rulesToInstall = [...tier1Rules];
+            if (complexity.recommendations.tier2Rules) {
+                rulesToInstall.push(...tier2Rules);
+            }
+            let installedCount = 0;
+            for (const name of rulesToInstall) {
+                const result = await installRule(cwd, name, templatesDir);
+                if (result)
+                    installedCount++;
+            }
+            if (installedCount > 0) {
+                console.log(chalk.gray(`  • Installed ${installedCount} canonical rules to .rulebook/rules/`));
+            }
+            // Project rules to detected tools
+            const ruleResult = await projectRules(cwd, {
+                claudeCode: existsSync(path.join(cwd, '.claude')) || existsSync(path.join(cwd, 'CLAUDE.md')),
+                cursor: detection.cursor?.detected,
+                gemini: detection.geminiCli?.detected,
+                windsurf: detection.windsurf?.detected,
+                copilot: detection.githubCopilot?.detected,
+                continueDev: detection.continueDev?.detected,
+            });
+            const totalProjected = ruleResult.claudeCode.length + ruleResult.cursor.length + ruleResult.gemini.length +
+                ruleResult.copilot.length + ruleResult.windsurf.length + ruleResult.continueDev.length;
+            if (totalProjected > 0) {
+                console.log(chalk.gray(`  • Projected rules to ${totalProjected} tool-specific files`));
+            }
+        }
         // Show Cursor MDC feedback
         if (detection.cursor?.detected) {
             if (detection.cursor.hasMdcRules) {
@@ -1588,6 +1629,51 @@ async function updateSingleProject(cwd, options) {
     const mergedContent = await mergeFullAgents(detection.existingAgents, config, cwd);
     await writeFile(agentsPath, mergedContent);
     mergeSpinner.succeed('AGENTS.md updated');
+    // Install + project canonical rules to all detected tools (v5 rule engine)
+    // On update: if .rulebook/rules/ is empty (v4 project), auto-install based on complexity
+    {
+        const { projectRules, installRule, loadCanonicalRules } = await import('../core/rule-engine.js');
+        const existingRules = await loadCanonicalRules(cwd);
+        if (existingRules.length === 0) {
+            // v4 project upgrading to v5 — install canonical rules based on complexity
+            const { assessComplexity } = await import('../core/complexity-detector.js');
+            const { getTemplatesDir } = await import('../core/generator.js');
+            const complexity = assessComplexity(cwd);
+            const templatesDir = getTemplatesDir();
+            const tier1 = ['no-shortcuts', 'git-safety', 'sequential-editing', 'research-first', 'follow-task-sequence'];
+            const tier2 = ['task-decomposition', 'incremental-tests', 'no-deferred', 'session-workflow'];
+            const toInstall = [...tier1];
+            if (complexity.recommendations.tier2Rules) {
+                toInstall.push(...tier2);
+            }
+            let installed = 0;
+            for (const name of toInstall) {
+                const result = await installRule(cwd, name, templatesDir);
+                if (result)
+                    installed++;
+            }
+            if (installed > 0) {
+                console.log(chalk.gray(`  • Installed ${installed} v5 canonical rules (${complexity.tier} project, ${complexity.metrics.estimatedLoc.toLocaleString()} LOC)`));
+            }
+        }
+        const ruleResult = await projectRules(cwd, {
+            claudeCode: existsSync(path.join(cwd, '.claude')) || existsSync(path.join(cwd, 'CLAUDE.md')),
+            cursor: detection.cursor?.detected,
+            gemini: detection.geminiCli?.detected,
+            windsurf: detection.windsurf?.detected,
+            copilot: detection.githubCopilot?.detected,
+            continueDev: detection.continueDev?.detected,
+        });
+        const totalProjected = ruleResult.claudeCode.length +
+            ruleResult.cursor.length +
+            ruleResult.gemini.length +
+            ruleResult.copilot.length +
+            ruleResult.windsurf.length +
+            ruleResult.continueDev.length;
+        if (totalProjected > 0) {
+            console.log(chalk.gray(`  • Projected ${totalProjected} canonical rules to detected tools`));
+        }
+    }
     // Show multi-tool config feedback (update command)
     if (detection.geminiCli?.detected) {
         console.log(chalk.gray('  • Gemini CLI config updated: GEMINI.md'));
@@ -3682,4 +3768,175 @@ export async function workspaceStatusCommand() {
         await manager.shutdownAll();
     }
 }
+// Context Intelligence Layer commands (v4.4)
+export async function decisionCreateCommand(title, options) {
+    const { DecisionManager } = await import('../core/decision-manager.js');
+    const mgr = new DecisionManager(process.cwd());
+    const spinner = ora('Creating decision...').start();
+    try {
+        const d = await mgr.create(title, {
+            context: options.context,
+            relatedTasks: options.relatedTask ? [options.relatedTask] : undefined,
+        });
+        spinner.succeed(`Decision ADR-${String(d.id).padStart(3, '0')}: ${d.title} (${d.status})`);
+    }
+    catch (error) {
+        spinner.fail(`Failed: ${String(error)}`);
+    }
+}
+export async function decisionListCommand(options) {
+    const { DecisionManager } = await import('../core/decision-manager.js');
+    const mgr = new DecisionManager(process.cwd());
+    const decisions = await mgr.list(options.status);
+    if (decisions.length === 0) {
+        console.log(chalk.dim('No decisions found.'));
+        return;
+    }
+    for (const d of decisions) {
+        const badge = d.status === 'accepted' ? chalk.green(d.status) : d.status === 'superseded' ? chalk.dim(d.status) : chalk.yellow(d.status);
+        console.log(`  ADR-${String(d.id).padStart(3, '0')}  ${d.title}  ${badge}`);
+    }
+}
+export async function decisionShowCommand(id) {
+    const { DecisionManager } = await import('../core/decision-manager.js');
+    const mgr = new DecisionManager(process.cwd());
+    const result = await mgr.show(parseInt(id));
+    if (!result) {
+        console.log(chalk.red(`Decision ${id} not found.`));
+        return;
+    }
+    console.log(result.content);
+}
+export async function decisionSupersedeCommand(oldId, newId) {
+    const { DecisionManager } = await import('../core/decision-manager.js');
+    const mgr = new DecisionManager(process.cwd());
+    const ok = await mgr.supersede(parseInt(oldId), parseInt(newId));
+    if (ok) {
+        console.log(chalk.green(`Decision ${oldId} superseded by ${newId}.`));
+    }
+    else {
+        console.log(chalk.red(`Decision ${oldId} not found.`));
+    }
+}
+export async function knowledgeAddCommand(type, title, options) {
+    const { KnowledgeManager } = await import('../core/knowledge-manager.js');
+    const mgr = new KnowledgeManager(process.cwd());
+    const spinner = ora('Adding knowledge entry...').start();
+    try {
+        const entry = await mgr.add(type, title, {
+            category: (options.category ?? 'code'),
+            description: options.description ?? '',
+        });
+        spinner.succeed(`${entry.type}: ${entry.title} (${entry.category})`);
+    }
+    catch (error) {
+        spinner.fail(`Failed: ${String(error)}`);
+    }
+}
+export async function knowledgeListCommand(options) {
+    const { KnowledgeManager } = await import('../core/knowledge-manager.js');
+    const mgr = new KnowledgeManager(process.cwd());
+    const entries = await mgr.list(options.type, options.category);
+    if (entries.length === 0) {
+        console.log(chalk.dim('No knowledge entries found.'));
+        return;
+    }
+    for (const e of entries) {
+        const badge = e.type === 'pattern' ? chalk.green('pattern') : chalk.red('anti-pattern');
+        console.log(`  ${badge}  ${e.title}  ${chalk.dim(e.category)}`);
+    }
+}
+export async function knowledgeShowCommand(id) {
+    const { KnowledgeManager } = await import('../core/knowledge-manager.js');
+    const mgr = new KnowledgeManager(process.cwd());
+    const result = await mgr.show(id);
+    if (!result) {
+        console.log(chalk.red(`Knowledge entry "${id}" not found.`));
+        return;
+    }
+    console.log(result.content);
+}
+export async function knowledgeRemoveCommand(id) {
+    const { KnowledgeManager } = await import('../core/knowledge-manager.js');
+    const mgr = new KnowledgeManager(process.cwd());
+    const ok = await mgr.remove(id);
+    if (ok) {
+        console.log(chalk.green(`Knowledge entry "${id}" removed.`));
+    }
+    else {
+        console.log(chalk.red(`Knowledge entry "${id}" not found.`));
+    }
+}
+export async function learnCaptureCommand(options) {
+    const { LearnManager } = await import('../core/learn-manager.js');
+    const mgr = new LearnManager(process.cwd());
+    // If no title/content provided, this would be interactive (placeholder for prompts)
+    const title = options.title ?? 'Untitled learning';
+    const content = options.content ?? '';
+    const tags = options.tags ? options.tags.split(',').map(t => t.trim()) : [];
+    const spinner = ora('Capturing learning...').start();
+    try {
+        const learning = await mgr.capture(title, content, {
+            source: 'manual',
+            relatedTask: options.relatedTask,
+            tags,
+        });
+        spinner.succeed(`Learning captured: ${learning.title}`);
+    }
+    catch (error) {
+        spinner.fail(`Failed: ${String(error)}`);
+    }
+}
+export async function learnFromRalphCommand() {
+    const { LearnManager } = await import('../core/learn-manager.js');
+    const mgr = new LearnManager(process.cwd());
+    const spinner = ora('Extracting learnings from Ralph history...').start();
+    try {
+        const learnings = await mgr.fromRalph();
+        if (learnings.length === 0) {
+            spinner.info('No new learnings found in Ralph history.');
+        }
+        else {
+            spinner.succeed(`Extracted ${learnings.length} learning(s) from Ralph history.`);
+        }
+    }
+    catch (error) {
+        spinner.fail(`Failed: ${String(error)}`);
+    }
+}
+export async function learnListCommand(options) {
+    const { LearnManager } = await import('../core/learn-manager.js');
+    const mgr = new LearnManager(process.cwd());
+    const limit = options.limit ? parseInt(options.limit) : undefined;
+    const learnings = await mgr.list(limit);
+    if (learnings.length === 0) {
+        console.log(chalk.dim('No learnings found.'));
+        return;
+    }
+    for (const l of learnings) {
+        const badge = l.source === 'ralph' ? chalk.blue('ralph') : l.source === 'task-archive' ? chalk.yellow('archive') : chalk.dim('manual');
+        const promoted = l.promotedTo ? chalk.green(` → ${l.promotedTo.type}`) : '';
+        console.log(`  ${badge}  ${l.title}${promoted}`);
+    }
+}
+export async function learnPromoteCommand(id, target, options) {
+    const { LearnManager } = await import('../core/learn-manager.js');
+    const mgr = new LearnManager(process.cwd());
+    if (target !== 'knowledge' && target !== 'decision') {
+        console.log(chalk.red('Target must be "knowledge" or "decision".'));
+        return;
+    }
+    const spinner = ora(`Promoting learning to ${target}...`).start();
+    try {
+        const result = await mgr.promote(id, target, { title: options.title });
+        if (!result) {
+            spinner.fail(`Learning "${id}" not found.`);
+            return;
+        }
+        spinner.succeed(`Learning promoted to ${result.type} (id: ${result.id}).`);
+    }
+    catch (error) {
+        spinner.fail(`Failed: ${String(error)}`);
+    }
+}
 //# sourceMappingURL=commands.js.map