ceobe-mastery-cli 1.0.0

package/dist/ai/executor.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executePlan = executePlan;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const env_1 = require("../config/env");
+const gateway_1 = require("./gateway");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const systemTools_1 = require("./tools/systemTools");
+async function executePlan(planMarkdown) {
+    const spinner = (0, ora_1.default)('Claude 4.6 Sonnet is executing the plan...').start();
+    try {
+        const gatewayUrl = (0, gateway_1.getGatewayUrl)('anthropic');
+        const anthropic = new sdk_1.default({
+            apiKey: env_1.env.ANTHROPIC_API_KEY,
+            baseURL: gatewayUrl
+        });
+        const systemInstruction = `
+You are the Execution Engine of the Ceobe AI System.
+Your task is to take the provided execution plan and strictly implement it.
+You have access to tool commands if run within an agent wrapper, otherwise output the exact code and terminal commands required to fulfill the user's request.
+DO NOT provide planning commentary. DO NOT hallucinate dependencies. Write code.
+`;
+        let messages = [
+            {
+                role: "user",
+                content: `Execute the following plan:\n\n${planMarkdown}`
+            }
+        ];
+        let isThinking = true;
+        while (isThinking) {
+            const msg = await anthropic.messages.create({
+                model: "claude-4.6-sonnet",
+                max_tokens: 4096,
+                temperature: 0,
+                system: systemInstruction,
+                messages: messages,
+                tools: systemTools_1.tools // Type bypass for SDK version compatibility,
+            });
+            // Log the assistant's text reasoning before the tool call
+            const textBlock = msg.content.find(c => c.type === 'text');
+            if (textBlock && textBlock.type === 'text' && textBlock.text) {
+                spinner.text = chalk_1.default.cyan(`Claude is thinking: ${textBlock.text.substring(0, 50)}...`);
+            }
+            const toolCalls = msg.content.filter(c => c.type === 'tool_use');
+            messages.push({
+                role: "assistant",
+                content: msg.content
+            });
+            if (toolCalls.length === 0) {
+                // No more tools, stop loop
+                isThinking = false;
+                spinner.succeed(chalk_1.default.green('Claude 4.6 Sonnet execution completed.'));
+                console.log(chalk_1.default.cyan('\n--- Final Response ---\n'));
+                if (textBlock && textBlock.type === 'text')
+                    console.log(textBlock.text);
+                console.log(chalk_1.default.cyan('\n----------------------\n'));
+            }
+            else {
+                // Execute tool calls and feed results back to Claude
+                let toolResults = [];
+                for (const block of toolCalls) {
+                    if (block.type !== 'tool_use')
+                        continue;
+                    spinner.text = chalk_1.default.yellow(`Claude is executing tool: ${block.name}...`);
+                    const resultText = await (0, systemTools_1.handleToolCall)(block.name, block.input);
+                    toolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: block.id,
+                        content: resultText
+                    });
+                }
+                messages.push({
+                    role: "user",
+                    content: toolResults
+                });
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Claude 4.6 Sonnet execution failed.'));
+        console.error(chalk_1.default.red(error.message));
+        throw error;
+    }
+}

package/dist/ai/gateway.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGatewayUrl = getGatewayUrl;
+const env_1 = require("../config/env");
+/**
+ * Constructs the Cloudflare AI Gateway URL for a given provider.
+ *
+ * @param provider - 'google-genai' for Gemini, 'anthropic' for Claude
+ * @returns The gateway URL
+ */
+function getGatewayUrl(provider) {
+    if (!env_1.env.CLOUDFLARE_ACCOUNT_ID || !env_1.env.CLOUDFLARE_GATEWAY_ID) {
+        throw new Error('Cloudflare Gateway credentials are not properly configured.');
+    }
+    return `https://gateway.ai.cloudflare.com/v1/${env_1.env.CLOUDFLARE_ACCOUNT_ID}/${env_1.env.CLOUDFLARE_GATEWAY_ID}/${provider}`;
+}

package/dist/ai/planner.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectRelevantSkills = selectRelevantSkills;
+exports.generateBRD = generateBRD;
+exports.generateArchitecture = generateArchitecture;
+exports.generateImplementationPlan = generateImplementationPlan;
+exports.auditPlan = auditPlan;
+const genai_1 = require("@google/genai");
+const env_1 = require("../config/env");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const contextLoader_1 = require("../utils/contextLoader");
+const ai = new genai_1.GoogleGenAI({
+    apiKey: env_1.env.GEMINI_API_KEY,
+    // Note: Depending on the exact SDK version/options, 
+    // baseUrl mapping might require custom fetch or specific instantiation config.
+    // Using native fetch or overriding baseUrl here ensures routing via Cloudflare.
+});
+/**
+ * PHASE 0: SKILL CLASSIFICATION
+ * Determines which specific skill sets are needed for the user's task.
+ */
+async function selectRelevantSkills(taskDescription) {
+    const spinner = (0, ora_1.default)('Gemini 3.1 Pro is analyzing the required skills for this task...').start();
+    try {
+        const availableSkills = (0, contextLoader_1.getAvailableSkills)();
+        if (availableSkills.length === 0) {
+            spinner.succeed('No skills found in workspace. Proceeding without skills.');
+            return [];
+        }
+        const systemInstruction = `
+You are the Ceobe AI Skill Router.
+Your ONLY job is to analyze the user request and determine which internal skills are required.
+
+Available Skills:
+${availableSkills.join(', ')}
+
+User Request:
+${taskDescription}
+
+Analyze the request. Output ONLY a raw, comma-separated list of the exact skill names required. If none apply, output "none".
+Example: "cost-reducer, scalability, frontend-design"
+NO markdown, NO greetings, NO extra text.
+`;
+        const response = await ai.models.generateContent({
+            model: 'gemini-3.1-pro-preview',
+            contents: [{ role: 'user', parts: [{ text: systemInstruction }] }],
+            config: { temperature: 0.0 } // 0.0 for strict deterministic classification
+        });
+        const output = (response.text || '').trim();
+        if (output.toLowerCase() === 'none') {
+            spinner.succeed(chalk_1.default.green('Gemini selected NO specific skills.'));
+            return [];
+        }
+        const selected = output.split(',').map(s => s.trim()).filter(s => availableSkills.includes(s));
+        spinner.succeed(chalk_1.default.green(`Gemini selected skills: ${selected.join(', ')}`));
+        return selected;
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to route skills. Proceeding with base rules only.'));
+        return [];
+    }
+}
+async function generateBRD(taskDescription, selectedSkills = []) {
+    const spinner = (0, ora_1.default)('Gemini 3.1 Pro is analyzing the request and generating a Business Requirements Document...').start();
+    try {
+        const rules = (0, contextLoader_1.readCeobeRules)();
+        const skillsContext = selectedSkills.length > 0 ? (0, contextLoader_1.readSpecificSkills)(selectedSkills) : '';
+        const systemInstruction = `
+You are the Brain of the Ceobe AI Engineering System. You are a Senior Architect.
+STAGE 1: DISCOVERY & BRD.
+
+Adhere to these rules:
+${rules}
+
+${skillsContext}
+
+User Request:
+${taskDescription}
+
+Output ONLY the markdown Business Requirements Document (BRD). Do not output greetings or implementation steps yet. Focus on goals, target audience, and feature definitions.
+
+YOU MUST FORMAT YOUR OUTPUT EXACTLY ACCORDING TO THIS TEMPLATE:
+${(0, contextLoader_1.readTemplate)('brd-template.md')}
+`;
+        const response = await ai.models.generateContent({
+            model: 'gemini-3.1-pro-preview',
+            contents: [{ role: 'user', parts: [{ text: systemInstruction }] }],
+            config: { temperature: 0.2 }
+        });
+        spinner.succeed(chalk_1.default.green('Gemini 3.1 Pro successfully generated the BRD.'));
+        return response.text || '';
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Gemini 3.1 Pro failed to generate BRD.'));
+        throw error;
+    }
+}
+async function generateArchitecture(brdContent, selectedSkills = []) {
+    const spinner = (0, ora_1.default)('Gemini 3.1 Pro is designing the System Architecture...').start();
+    try {
+        const rules = (0, contextLoader_1.readCeobeRules)();
+        const skillsContext = selectedSkills.length > 0 ? (0, contextLoader_1.readSpecificSkills)(selectedSkills) : '';
+        const systemInstruction = `
+You are the Brain of the Ceobe AI Engineering System. You are a Senior Architect.
+STAGE 2: ARCHITECTURE DESIGN.
+
+Rules:
+${rules}
+
+${skillsContext}
+
+Current BRD Context:
+${brdContent}
+
+Output ONLY the markdown Architecture Document based on the constraints. Outline the tech stack, data schemas, and folder structures. Do not write full code.
+
+YOU MUST FORMAT YOUR OUTPUT EXACTLY ACCORDING TO THIS TEMPLATE:
+${(0, contextLoader_1.readTemplate)('architecture-template.md')}
+`;
+        const response = await ai.models.generateContent({
+            model: 'gemini-3.1-pro-preview',
+            contents: [{ role: 'user', parts: [{ text: systemInstruction }] }],
+            config: { temperature: 0.2 }
+        });
+        spinner.succeed(chalk_1.default.green('Gemini 3.1 Pro successfully generated the Architecture Plan.'));
+        return response.text || '';
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Gemini 3.1 Pro failed to generate Architecture Plan.'));
+        throw error;
+    }
+}
+async function generateImplementationPlan(architectureContent, selectedSkills = []) {
+    const spinner = (0, ora_1.default)('Gemini 3.1 Pro is generating the Execution Checklist...').start();
+    try {
+        const rules = (0, contextLoader_1.readCeobeRules)();
+        const skillsContext = selectedSkills.length > 0 ? (0, contextLoader_1.readSpecificSkills)(selectedSkills) : '';
+        const systemInstruction = `
+You are the Brain of the Ceobe AI Engineering System. You are a Senior Architect.
+STAGE 3: IMPLEMENTATION / SPRINT PLANNING.
+
+Rules:
+${rules}
+
+${skillsContext}
+
+Current Architecture Plan Context:
+${architectureContent}
+
+Output ONLY the markdown execution checklist (a Jira-like task list). Detail what file paths to create/edit and exactly what code Claude should write in each file.
+
+YOU MUST FORMAT YOUR OUTPUT EXACTLY ACCORDING TO THIS TEMPLATE:
+${(0, contextLoader_1.readTemplate)('tasks-template.md')}
+`;
+        const response = await ai.models.generateContent({
+            model: 'gemini-3.1-pro-preview',
+            contents: [{ role: 'user', parts: [{ text: systemInstruction }] }],
+            config: { temperature: 0.2 }
+        });
+        spinner.succeed(chalk_1.default.green('Gemini 3.1 Pro successfully generated the Execution Checklist.'));
+        return response.text || '';
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Gemini 3.1 Pro failed to generate Checklist.'));
+        throw error;
+    }
+}
+async function auditPlan(combinedContent, selectedSkills = []) {
+    const spinner = (0, ora_1.default)('Gemini 3.1 Pro is auditing the project plans for conflicts and rule violations...').start();
+    try {
+        const rules = (0, contextLoader_1.readCeobeRules)();
+        const skillsContext = selectedSkills.length > 0 ? (0, contextLoader_1.readSpecificSkills)(selectedSkills) : '';
+        const systemInstruction = `
+You are the Lead Quality Assurance Auditor for the Ceobe AI Engineering System.
+STAGE 4: PLAN AUDIT & VALIDATION.
+
+Rules:
+${rules}
+
+${skillsContext}
+
+Below is the combined content of the BRD, Architecture, and Task execution plan that the user has manually reviewed and potentially edited.
+
+Combined Content:
+${combinedContent}
+
+Your Job:
+1. Verify if the Architecture contradicts the BRD.
+2. Verify if the Task List executes everything required by the Architecture.
+3. Verify if anything in the plans violates the core Ceobe Engineering Rules or the provided Skills constraints (e.g. using npm when bun-developer is active).
+
+If the plans are 100% solid and ready for execution, reply ABSOLUTELY ONLY with the word: "APPROVED".
+If there are critical conflicts, bugs, or missing steps, reply with a markdown list of the mandatory changes needed. Do NOT say "APPROVED" if there are warnings.
+`;
+        const response = await ai.models.generateContent({
+            model: 'gemini-3.1-pro-preview',
+            contents: [{ role: 'user', parts: [{ text: systemInstruction }] }],
+            config: { temperature: 0.1 }
+        });
+        const output = (response.text || '').trim();
+        if (output === 'APPROVED') {
+            spinner.succeed(chalk_1.default.green('Audit PASSED. Project blueprint is solid and ready for execution.'));
+            return true;
+        }
+        else {
+            spinner.warn(chalk_1.default.yellow('Audit FAILED. Conflicts or missing steps detected.'));
+            console.log(chalk_1.default.cyan(`\\n--- Auditor Feedback ---\\n`));
+            console.log(output);
+            console.log(chalk_1.default.cyan(`\\n-------------------------\\n`));
+            return false;
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Gemini 3.1 Pro failed to audit the plans.'));
+        throw error;
+    }
+}

package/dist/ai/tools/systemTools.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tools = void 0;
+exports.handleToolCall = handleToolCall;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const env_1 = require("../../config/env");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+exports.tools = [
+    {
+        name: 'read_file',
+        description: 'Reads the content of a file. Returns the file content as a string.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute or relative path to the file to read. (e.g. src/index.ts or D:/path/to/file)'
+                }
+            },
+            required: ['file_path']
+        }
+    },
+    {
+        name: 'write_file',
+        description: 'Writes content to a file. Overwrites the file if it exists, creates it if it does not. Also creates necessary parent directories.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute or relative path to the file to write.'
+                },
+                content: {
+                    type: 'string',
+                    description: 'The full content to write to the file.'
+                }
+            },
+            required: ['file_path', 'content']
+        }
+    },
+    {
+        name: 'execute_command',
+        description: 'Executes a bash/PowerShell command on the host system. Returns stdout and stderr.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string',
+                    description: 'The terminal command to run (e.g., npm install express, tsc, dir)'
+                }
+            },
+            required: ['command']
+        }
+    }
+];
+// Helper to resolve paths against the workspace root if they are relative
+function resolvePath(filePath) {
+    if (path.isAbsolute(filePath)) {
+        return filePath;
+    }
+    return path.join(env_1.env.TARGET_PROJECT_DIR, filePath);
+}
+async function handleToolCall(toolName, input) {
+    try {
+        switch (toolName) {
+            case 'read_file': {
+                const fullPath = resolvePath(input.file_path);
+                if (!fs.existsSync(fullPath)) {
+                    return `Error: File not found at ${fullPath}`;
+                }
+                return fs.readFileSync(fullPath, 'utf8');
+            }
+            case 'write_file': {
+                const fullPath = resolvePath(input.file_path);
+                const dir = path.dirname(fullPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                fs.writeFileSync(fullPath, input.content, 'utf8');
+                return `Successfully wrote to ${fullPath}`;
+            }
+            case 'execute_command': {
+                // Caution: In a real secure environment, commands must be sandboxed or require user approval.
+                // For this AI engineering system, we allow execution within the workspace context.
+                const { stdout, stderr } = await execAsync(input.command, { cwd: env_1.env.TARGET_PROJECT_DIR });
+                let result = '';
+                if (stdout)
+                    result += `STDOUT:\n${stdout}\n`;
+                if (stderr)
+                    result += `STDERR:\n${stderr}\n`;
+                return result || 'Command executed successfully with no output.';
+            }
+            default:
+                return `Error: Tool ${toolName} not recognized.`;
+        }
+    }
+    catch (error) {
+        return `Error executing ${toolName}: ${error.message}`;
+    }
+}

package/dist/config/env.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
+exports.loadEnv = loadEnv;
+const dotenv_1 = __importDefault(require("dotenv"));
+const chalk_1 = __importDefault(require("chalk"));
+// Load environment variables from .env file
+dotenv_1.default.config();
+const path_1 = __importDefault(require("path"));
+function loadEnv() {
+    const missingKeys = [];
+    const getEnv = (key) => {
+        const value = process.env[key];
+        if (!value) {
+            missingKeys.push(key);
+            return '';
+        }
+        return value;
+    };
+    const config = {
+        CLOUDFLARE_ACCOUNT_ID: getEnv('CLOUDFLARE_ACCOUNT_ID'),
+        CLOUDFLARE_GATEWAY_ID: getEnv('CLOUDFLARE_GATEWAY_ID'),
+        GEMINI_API_KEY: getEnv('GEMINI_API_KEY'),
+        ANTHROPIC_API_KEY: getEnv('ANTHROPIC_API_KEY'),
+        // The location of Ceobe's brain (skills, templates, rules)
+        CEOEBE_INSTALL_DIR: process.env.CEOEBE_INSTALL_DIR || path_1.default.resolve(__dirname, '../../'),
+        // The user's current terminal directory where code is written
+        TARGET_PROJECT_DIR: process.cwd(),
+    };
+    if (missingKeys.length > 0) {
+        console.error(chalk_1.default.red(`[Error] Missing required environment variables:`));
+        missingKeys.forEach(key => console.error(chalk_1.default.red(`  - ${key}`)));
+        console.error(chalk_1.default.yellow(`\nPlease set them in your .env file or system environment variables.`));
+        process.exit(1);
+    }
+    return config;
+}
+exports.env = loadEnv();

package/dist/index.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const env_1 = require("./config/env");
+const planner_1 = require("./ai/planner");
+const executor_1 = require("./ai/executor");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const program = new commander_1.Command();
+program
+    .name('ceobe')
+    .description('Ceobe CLI: An AI Engineering orchestrator using Gemini 3.1 Pro and Sonnet 4.6 via Cloudflare AI Gateway.')
+    .version('1.0.0');
+program
+    .command('plan <description>')
+    .description('Phase 1: Generate BRD, Architecture, and Task Plan for review.')
+    .action(async (description) => {
+    console.log(chalk_1.default.blue(`Planning project with description: ${description}`));
+    console.log(chalk_1.default.gray(`Workspace: ${env_1.env.TARGET_PROJECT_DIR}\n`));
+    try {
+        const ceobeDir = path.join(env_1.env.TARGET_PROJECT_DIR, '.ceobe');
+        if (!fs.existsSync(ceobeDir))
+            fs.mkdirSync(ceobeDir, { recursive: true });
+        const selectedSkills = await (0, planner_1.selectRelevantSkills)(description);
+        const brd = await (0, planner_1.generateBRD)(description, selectedSkills);
+        fs.writeFileSync(path.join(ceobeDir, 'brd.md'), brd);
+        const arch = await (0, planner_1.generateArchitecture)(brd, selectedSkills);
+        fs.writeFileSync(path.join(ceobeDir, 'architecture.md'), arch);
+        const plan = await (0, planner_1.generateImplementationPlan)(arch, selectedSkills);
+        fs.writeFileSync(path.join(ceobeDir, 'task.md'), plan);
+        console.log(chalk_1.default.magenta(`\n[Planning Phase Complete] Documents saved to .ceobe/ folder.`));
+        console.log(chalk_1.default.yellow(`Please review brd.md, architecture.md, and task.md.`));
+        console.log(chalk_1.default.green(`Once approved, run: npx ceobe execute\n`));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('\n[Error] Project planning failed.'));
+        console.error(err);
+    }
+});
+program
+    .command('execute [taskFile]')
+    .description('Phase 2: Execute a generated task plan (default: task.md).')
+    .action(async (taskFile = 'task.md') => {
+    console.log(chalk_1.default.blue(`Executing plan from: .ceobe/${taskFile}`));
+    try {
+        const taskPath = path.join(env_1.env.TARGET_PROJECT_DIR, '.ceobe', taskFile);
+        if (!fs.existsSync(taskPath)) {
+            console.error(chalk_1.default.red(`\n[Error] Task file not found at ${taskPath}`));
+            console.error(chalk_1.default.yellow(`Did you forget to run 'ceobe plan' first?\n`));
+            return;
+        }
+        const planContent = fs.readFileSync(taskPath, 'utf8');
+        console.log(chalk_1.default.magenta(`\n[Execution Phase Started. Firing up Sonnet 4.6]\n`));
+        await (0, executor_1.executePlan)(planContent);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('\n[Error] Execution failed.'));
+        console.error(err);
+    }
+});
+program
+    .command('audit [prefix]')
+    .description('Phase 1.5: Audit your edited plans for conflicts before execution. Prefix is empty for new projects, or "feature-" for features.')
+    .action(async (prefix = '') => {
+    console.log(chalk_1.default.blue(`Auditing plans in .ceobe/ folder with prefix '${prefix}'...`));
+    try {
+        const ceobeDir = path.join(env_1.env.TARGET_PROJECT_DIR, '.ceobe');
+        const brdPath = path.join(ceobeDir, prefix ? `${prefix}brd.md` : 'brd.md');
+        const archPath = path.join(ceobeDir, prefix ? `${prefix}architecture.md` : 'architecture.md');
+        const taskPath = path.join(ceobeDir, prefix ? `${prefix}task.md` : 'task.md');
+        if (!fs.existsSync(brdPath) || !fs.existsSync(archPath) || !fs.existsSync(taskPath)) {
+            console.error(chalk_1.default.red(`\n[Error] Missing plan files in ${ceobeDir}. Expected brd, architecture, and task files.`));
+            return;
+        }
+        const combinedContent = `
+--- BRD ---
+${fs.readFileSync(brdPath, 'utf8')}
+--- ARCHITECTURE ---
+${fs.readFileSync(archPath, 'utf8')}
+--- TASK PLAN ---
+${fs.readFileSync(taskPath, 'utf8')}
+      `;
+        // Simple heuristic: read the BRD description to guess the skills again
+        const briefDescription = fs.readFileSync(brdPath, 'utf8').substring(0, 500);
+        const selectedSkills = await (0, planner_1.selectRelevantSkills)(briefDescription);
+        const passed = await (0, planner_1.auditPlan)(combinedContent, selectedSkills);
+        if (passed) {
+            console.log(chalk_1.default.green(`\nYou are cleared to run: npx ceobe execute ${prefix ? prefix + 'task.md' : ''}\n`));
+        }
+        else {
+            console.log(chalk_1.default.yellow(`\nPlease fix the above issues in your markdown files, then run 'ceobe audit' again.\n`));
+        }
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('\n[Error] Audit failed.'));
+        console.error(err);
+    }
+});
+program
+    .command('build-feature <description>')
+    .description('Build a new feature following Ceobe engineering rules.')
+    .action(async (description) => {
+    console.log(chalk_1.default.blue(`Building feature with description: ${description}`));
+    console.log(chalk_1.default.gray(`Workspace: ${env_1.env.TARGET_PROJECT_DIR}\n`));
+    try {
+        const ceobeDir = path.join(env_1.env.TARGET_PROJECT_DIR, '.ceobe');
+        if (!fs.existsSync(ceobeDir))
+            fs.mkdirSync(ceobeDir, { recursive: true });
+        const selectedSkills = await (0, planner_1.selectRelevantSkills)(description);
+        const brd = await (0, planner_1.generateBRD)(description, selectedSkills);
+        fs.writeFileSync(path.join(ceobeDir, 'feature-brd.md'), brd);
+        const arch = await (0, planner_1.generateArchitecture)(brd, selectedSkills);
+        fs.writeFileSync(path.join(ceobeDir, 'feature-architecture.md'), arch);
+        const plan = await (0, planner_1.generateImplementationPlan)(arch, selectedSkills);
+        fs.writeFileSync(path.join(ceobeDir, 'feature-task.md'), plan);
+        console.log(chalk_1.default.magenta(`\n[Feature Blueprint Complete] Documents saved to .ceobe/ folder.`));
+        console.log(chalk_1.default.yellow(`Please review feature-brd.md, feature-architecture.md, and feature-task.md.`));
+        console.log(chalk_1.default.green(`Once approved, run: npx ceobe execute feature-task.md\n`));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('\n[Error] Feature build failed.'));
+        console.error(err);
+    }
+});
+// Parse the arguments
+program.parse(process.argv);
+// If no arguments passed, show help
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}