olympus-ai 4.1.0 → 4.2.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "olympus-ai",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "Olympus: Multi-agent orchestration for Claude Code. Summon the gods of code.",
   "author": {
     "name": "mikev10",

package/dist/cli/index.js

@@ -12,13 +12,13 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { loadConfig, getConfigPaths, generateConfigSchema } from '../config/loader.js';
 import { createOlympusSession } from '../index.js';
 import { checkForUpdates, performUpdate, formatUpdateNotification, getInstalledVersion } from '../features/auto-update.js';
 import { install as installOlympus, uninstall as uninstallOlympus, isInstalled, getInstallInfo } from '../installer/index.js';
-import { readFeedbackLog, readJsonFile, getLearningDir, writeJsonFile, appendFeedback, updateAgentPerformance, loadSessionSummaries, getLastSessionSummary, } from '../learning/storage.js';
+import { readFeedbackLog, readJsonFile, getLearningDir, writeJsonFile, appendFeedback, updateAgentPerformance, loadSessionSummaries, readAgentPerformance, } from '../learning/storage.js';
 import { extractPatterns } from '../learning/pattern-extractor.js';
 import { extractPatterns as extractTaskPatterns, computePatternConfidence } from '../learning/pattern-matcher.js';
 import { updatePreferences, createDefaultPreferences } from '../learning/preference-learner.js';
@@ -27,13 +27,14 @@ import { generatePromptPatches, previewPatches, applyPromptPatches } from '../le
 import { readDiscoveries, recordDiscovery } from '../learning/discovery.js';
 import { migrateNotepads } from '../learning/migrate-notepads.js';
 import { generateLearningStats, formatLearningStats } from '../learning/stats.js';
-import { cleanupLearning, formatCleanupResult } from '../learning/cleanup.js';
+import { cleanupLearning, formatCleanupResult, collectProjectDirStats } from '../learning/cleanup.js';
+import { resolveProjectRoot, deriveProjectSlug, getProjectScopedDir } from '../learning/project-resolver.js';
 import { getWarningThreshold } from '../learning/baselines.js';
 import { calculateCost, DEFAULT_PRICING } from '../learning/pricing.js';
 import { getTokenUsage, hasEfficiencyMetrics, safeTokenTotal } from '../learning/utils.js';
 import { getSessionStatePath } from '../learning/session-state.js';
 import { randomUUID } from 'crypto';
-import { rmSync, appendFileSync } from 'fs';
+import { rmSync, appendFileSync, readdirSync, statSync } from 'fs';
 import { showMetrics, exportMetrics, analyzeMetrics, cleanMetrics } from './commands/metrics.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Try to load package.json for version
@@ -574,18 +575,72 @@ program
     .option('--suggest', 'Show suggested prompt improvements')
     .option('--apply', 'Apply suggested improvements')
     .option('-f, --forget', 'Forget all learnings')
-    .option('-p, --project', 'Scope to current project (with --forget)')
-    .option('-e, --export', 'Export learnings to JSON')
+    .option('-p, --project [slug]', 'Project slug for --forget; omit value to use current project')
+    .option('-e, --export [file]', 'Export current project data to file or stdout')
     .option('-i, --import <file>', 'Import learnings from JSON')
     .option('--efficiency', 'Show agent efficiency rankings and token metrics')
     .option('--show-costs', 'Show cost breakdown by model and agent')
     .option('--budget-status', 'Show current session token budget status')
     .option('--last-session', 'Show last session summary')
     .option('--sessions [n]', 'Show last N sessions (default: 10)')
+    .option('--global', 'Show global learning data, bypassing project scoping')
+    .option('--all-projects', 'List all project directories with stats')
+    .option('--confirm', 'Confirm destructive operations (required for --forget)')
     .action(async (options) => {
     const learningDir = getLearningDir();
+    function resolveProjectContext() {
+        if (options.global) {
+            return { projectPath: null, isInProject: false };
+        }
+        try {
+            const resolved = resolveProjectRoot(process.cwd());
+            const cwd = resolve(process.cwd());
+            if (resolved === cwd) {
+                return { projectPath: null, isInProject: false };
+            }
+            return { projectPath: resolved, isInProject: true };
+        }
+        catch {
+            return { projectPath: null, isInProject: false };
+        }
+    }
+    if (options.allProjects) {
+        try {
+            const projectsDir = join(getLearningDir(), 'projects');
+            const stats = collectProjectDirStats(projectsDir);
+            if (stats.length === 0) {
+                console.log('No project directories found.');
+                return;
+            }
+            const slugW = 40, dateW = 22, sizeW = 10, feedW = 10, sessW = 8;
+            const header = 'Project'.padEnd(slugW) + 'Last Modified'.padEnd(dateW) + 'Size'.padStart(sizeW) + 'Feedback'.padStart(feedW) + 'Sessions'.padStart(sessW);
+            const divider = '-'.repeat(slugW + dateW + sizeW + feedW + sessW);
+            console.log(header);
+            console.log(divider);
+            for (const s of stats) {
+                const sizeKb = (s.sizeBytes / 1024).toFixed(0) + ' KB';
+                const dateStr = s.lastModified.toISOString().replace('T', ' ').substring(0, 16);
+                const line = s.slug.substring(0, slugW).padEnd(slugW)
+                    + dateStr.padEnd(dateW)
+                    + sizeKb.padStart(sizeW)
+                    + String(s.feedbackCount).padStart(feedW)
+                    + String(s.sessionCount).padStart(sessW);
+                console.log(line);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[Olympus] Failed to list project directories: ${msg}`);
+        }
+        return;
+    }
     if (options.lastSession) {
-        const summary = getLastSessionSummary();
+        const { projectPath: lsProjectPath } = resolveProjectContext();
+        if (!lsProjectPath && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
+        const lsSummaries = loadSessionSummaries(lsProjectPath ?? undefined);
+        const summary = lsSummaries.length > 0 ? lsSummaries[lsSummaries.length - 1] : null;
         if (!summary) {
             console.log(chalk.yellow('No session summaries recorded yet. Complete a session first.'));
             return;
@@ -615,9 +670,13 @@ program
         return;
     }
     if (options.sessions !== undefined) {
+        const { projectPath: sessProjectPath } = resolveProjectContext();
+        if (!sessProjectPath && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
         const n = typeof options.sessions === 'string' ? parseInt(options.sessions) : 10;
         const count = isNaN(n) ? 10 : n;
-        const allSummaries = loadSessionSummaries();
+        const allSummaries = loadSessionSummaries(sessProjectPath ?? undefined);
         if (allSummaries.length === 0) {
             console.log(chalk.yellow('No session summaries recorded yet. Complete a session first.'));
             return;
@@ -669,6 +728,24 @@ program
     if (options.stats) {
         const stats = generateLearningStats(process.cwd());
         console.log(formatLearningStats(stats));
+        try {
+            const projectsDir = join(getLearningDir(), 'projects');
+            const projStats = collectProjectDirStats(projectsDir);
+            if (projStats.length > 0) {
+                console.log('\nPer-Project Storage:');
+                let totalBytes = 0;
+                for (const ps of projStats) {
+                    const sizeKb = (ps.sizeBytes / 1024).toFixed(0) + ' KB';
+                    console.log(`  ${ps.slug.padEnd(40)} ${sizeKb.padStart(8)}`);
+                    totalBytes += ps.sizeBytes;
+                }
+                const totalKb = (totalBytes / 1024).toFixed(0) + ' KB';
+                console.log(`  ${'-'.repeat(49)}`);
+                console.log(`  Total (${projStats.length} project${projStats.length === 1 ? '' : 's'}):${' '.repeat(Math.max(0, 33 - String(projStats.length).length - 10))} ${totalKb.padStart(8)}`);
+                console.log(`\nGlobal learning directory: ${getLearningDir()} (${totalKb})`);
+            }
+        }
+        catch { }
         return;
     }
     if (options.cleanup) {
@@ -682,10 +759,14 @@ program
         return;
     }
     if (options.show) {
+        const { projectPath: showProjectPath, isInProject: showIsInProject } = resolveProjectContext();
+        if (!showIsInProject && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
         console.log(chalk.blue.bold('\n╭─────────────────────────────────────────────────────────────╮'));
         console.log(chalk.blue.bold('│                  OLYMPUS LEARNING STATUS                    │'));
         console.log(chalk.blue.bold('╰─────────────────────────────────────────────────────────────╯\n'));
-        const feedback = readFeedbackLog();
+        const feedback = readFeedbackLog(showProjectPath ?? undefined);
         const revisions = feedback.filter(f => f.event_type === 'revision').length;
         const cancellations = feedback.filter(f => f.event_type === 'cancellation').length;
         const successes = feedback.filter(f => f.event_type === 'success').length;
@@ -698,8 +779,18 @@ program
                 console.log(`   • Verbosity: ${prefs.verbosity}`);
             if (prefs.autonomy !== 'unknown')
                 console.log(`   • Autonomy: ${prefs.autonomy}`);
-            for (const rule of prefs.explicit_rules.slice(0, 3)) {
-                console.log(`   • ${rule}`);
+            const filteredRules = prefs.explicit_rules.filter((r) => {
+                if (typeof r === 'object' && r !== null && 'rule' in r) {
+                    const rObj = r;
+                    return !showProjectPath || !rObj.project_path || rObj.project_path === showProjectPath;
+                }
+                return true;
+            });
+            for (const rule of filteredRules.slice(0, 3)) {
+                const ruleText = typeof rule === 'object' && rule !== null && 'rule' in rule
+                    ? rule.rule
+                    : String(rule);
+                console.log(`   * ${ruleText}`);
             }
             console.log('');
         }
@@ -710,7 +801,7 @@ program
             }
             console.log('');
         }
-        const agentPerf = readJsonFile(join(learningDir, 'agent-performance.json'), {});
+        const agentPerf = readAgentPerformance(showProjectPath ?? undefined);
         if (Object.keys(agentPerf).length > 0) {
             console.log(chalk.white('🤖 Agent Performance:'));
             for (const [name, perf] of Object.entries(agentPerf)) {
@@ -719,7 +810,16 @@ program
             }
             console.log('');
         }
-        // Show discoveries
+        const showSummaries = loadSessionSummaries(showProjectPath ?? undefined);
+        if (showSummaries.length > 0) {
+            console.log(chalk.white('📅 Sessions:'));
+            console.log(`   • Total recorded: ${showSummaries.length}`);
+            const lastS = showSummaries[showSummaries.length - 1];
+            if (lastS) {
+                console.log(`   • Last: ${new Date(lastS.started_at).toLocaleString()}`);
+            }
+            console.log('');
+        }
         const discoveries = readDiscoveries(process.cwd());
         if (discoveries.total_discoveries > 0) {
             console.log(chalk.white('💡 Discoveries:'));
@@ -734,7 +834,6 @@ program
             }
             console.log('');
         }
-        // Show auto-discovery configuration status
         try {
             const { loadDiscoveryConfig } = await import('../learning/config.js');
             const discoveryConfig = loadDiscoveryConfig(process.cwd());
@@ -743,7 +842,6 @@ program
             console.log(`   • Min Confidence: ${discoveryConfig.minConfidence}`);
             console.log(`   • Limits: ${discoveryConfig.maxPerSession}/session, ${discoveryConfig.maxPerDay}/day`);
             console.log(`   • Dedup Window: ${discoveryConfig.deduplicationWindowDays} days`);
-            // Show recent auto-discoveries with confidence scores
             if (discoveries.total_discoveries > 0) {
                 const recentAuto = [...discoveries.project_discoveries]
                     .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
@@ -760,29 +858,31 @@ program
             console.log('');
         }
         catch {
-            // Silent failure - auto-discovery status is non-critical
         }
         return;
     }
     if (options.analyze) {
+        const { projectPath: analyzeProjectPath } = resolveProjectContext();
+        if (!analyzeProjectPath && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
         console.log(chalk.blue('Analyzing feedback...\n'));
-        const feedback = readFeedbackLog();
-        const patterns = extractPatterns(feedback);
+        const feedback = readFeedbackLog(analyzeProjectPath ?? undefined);
+        const patterns = extractPatterns(feedback, undefined, undefined, analyzeProjectPath ?? undefined);
         console.log(chalk.white(`Found ${patterns.length} patterns:\n`));
         for (const p of patterns) {
             console.log(`  [${(p.confidence * 100).toFixed(0)}%] ${p.pattern.substring(0, 60)}...`);
             console.log(chalk.gray(`       Seen ${p.evidence_count}x, scope: ${p.scope}, category: ${p.category}`));
         }
-        // Update preferences
         const currentPrefs = readJsonFile(join(learningDir, 'user-preferences.json'), createDefaultPreferences());
-        const updatedPrefs = updatePreferences(currentPrefs, feedback, patterns);
+        const updatedPrefs = updatePreferences(currentPrefs, feedback, patterns, analyzeProjectPath ?? undefined);
         writeJsonFile(join(learningDir, 'user-preferences.json'), updatedPrefs);
-        // Update agent performance
         const agentPerf = evaluateAgentPerformance(feedback);
-        // Extract task patterns for routing recommendations
         const agentPerfObj = Object.fromEntries(agentPerf);
-        // Load existing performance to preserve existing task_patterns
-        const existingPerf = readJsonFile(join(learningDir, 'agent-performance.json'), {});
+        const agentPerfWritePath = analyzeProjectPath
+            ? join(getProjectScopedDir(analyzeProjectPath), 'agent-performance.json')
+            : join(learningDir, 'agent-performance.json');
+        const existingPerf = readJsonFile(agentPerfWritePath, {});
         // Analyze task patterns per agent
         for (const [agentName, perf] of Object.entries(agentPerfObj)) {
             const agentFeedback = feedback.filter(f => f.agent_used === agentName);
@@ -815,15 +915,13 @@ program
                 });
             }
             if (taskPatterns.length > 0) {
-                perf.task_patterns = taskPatterns.slice(0, 10); // Limit to top 10 patterns
+                perf.task_patterns = taskPatterns.slice(0, 10);
             }
             else if (existingPerf[agentName]?.task_patterns) {
-                // Preserve existing patterns if no new ones found
                 perf.task_patterns = existingPerf[agentName].task_patterns;
             }
         }
-        // Write with patterns included
-        writeJsonFile(join(learningDir, 'agent-performance.json'), agentPerfObj);
+        writeJsonFile(agentPerfWritePath, agentPerfObj);
         const totalPatterns = Object.values(agentPerfObj).reduce((sum, p) => sum + (p.task_patterns?.length || 0), 0);
         if (totalPatterns > 0) {
             console.log(chalk.green(`✓ ${totalPatterns} task patterns extracted for routing optimization.`));
@@ -867,19 +965,42 @@ program
     }
     if (options.forget) {
         if (options.project) {
-            const projectDir = join(process.cwd(), '.olympus', 'learning');
-            if (existsSync(projectDir)) {
-                rmSync(projectDir, { recursive: true });
-                console.log(chalk.green('✓ Project learnings forgotten.'));
-            }
-            else {
-                console.log(chalk.yellow('No project learnings found.'));
+            try {
+                const targetSlug = typeof options.project === 'string'
+                    ? options.project
+                    : deriveProjectSlug(resolveProjectRoot(process.cwd()));
+                const targetPath = join(getLearningDir(), 'projects', targetSlug);
+                if (!options.confirm) {
+                    if (!existsSync(targetPath)) {
+                        console.log(`Project directory not found: ${targetSlug}`);
+                        return;
+                    }
+                    const files = readdirSync(targetPath);
+                    console.log(`Would delete: ${targetPath}`);
+                    for (const f of files) {
+                        const fp = join(targetPath, f);
+                        let sz = 0;
+                        try {
+                            sz = statSync(fp).size;
+                        }
+                        catch { }
+                        console.log(`  ${f} (${sz} bytes)`);
+                    }
+                    console.log('Run with --confirm to delete.');
+                }
+                else {
+                    if (!existsSync(targetPath)) {
+                        console.log(`Project directory not found: ${targetSlug}`);
+                        return;
+                    }
+                    const fileCount = readdirSync(targetPath).length;
+                    rmSync(targetPath, { recursive: true, force: true });
+                    console.log(chalk.green(`Deleted project data for ${targetSlug} (${fileCount} files removed).`));
+                }
             }
-            // DELETE SESSION STATE (privacy fix)
-            const sessionStatePath = getSessionStatePath(process.cwd());
-            if (existsSync(sessionStatePath)) {
-                rmSync(sessionStatePath);
-                console.log(chalk.green('✓ Session state deleted.'));
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`[Olympus] Failed to forget project: ${msg}`);
             }
         }
         else {
@@ -894,15 +1015,35 @@ program
         }
         return;
     }
-    if (options.export) {
-        const data = {
-            feedback: readFeedbackLog(),
-            preferences: readJsonFile(join(learningDir, 'user-preferences.json'), null),
-            agentPerformance: readJsonFile(join(learningDir, 'agent-performance.json'), {}),
-            discoveries: readDiscoveries(process.cwd()),
-            exportedAt: new Date().toISOString(),
-        };
-        console.log(JSON.stringify(data, null, 2));
+    if (options.export !== undefined) {
+        try {
+            const { projectPath: exportProjectPath, isInProject: exportIsInProject } = resolveProjectContext();
+            if (!exportIsInProject) {
+                console.log('Not inside a recognized project directory. Showing global data.');
+                return;
+            }
+            const exportProjDir = getProjectScopedDir(exportProjectPath);
+            const readRaw = (file) => {
+                const p = join(exportProjDir, file);
+                return existsSync(p) ? readFileSync(p, 'utf-8') : null;
+            };
+            const output = JSON.stringify({
+                feedback_log: readRaw('feedback-log.jsonl'),
+                agent_performance: readRaw('agent-performance.json'),
+                session_insights: readRaw('session-insights.json'),
+            }, null, 2);
+            if (typeof options.export === 'string' && options.export.length > 0) {
+                writeFileSync(options.export, output, 'utf-8');
+                console.log(chalk.green(`✓ Exported to ${options.export}`));
+            }
+            else {
+                console.log(output);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[Olympus] Failed to export: ${msg}`);
+        }
         return;
     }
     if (options.import) {
@@ -932,9 +1073,12 @@ program
         return;
     }
     if (options.efficiency) {
-        const feedback = readFeedbackLog();
-        const agentPerfRaw = readJsonFile(join(learningDir, 'agent-performance.json'), {});
-        // Compute agent performance from feedback if not already computed
+        const { projectPath: effProjectPath } = resolveProjectContext();
+        if (!effProjectPath && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
+        const feedback = readFeedbackLog(effProjectPath ?? undefined);
+        const agentPerfRaw = readAgentPerformance(effProjectPath ?? undefined);
         const agentPerf = {};
         const agentNames = new Set(feedback.filter(f => f.agent_used).map(f => f.agent_used));
         for (const agentName of agentNames) {
@@ -943,7 +1087,6 @@ program
                 agentPerf[agentName] = perf;
             }
         }
-        // Merge with existing performance data
         Object.assign(agentPerf, agentPerfRaw);
         const agents = Object.values(agentPerf).filter(p => hasEfficiencyMetrics(p));
         if (agents.length === 0) {