continuous-improvement 3.1.0 → 3.9.1

package/bin/unified-cli.mjs

@@ -0,0 +1,533 @@
+#!/usr/bin/env node
+/**
+ * Unified Continuous Improvement CLI.
+ *
+ * Comprehensive command-line interface for the unified plugin that combines
+ * CLI-Anything, Compound Engineering, and PM-Skills.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import UnifiedContinuousImprovement from "../lib/unified-plugin.mjs";
+const DEFAULT_CONFIG = {
+    workspace: "./ci-workspace",
+    verbose: false,
+    defaultMode: "expert",
+};
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function parseJsonOption(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON option: ${getErrorMessage(error)}`);
+    }
+}
+class UnifiedCLI {
+    plugin = null;
+    config;
+    constructor() {
+        this.config = this.loadConfig();
+    }
+    loadConfig() {
+        const configPath = join(process.cwd(), ".ci-config.json");
+        if (existsSync(configPath)) {
+            try {
+                const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+                return { ...DEFAULT_CONFIG, ...parsed };
+            }
+            catch {
+                console.warn("Warning: Invalid config file, using defaults");
+            }
+        }
+        return { ...DEFAULT_CONFIG };
+    }
+    initializePlugin(options) {
+        this.plugin = new UnifiedContinuousImprovement({
+            workspace: options.workspace ?? this.config.workspace,
+            verbose: options.verbose ?? this.config.verbose,
+        });
+        return this.plugin;
+    }
+    requirePlugin() {
+        if (!this.plugin) {
+            throw new Error("CLI plugin not initialized");
+        }
+        return this.plugin;
+    }
+    async runCommand(command, args, options = {}) {
+        this.initializePlugin(options);
+        switch (command) {
+            case "init":
+                return this.handleInit(args, options);
+            case "workflow":
+                return this.handleWorkflow(args, options);
+            case "research":
+                return this.handleResearch(options);
+            case "planning":
+                return this.handlePlanning(options);
+            case "execution":
+                return this.handleExecution();
+            case "review":
+                return this.handleReview(options);
+            case "status":
+                return this.handleStatus();
+            case "cli":
+                return this.handleCLI(args);
+            case "pm":
+                return this.handlePM(args, options);
+            case "compound":
+                return this.handleCompound(args);
+            case "learnings":
+                return this.handleLearnings(args);
+            case "config":
+                return this.handleConfig(args);
+            default:
+                throw new Error(`Unknown command: ${command}`);
+        }
+    }
+    async handleInit(args, options) {
+        if (args.length < 2) {
+            throw new Error("Usage: ci init <project-name> <objective> [options]");
+        }
+        const [name, ...objectiveParts] = args;
+        const objective = objectiveParts.join(" ");
+        console.log(`🚀 Initializing project: ${name}`);
+        console.log(`📋 Objective: ${objective}`);
+        const plugin = this.requirePlugin();
+        const result = await plugin.initializeProject({
+            name: name,
+            objective,
+            product: parseJsonOption(options.product) ?? {},
+            industry: options.industry ?? "",
+            targetMarket: parseJsonOption(options.targetMarket) ?? {},
+        });
+        console.log(`✅ Project initialized successfully!`);
+        console.log(`🆔 Project ID: ${result.projectId}`);
+        console.log(`🔗 Session ID: ${result.sessionId}`);
+        console.log(`📊 PM Analysis: ${result.pmAnalysis.totalSkills} skills completed`);
+        console.log(`\n🎯 Next steps:`);
+        result.nextSteps.forEach((step, i) => {
+            console.log(`   ${i + 1}. ${step}`);
+        });
+        return result;
+    }
+    async handleWorkflow(args, options) {
+        if (args.length < 2) {
+            throw new Error("Usage: ci workflow <project-name> <objective> [options]");
+        }
+        const [name, ...objectiveParts] = args;
+        const objective = objectiveParts.join(" ");
+        console.log(`🚀 Starting complete workflow for: ${name}`);
+        console.log(`📋 Objective: ${objective}`);
+        const progressCallback = (message) => {
+            console.log(`   ⏳ ${message}`);
+        };
+        const plugin = this.requirePlugin();
+        const result = await plugin.executeCompleteWorkflow({
+            name: name,
+            objective,
+            product: parseJsonOption(options.product) ?? {},
+            industry: options.industry ?? "",
+            targetMarket: parseJsonOption(options.targetMarket) ?? {},
+        }, {
+            researchContext: options.repo ? { repositoryPath: options.repo } : {},
+            progressCallback,
+        });
+        console.log(`🎉 Complete workflow finished!`);
+        console.log(`🆔 Project: ${result.project}`);
+        console.log(`🔗 Session: ${result.sessionId}`);
+        for (const [phase] of Object.entries(result.phases)) {
+            console.log(`\n📊 ${phase.charAt(0).toUpperCase() + phase.slice(1)} Phase:`);
+        }
+        return result;
+    }
+    async handleResearch(options) {
+        console.log(`🔍 Starting research phase...`);
+        const context = {};
+        if (options.repo)
+            context.repositoryPath = options.repo;
+        if (options.context)
+            context.additionalContext = parseJsonOption(options.context);
+        const plugin = this.requirePlugin();
+        const result = await plugin.executeResearchPhase(context);
+        console.log(`✅ Research phase completed!`);
+        console.log(`💡 Generated ${result.brainstorm.ideas.length} ideas`);
+        console.log(`🔍 Identified ${result.brainstorm.risks.length} risks`);
+        if (result.cliTools) {
+            console.log(`🛠️  Generated CLI with ${result.cliTools.commands.length} commands`);
+        }
+        return result;
+    }
+    async handlePlanning(options) {
+        console.log(`📋 Starting planning phase...`);
+        const preferences = parseJsonOption(options.preferences) ?? {};
+        const plugin = this.requirePlugin();
+        const result = await plugin.executePlanningPhase(preferences);
+        console.log(`✅ Planning phase completed!`);
+        console.log(`📈 Created plan with ${result.corePlan.steps.length} steps`);
+        const estimated = result.corePlan.timeline?.estimated;
+        if (estimated)
+            console.log(`⏱️  Timeline: ${estimated}`);
+        console.log(`⚠️  Identified ${result.risks.length} risks`);
+        return result;
+    }
+    async handleExecution() {
+        console.log(`🔧 Starting execution phase...`);
+        const progressCallback = (message) => {
+            console.log(`   ⚡ ${message}`);
+        };
+        const plugin = this.requirePlugin();
+        const result = await plugin.executeWorkingPhase(progressCallback);
+        console.log(`✅ Execution phase completed!`);
+        console.log(`📋 Completed ${result.coreWork.steps.length} steps`);
+        console.log(`🔧 Resolved ${result.issues.length} issues`);
+        console.log(`💡 Applied ${result.solutions.length} solutions`);
+        return result;
+    }
+    async handleReview(options) {
+        console.log(`🔍 Starting review phase...`);
+        const criteria = parseJsonOption(options.criteria);
+        const plugin = this.requirePlugin();
+        const result = await plugin.executeReviewPhase(criteria);
+        console.log(`✅ Review phase completed!`);
+        console.log(`📊 Overall score: ${result.coreReview.review.overallScore}/100`);
+        console.log(`💡 Generated ${result.learnings.length} learnings`);
+        console.log(`📋 Created ${result.recommendations.length} recommendations`);
+        return result;
+    }
+    async handleStatus() {
+        const plugin = this.requirePlugin();
+        const status = await plugin.getProjectStatus();
+        console.log(`📊 Project Status:`);
+        console.log(`   Project: ${status.project ?? "No active project"}`);
+        console.log(`   Session: ${status.sessionId ?? "N/A"}`);
+        console.log(`   Current Phase: ${status.currentPhase ?? "N/A"}`);
+        if (status.progress) {
+            console.log(`   Progress: ${status.progress.completed}/${status.progress.total} (${status.progress.percentage}%)`);
+        }
+        if (status.nextSteps && status.nextSteps.length > 0) {
+            console.log(`\n🎯 Next Steps:`);
+            status.nextSteps.forEach((step, i) => {
+                console.log(`   ${i + 1}. ${step}`);
+            });
+        }
+        return status;
+    }
+    async handleCLI(args) {
+        const [subcommand, ...subArgs] = args;
+        switch (subcommand) {
+            case "generate":
+                if (subArgs.length === 0) {
+                    throw new Error("Usage: ci cli generate <repository-path>");
+                }
+                return this.handleCLIGenerate(subArgs[0]);
+            case "list":
+                return this.handleCLIList();
+            default:
+                throw new Error("Usage: ci cli <generate|list> [args]");
+        }
+    }
+    async handleCLIGenerate(repoPath) {
+        console.log(`🛠️  Generating CLI for: ${repoPath}`);
+        const plugin = this.requirePlugin();
+        const result = await plugin.cliAnything.generateCLI(repoPath);
+        console.log(`✅ CLI generated successfully!`);
+        console.log(`📁 Output: ${result.outputPath}`);
+        console.log(`🔧 Commands: ${result.commands.length}`);
+        console.log(`\n📋 Available Commands:`);
+        for (const cmd of result.commands) {
+            console.log(`   ${cmd.name.padEnd(15)} - ${cmd.description}`);
+        }
+        return result;
+    }
+    handleCLIList() {
+        console.log(`🛠️  CLI Generation Tool Status: Ready`);
+        console.log(`   Repository Analysis: Supported`);
+        console.log(`   Project Types: Node.js, React, Python, Docker, and more`);
+        console.log(`   Output Format: Executable JavaScript`);
+    }
+    async handlePM(args, options) {
+        const [subcommand, ...subArgs] = args;
+        switch (subcommand) {
+            case "analyze":
+                return this.handlePMAnalyze(options);
+            case "skill":
+                return this.handlePMSkill(subArgs);
+            case "list":
+                return this.handlePMList();
+            default:
+                throw new Error("Usage: ci pm <analyze|skill|list> [args]");
+        }
+    }
+    async handlePMAnalyze(options) {
+        console.log(`📊 Running comprehensive PM analysis...`);
+        const productInfo = {
+            product: parseJsonOption(options.product) ?? {},
+            industry: options.industry ?? "Technology",
+            targetMarket: parseJsonOption(options.targetMarket) ?? {},
+        };
+        const plugin = this.requirePlugin();
+        const result = await plugin.pmSkills.runProductAnalysis(productInfo);
+        console.log(`✅ PM analysis completed!`);
+        console.log(`📊 Summary: ${result.summary.completedSkills}/${result.summary.totalSkills} skills completed`);
+        console.log(`💡 Key insights: ${result.summary.keyInsights.length}`);
+        console.log(`📋 Recommendations: ${result.summary.recommendations.length}`);
+        console.log(`📁 Results saved to: ${result.savedTo}`);
+        return result;
+    }
+    async handlePMSkill(args) {
+        if (args.length === 0) {
+            throw new Error("Usage: ci pm skill <skill-name>");
+        }
+        const [skillName] = args;
+        console.log(`📊 Executing PM skill: ${skillName}`);
+        const input = {
+            product: { name: "Sample Product" },
+            market: { size: "Medium" },
+        };
+        const plugin = this.requirePlugin();
+        const result = await plugin.pmSkills.executeSkill(skillName, input);
+        console.log(`✅ PM skill ${skillName} completed!`);
+        console.log(`📁 Results saved to: ${result.savedTo}`);
+        return result;
+    }
+    handlePMList() {
+        const plugin = this.requirePlugin();
+        const skills = plugin.pmSkills.getAvailableSkills();
+        console.log(`📊 Available PM Skills:`);
+        for (const skill of skills) {
+            console.log(`   ${skill.name.padEnd(20)} - ${skill.description} [${skill.category}]`);
+        }
+    }
+    async handleCompound(args) {
+        const [subcommand, ...subArgs] = args;
+        switch (subcommand) {
+            case "session":
+                return this.handleCompoundSession(subArgs);
+            case "learnings":
+                return this.handleCompoundLearnings();
+            default:
+                throw new Error("Usage: ci compound <session|learnings> [args]");
+        }
+    }
+    async handleCompoundSession(args) {
+        if (args.length < 2) {
+            throw new Error("Usage: ci compound session <project-name> <objective>");
+        }
+        const [name, ...objectiveParts] = args;
+        const objective = objectiveParts.join(" ");
+        console.log(`🔧 Starting compound engineering session...`);
+        const plugin = this.requirePlugin();
+        const session = await plugin.compoundEngineering.startSession(name, objective);
+        console.log(`✅ Session started!`);
+        console.log(`🆔 Session ID: ${session.id}`);
+        console.log(`📋 Objective: ${session.objective}`);
+        console.log(`🔄 Current Phase: ${session.phase}`);
+        return session;
+    }
+    async handleCompoundLearnings() {
+        console.log(`📚 Loading compound engineering learnings...`);
+        const plugin = this.requirePlugin();
+        await plugin.compoundEngineering.loadLearnings();
+        const learnings = plugin.compoundEngineering.getAllLearnings();
+        console.log(`📚 Found ${learnings.length} learnings:`);
+        for (const learning of learnings) {
+            console.log(`   [${learning.confidence.toFixed(2)}] ${learning.summary}`);
+        }
+        return learnings;
+    }
+    async handleLearnings(args) {
+        const [subcommand, ...subArgs] = args;
+        switch (subcommand) {
+            case "search":
+                return this.handleLearningsSearch(subArgs.join(" "));
+            case "all":
+                return this.handleLearningsAll();
+            default:
+                throw new Error("Usage: ci learnings <search|all> [query]");
+        }
+    }
+    async handleLearningsSearch(query) {
+        console.log(`🔍 Searching learnings for: "${query}"`);
+        const plugin = this.requirePlugin();
+        await plugin.compoundEngineering.loadLearnings();
+        const results = plugin.compoundEngineering.searchLearnings(query);
+        console.log(`🔍 Found ${results.length} matching learnings:`);
+        for (const learning of results) {
+            console.log(`   [${learning.confidence.toFixed(2)}] ${learning.summary}`);
+        }
+        return results;
+    }
+    async handleLearningsAll() {
+        console.log(`📚 Loading all learnings...`);
+        const plugin = this.requirePlugin();
+        await plugin.compoundEngineering.loadLearnings();
+        const learnings = plugin.compoundEngineering.getAllLearnings();
+        console.log(`📚 Total learnings: ${learnings.length}`);
+        const grouped = learnings.reduce((groups, learning) => {
+            const type = learning.type || "general";
+            if (!groups[type])
+                groups[type] = [];
+            groups[type].push(learning);
+            return groups;
+        }, {});
+        for (const [type, items] of Object.entries(grouped)) {
+            console.log(`\n   ${type.charAt(0).toUpperCase() + type.slice(1)} (${items.length}):`);
+            for (const learning of items) {
+                console.log(`     [${learning.confidence.toFixed(2)}] ${learning.summary}`);
+            }
+        }
+        return learnings;
+    }
+    async handleConfig(args) {
+        const [subcommand, ...subArgs] = args;
+        switch (subcommand) {
+            case "show":
+                return this.handleConfigShow();
+            case "set":
+                return this.handleConfigSet(subArgs);
+            default:
+                throw new Error("Usage: ci config <show|set> [key] [value]");
+        }
+    }
+    handleConfigShow() {
+        console.log(`⚙️  Current Configuration:`);
+        console.log(`   Workspace: ${this.config.workspace}`);
+        console.log(`   Verbose: ${this.config.verbose}`);
+        console.log(`   Default Mode: ${this.config.defaultMode}`);
+    }
+    handleConfigSet(args) {
+        if (args.length < 2) {
+            throw new Error("Usage: ci config set <key> <value>");
+        }
+        const [key, value] = args;
+        if (!key || value === undefined) {
+            throw new Error("Usage: ci config set <key> <value>");
+        }
+        if (key === "workspace") {
+            this.config.workspace = value;
+        }
+        else if (key === "verbose") {
+            this.config.verbose = value === "true";
+        }
+        else if (key === "defaultMode") {
+            this.config.defaultMode = value;
+        }
+        else {
+            throw new Error(`Unknown config key: ${key}`);
+        }
+        console.log(`✅ Configuration updated: ${key} = ${value}`);
+    }
+}
+function parseGlobalOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const flag = args[i];
+        const next = args[i + 1];
+        const consumeValue = (key) => {
+            if (next === undefined)
+                return;
+            options[key] = next;
+            args.splice(i, 2);
+            i--;
+        };
+        switch (flag) {
+            case "--workspace":
+                consumeValue("workspace");
+                break;
+            case "--verbose":
+                options.verbose = true;
+                args.splice(i, 1);
+                i--;
+                break;
+            case "--repo":
+                consumeValue("repo");
+                break;
+            case "--product":
+                consumeValue("product");
+                break;
+            case "--industry":
+                consumeValue("industry");
+                break;
+            case "--target-market":
+                consumeValue("targetMarket");
+                break;
+            default:
+                break;
+        }
+    }
+    return options;
+}
+async function main() {
+    const [, , command, ...args] = process.argv;
+    if (!command || command === "--help" || command === "-h") {
+        console.log(`
+Unified Continuous Improvement CLI
+
+Usage: ci <command> [args] [options]
+
+Main Commands:
+  init <name> <objective>        Initialize new project with comprehensive analysis
+  workflow <name> <objective>    Run complete end-to-end workflow
+  research                       Execute research phase
+  planning                       Execute planning phase
+  execution                      Execute execution phase
+  review                         Execute review phase
+  status                         Show project status
+
+Tool Commands:
+  cli generate <repo-path>       Generate CLI for repository
+  pm analyze                     Run comprehensive PM analysis
+  pm skill <name>                Execute specific PM skill
+  pm list                        List available PM skills
+  compound session <name> <obj>  Start compound engineering session
+  compound learnings             Show compound engineering learnings
+  learnings search <query>       Search through all learnings
+  learnings all                  Show all learnings
+
+Configuration:
+  config show                    Show current configuration
+  config set <key> <value>       Set configuration value
+
+Global Options:
+  --workspace <dir>              Workspace directory
+  --verbose                      Enable verbose logging
+  --repo <path>                  Repository path for CLI generation
+  --product <json>               Product information as JSON
+  --industry <name>              Industry name
+  --target-market <json>         Target market as JSON
+
+Examples:
+  ci init "MyApp" "Build a task management app"
+  ci workflow "MyApp" "Build task management" --repo ./my-app
+  ci cli generate ./my-repo
+  ci pm analyze --industry "SaaS" --target-market '{"segment":"SMB"}'
+  ci learnings search "performance"
+`);
+        process.exit(0);
+    }
+    const cli = new UnifiedCLI();
+    const options = parseGlobalOptions(args);
+    try {
+        const result = await cli.runCommand(command, args, options);
+        if (options.verbose && result) {
+            console.log(`\n🔍 Detailed result:`);
+            console.log(JSON.stringify(result, null, 2));
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error: ${getErrorMessage(error)}`);
+        process.exit(1);
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        console.error(`❌ Fatal error: ${getErrorMessage(error)}`);
+        process.exit(1);
+    });
+}
+export default UnifiedCLI;

package/commands/continuous-improvement.md

@@ -1,11 +1,11 @@
 ---
 name: continuous-improvement
-description: "Reflect on the current session, analyze observations for patterns, and show instinct status. Run after finishing significant work."
+description: "Reflect on the current session, analyze observations for patterns, and show instinct status. Runs on-demand to save tokens."
 ---
 
 # /continuous-improvement
 
-Run this after completing significant work. It does three things in order.
+Run this when you want to reflect and learn — not every session. Three steps in order.
 
 ## Step 1: Reflect
 
@@ -17,10 +17,20 @@ Generate a reflection for this session based on what happened:
 - What failed:
 - What I'd do differently:
 - Rule to add:
+- Iteration — Next best recommendations (ranked, top 3):
+  1. <primary — strongest next move>
+  2. <alternative — different angle>
+  3. <alternative — smaller/larger scope>
 ```
 
 If there's a "Rule to add", create an instinct YAML file with 0.6 starting confidence in the project's instinct directory.
 
+The "Iteration — Next best recommendations" field is the Law 6 handoff. List the **top 3 ranked** core-development moves — what to build, fix, refactor, or investigate next so the feature/system advances. Item #1 is the strongest; #2 and #3 are alternatives the user can pivot to. NOT git steps (commit, push, PR), NOT verification re-runs, NOT deploy actions — those belong in the end-of-run summary.
+
+Format per item: `<verb> <object at path:line> (<why, one clause grounded in current context>)`.
+
+Rules: always exactly 3 distinct directions, not padding. If fewer real moves exist, fill remaining slots with `None — goal met from this angle.` If the goal is fully met across all angles, write `1. None — goal met, stop.` and omit #2 and #3.
+
 ## Step 2: Analyze Observations
 
 Check `~/.claude/instincts/` for the current project (detect via git root → SHA-256 first 12 chars).
@@ -39,6 +49,15 @@ Look at `~/.claude/instincts/<hash>/observations.jsonl`. If 20+ lines exist:
 
 If fewer than 20 observations, skip analysis and note the count.
 
+### Multi-Agent Analysis (500+ observations)
+
+When observation backlog is large, parallelize:
+- **Agent 1:** User corrections + error→fix patterns
+- **Agent 2:** Repeated workflows + tool preferences
+- **Agent 3:** Cross-reference existing instincts for updates
+
+Merge results and deduplicate before writing YAML files.
+
 ## Step 3: Show Status
 
 Display all instincts for the current project + global:
@@ -53,6 +72,10 @@ Display all instincts for the current project + global:
 - What failed: [from this session]
 - What I'd do differently: [from this session]
 - Rule to add: [captured as instinct]
+- Iteration — Next best recommendations (ranked, top 3):
+  1. [primary core-development move]
+  2. [alternative angle]
+  3. [alternative scope]
 
 ## Learning
   NEW  [instinct-id]        [domain]  [confidence]  (from reflection)
@@ -72,3 +95,21 @@ Display all instincts for the current project + global:
 ```
 
 If no instincts or observations exist yet, explain this is expected — the system is in CAPTURE level and will create instincts after 20+ observations accumulate.
+
+## Subcommands
+
+### `/continuous-improvement weekly`
+
+Set up a weekly analysis schedule:
+1. Create a cron/loop schedule that runs `/continuous-improvement analyze` every 7 days
+2. Confirm the schedule to the user
+3. Show next scheduled run date
+
+### `/continuous-improvement always-on`
+
+Toggle always-on mode for the current project:
+1. Find project hash
+2. Create/update `~/.claude/instincts/<hash>/config.yaml` with `always_on: true|false`
+3. Confirm the change
+
+**Default is off** — observations accumulate silently, analysis only runs when you ask.

package/commands/discipline.md

@@ -19,6 +19,20 @@ Print this card and check yourself against each law.
 | 6 | **Iterate One Change** | Am I changing one thing at a time? | "And also..." |
 | 7 | **Learn From Every Session** | Did I capture this as an instinct? | "Next time I'll..." |
 
+## Operator Stakes
+
+The Laws above are the *how*. These five principles are the *why*: code ships from your account, the incident lands on your pager, the bill hits your budget. Each one pairs with the Law that prevents it from going wrong.
+
+| # | Principle | Vibe coder | Engineer | Law |
+|---|-----------|------------|----------|-----|
+| 1 | **Ownership** | Ships auth, moves on | Adds rate limits, audit logs, password-reset flow, incident runbook before shipping | 4 |
+| 2 | **Reliability over cleverness** | Accepts a clever regex + heavy lib that breaks on ISO 8601 with millis | Picks the boring tested API, writes tests for leap years and DST | 1 |
+| 3 | **Systems thinking** | Builds in-memory CSV export, works for 100 dev users, OOMs in prod | Asks row count first, picks paginated background job + S3 link | 2 |
+| 4 | **Problem framing** | Builds the websocket chat the ticket asked for | Finds out users wanted faster support replies, not chat | 1 |
+| 5 | **Constraints management** | Calls the $0.02/image model on every upload | Does the math, adds client-side validation + caching + cheaper triage model | 2 |
+
+Code is a liability, not an asset. Speed without these five turns into someone else's incident at 3am — except the someone is you.
+
 ## The Loop
 
 ```