@esotech/contextuate 2.0.0

package/dist/commands/install.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installAgentsCommand = installAgentsCommand;
+exports.installStandardsCommand = installStandardsCommand;
+exports.installToolsCommand = installToolsCommand;
+exports.installCommand = installCommand;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+// Get template source directory
+function getTemplateSource() {
+    let templateSource = path_1.default.join(__dirname, '../templates');
+    // Handle ts-node vs compiled paths
+    if (path_1.default.basename(path_1.default.join(__dirname, '..')) === 'src') {
+        templateSource = path_1.default.join(__dirname, '../../src/templates');
+    }
+    else if (path_1.default.basename(__dirname) === 'commands') {
+        templateSource = path_1.default.join(__dirname, '../templates');
+    }
+    if (!fs_extra_1.default.existsSync(templateSource)) {
+        templateSource = path_1.default.join(__dirname, '../../templates');
+    }
+    return templateSource;
+}
+// Discover available templates
+async function discoverTemplates() {
+    const templateSource = getTemplateSource();
+    const result = {
+        agents: [],
+        standards: [],
+        tools: [],
+    };
+    // Discover agents
+    const agentDir = path_1.default.join(templateSource, 'agents');
+    if (fs_extra_1.default.existsSync(agentDir)) {
+        const files = await fs_extra_1.default.readdir(agentDir);
+        result.agents = files
+            .filter(f => f.endsWith('.md'))
+            .map(f => f.replace('.md', ''));
+    }
+    // Discover language standards
+    const standardsDir = path_1.default.join(templateSource, 'templates/standards');
+    if (fs_extra_1.default.existsSync(standardsDir)) {
+        const files = await fs_extra_1.default.readdir(standardsDir);
+        result.standards = files
+            .filter(f => f.endsWith('.standards.md'))
+            .map(f => f.replace('.standards.md', ''));
+    }
+    // Discover tools
+    const toolsDir = path_1.default.join(templateSource, 'tools');
+    if (fs_extra_1.default.existsSync(toolsDir)) {
+        const files = await fs_extra_1.default.readdir(toolsDir);
+        result.tools = files
+            .filter(f => f.endsWith('.tool.md'))
+            .map(f => f.replace('.tool.md', ''));
+    }
+    return result;
+}
+// List available templates
+async function listTemplates() {
+    const templates = await discoverTemplates();
+    console.log(chalk_1.default.blue('\nAvailable Templates:\n'));
+    console.log(chalk_1.default.cyan('Agents:'));
+    if (templates.agents.length > 0) {
+        templates.agents.forEach(a => console.log(`  - ${a}`));
+    }
+    else {
+        console.log('  (none found)');
+    }
+    console.log(chalk_1.default.cyan('\nLanguage Standards:'));
+    if (templates.standards.length > 0) {
+        templates.standards.forEach(s => console.log(`  - ${s}`));
+    }
+    else {
+        console.log('  (none found)');
+    }
+    console.log(chalk_1.default.cyan('\nTools:'));
+    if (templates.tools.length > 0) {
+        templates.tools.forEach(t => console.log(`  - ${t}`));
+    }
+    else {
+        console.log('  (none found)');
+    }
+    console.log('');
+}
+// Copy helper
+async function copyFile(src, dest, force) {
+    const absSrc = path_1.default.resolve(src);
+    const absDest = path_1.default.resolve(dest);
+    if (absSrc === absDest) {
+        return false;
+    }
+    if (!fs_extra_1.default.existsSync(src)) {
+        console.log(chalk_1.default.red(`[ERROR] Source file missing: ${src}`));
+        return false;
+    }
+    if (fs_extra_1.default.existsSync(dest) && !force) {
+        console.log(chalk_1.default.yellow(`[SKIP] Already exists: ${dest}`));
+        return false;
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(dest));
+    await fs_extra_1.default.copy(src, dest);
+    console.log(chalk_1.default.green(`[OK] Installed: ${dest}`));
+    return true;
+}
+// Install agents
+async function installAgents(names, force) {
+    const templateSource = getTemplateSource();
+    const templates = await discoverTemplates();
+    let installed = 0;
+    for (const name of names) {
+        const normalized = name.toLowerCase().trim();
+        const matched = templates.agents.find(a => a.toLowerCase() === normalized);
+        if (matched) {
+            const src = path_1.default.join(templateSource, 'agents', `${matched}.md`);
+            const dest = path_1.default.join('docs/ai/agents', `${matched}.md`);
+            if (await copyFile(src, dest, force)) {
+                installed++;
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow(`[WARN] Agent "${name}" not found. Use --list to see available agents.`));
+        }
+    }
+    return installed;
+}
+// Install language standards
+async function installStandards(names, force) {
+    const templateSource = getTemplateSource();
+    const templates = await discoverTemplates();
+    let installed = 0;
+    for (const name of names) {
+        const normalized = name.toLowerCase().trim();
+        const matched = templates.standards.find(s => s.toLowerCase() === normalized);
+        if (matched) {
+            const src = path_1.default.join(templateSource, 'templates/standards', `${matched}.standards.md`);
+            const dest = path_1.default.join('docs/ai/standards', `${matched}.standards.md`);
+            if (await copyFile(src, dest, force)) {
+                installed++;
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow(`[WARN] Standard "${name}" not found. Use --list to see available standards.`));
+        }
+    }
+    return installed;
+}
+// Install tools
+async function installTools(names, force) {
+    const templateSource = getTemplateSource();
+    const templates = await discoverTemplates();
+    let installed = 0;
+    for (const name of names) {
+        const normalized = name.toLowerCase().trim();
+        const matched = templates.tools.find(t => t.toLowerCase() === normalized);
+        if (matched) {
+            const src = path_1.default.join(templateSource, 'tools', `${matched}.tool.md`);
+            const dest = path_1.default.join('docs/ai/.contextuate/tools', `${matched}.tool.md`);
+            if (await copyFile(src, dest, force)) {
+                installed++;
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow(`[WARN] Tool "${name}" not found. Use --list to see available tools.`));
+        }
+    }
+    return installed;
+}
+// Subcommand handlers
+async function installAgentsCommand(names, options) {
+    const templates = await discoverTemplates();
+    const useAll = options.all || names.includes('all');
+    const agentsToInstall = useAll ? templates.agents : names;
+    if (agentsToInstall.length === 0) {
+        console.log(chalk_1.default.yellow('No agents specified. Use "all" or provide agent names.'));
+        console.log(chalk_1.default.gray('Available agents:'));
+        templates.agents.forEach(a => console.log(`  - ${a}`));
+        return;
+    }
+    console.log(chalk_1.default.blue('\n[INFO] Installing agents...\n'));
+    const count = await installAgents(agentsToInstall, options.force || false);
+    console.log(chalk_1.default.green(`\n[OK] Installed ${count} agent(s)\n`));
+}
+async function installStandardsCommand(names, options) {
+    const templates = await discoverTemplates();
+    const useAll = options.all || names.includes('all');
+    const standardsToInstall = useAll ? templates.standards : names;
+    if (standardsToInstall.length === 0) {
+        console.log(chalk_1.default.yellow('No standards specified. Use "all" or provide language names.'));
+        console.log(chalk_1.default.gray('Available standards:'));
+        templates.standards.forEach(s => console.log(`  - ${s}`));
+        return;
+    }
+    console.log(chalk_1.default.blue('\n[INFO] Installing language standards...\n'));
+    const count = await installStandards(standardsToInstall, options.force || false);
+    console.log(chalk_1.default.green(`\n[OK] Installed ${count} standard(s)\n`));
+}
+async function installToolsCommand(names, options) {
+    const templates = await discoverTemplates();
+    const useAll = options.all || names.includes('all');
+    const toolsToInstall = useAll ? templates.tools : names;
+    if (toolsToInstall.length === 0) {
+        console.log(chalk_1.default.yellow('No tools specified. Use "all" or provide tool names.'));
+        console.log(chalk_1.default.gray('Available tools:'));
+        templates.tools.forEach(t => console.log(`  - ${t}`));
+        return;
+    }
+    console.log(chalk_1.default.blue('\n[INFO] Installing tools...\n'));
+    const count = await installTools(toolsToInstall, options.force || false);
+    console.log(chalk_1.default.green(`\n[OK] Installed ${count} tool(s)\n`));
+}
+// Main install command (flag style or interactive)
+async function installCommand(options) {
+    // Handle --list flag
+    if (options.list) {
+        await listTemplates();
+        return;
+    }
+    const templates = await discoverTemplates();
+    const force = options.force || false;
+    // Check if any flags were provided
+    const hasFlags = options.agents || options.standards || options.tools || options.all;
+    if (!hasFlags) {
+        // Interactive mode
+        try {
+            const { categories } = await inquirer_1.default.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'categories',
+                    message: 'What would you like to install?',
+                    choices: [
+                        { name: 'Agents (AI persona definitions)', value: 'agents' },
+                        { name: 'Language Standards (coding guidelines)', value: 'standards' },
+                        { name: 'Tools (AI tool guides)', value: 'tools' },
+                    ],
+                    validate: (answer) => {
+                        if (answer.length < 1) {
+                            return 'Select at least one category.';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            let selectedAgents = [];
+            let selectedStandards = [];
+            let selectedTools = [];
+            if (categories.includes('agents') && templates.agents.length > 0) {
+                const { agents } = await inquirer_1.default.prompt([
+                    {
+                        type: 'checkbox',
+                        name: 'agents',
+                        message: 'Select agents to install:',
+                        choices: [
+                            { name: 'Select All', value: '__all__' },
+                            new inquirer_1.default.Separator(),
+                            ...templates.agents.map(a => ({
+                                name: a.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' '),
+                                value: a,
+                            })),
+                        ],
+                    },
+                ]);
+                selectedAgents = agents.includes('__all__') ? templates.agents : agents;
+            }
+            if (categories.includes('standards') && templates.standards.length > 0) {
+                const { standards } = await inquirer_1.default.prompt([
+                    {
+                        type: 'checkbox',
+                        name: 'standards',
+                        message: 'Select language standards to install:',
+                        choices: [
+                            { name: 'Select All', value: '__all__' },
+                            new inquirer_1.default.Separator(),
+                            ...templates.standards.map(s => ({
+                                name: s.charAt(0).toUpperCase() + s.slice(1),
+                                value: s,
+                            })),
+                        ],
+                    },
+                ]);
+                selectedStandards = standards.includes('__all__') ? templates.standards : standards;
+            }
+            if (categories.includes('tools') && templates.tools.length > 0) {
+                const { tools } = await inquirer_1.default.prompt([
+                    {
+                        type: 'checkbox',
+                        name: 'tools',
+                        message: 'Select tools to install:',
+                        choices: [
+                            { name: 'Select All', value: '__all__' },
+                            new inquirer_1.default.Separator(),
+                            ...templates.tools.map(t => ({
+                                name: t.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' '),
+                                value: t,
+                            })),
+                        ],
+                    },
+                ]);
+                selectedTools = tools.includes('__all__') ? templates.tools : tools;
+            }
+            // Install selected items
+            let totalInstalled = 0;
+            if (selectedAgents.length > 0) {
+                console.log(chalk_1.default.blue('\n[INFO] Installing agents...'));
+                totalInstalled += await installAgents(selectedAgents, force);
+            }
+            if (selectedStandards.length > 0) {
+                console.log(chalk_1.default.blue('\n[INFO] Installing language standards...'));
+                totalInstalled += await installStandards(selectedStandards, force);
+            }
+            if (selectedTools.length > 0) {
+                console.log(chalk_1.default.blue('\n[INFO] Installing tools...'));
+                totalInstalled += await installTools(selectedTools, force);
+            }
+            console.log(chalk_1.default.green(`\n[OK] Installation complete. ${totalInstalled} file(s) installed.\n`));
+        }
+        catch (error) {
+            if (error.name === 'ExitPromptError' || error.message?.includes('User force closed')) {
+                console.log(chalk_1.default.yellow('\nInstallation cancelled.'));
+                process.exit(0);
+            }
+            throw error;
+        }
+    }
+    else {
+        // Flag-based mode
+        let totalInstalled = 0;
+        // Handle --all flag
+        if (options.all) {
+            console.log(chalk_1.default.blue('\n[INFO] Installing all templates...\n'));
+            totalInstalled += await installAgents(templates.agents, force);
+            totalInstalled += await installStandards(templates.standards, force);
+            totalInstalled += await installTools(templates.tools, force);
+        }
+        else {
+            // Handle individual flags
+            if (options.agents && options.agents.length > 0) {
+                const agentsToInstall = options.agents.includes('all') ? templates.agents : options.agents;
+                console.log(chalk_1.default.blue('\n[INFO] Installing agents...'));
+                totalInstalled += await installAgents(agentsToInstall, force);
+            }
+            if (options.standards && options.standards.length > 0) {
+                const standardsToInstall = options.standards.includes('all') ? templates.standards : options.standards;
+                console.log(chalk_1.default.blue('\n[INFO] Installing language standards...'));
+                totalInstalled += await installStandards(standardsToInstall, force);
+            }
+            if (options.tools && options.tools.length > 0) {
+                const toolsToInstall = options.tools.includes('all') ? templates.tools : options.tools;
+                console.log(chalk_1.default.blue('\n[INFO] Installing tools...'));
+                totalInstalled += await installTools(toolsToInstall, force);
+            }
+        }
+        console.log(chalk_1.default.green(`\n[OK] Installation complete. ${totalInstalled} file(s) installed.\n`));
+    }
+}

package/dist/commands/remove.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeCommand = removeCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+async function removeCommand(options) {
+    console.log(chalk_1.default.blue('╔════════════════════════════════════════╗'));
+    console.log(chalk_1.default.blue('║     Contextuate Cleanup                ║'));
+    console.log(chalk_1.default.blue('╚════════════════════════════════════════╝'));
+    console.log('');
+    // Define source directory for templates
+    let templateSource = path_1.default.join(__dirname, '../../docs/ai/.contextuate');
+    if (!fs_extra_1.default.existsSync(templateSource)) {
+        templateSource = path_1.default.join(__dirname, '../../../docs/ai/.contextuate');
+    }
+    if (!fs_extra_1.default.existsSync(templateSource)) {
+        console.error(chalk_1.default.red(`[ERROR] Could not find template source at ${templateSource}`));
+        return;
+    }
+    // Define jump files to check
+    const jumpFiles = [
+        { src: 'templates/platforms/CLAUDE.md', dest: 'CLAUDE.md' },
+        { src: 'templates/platforms/AGENTS.md', dest: 'AGENTS.md' },
+        { src: 'templates/platforms/GEMINI.md', dest: 'GEMINI.md' },
+        { src: 'templates/platforms/clinerules.md', dest: '.clinerules/cline-memory-bank.md' },
+        { src: 'templates/platforms/copilot.md', dest: '.github/copilot-instructions.md' },
+        { src: 'templates/platforms/cursor.mdc', dest: '.cursor/rules/project.mdc' },
+        { src: 'templates/platforms/windsurf.md', dest: '.windsurf/rules/project.md' },
+        { src: 'templates/platforms/antigravity.md', dest: '.antigravity/rules.md' },
+    ];
+    const calculateHash = async (filePath) => {
+        const content = await fs_extra_1.default.readFile(filePath);
+        return crypto_1.default.createHash('sha256').update(content).digest('hex');
+    };
+    console.log(chalk_1.default.blue('[INFO] Checking for unmodified jump files...'));
+    for (const file of jumpFiles) {
+        const templatePath = path_1.default.join(templateSource, file.src);
+        const destPath = path_1.default.resolve(file.dest);
+        if (fs_extra_1.default.existsSync(destPath)) {
+            if (fs_extra_1.default.existsSync(templatePath)) {
+                try {
+                    const templateHash = await calculateHash(templatePath);
+                    const destHash = await calculateHash(destPath);
+                    if (templateHash === destHash) {
+                        await fs_extra_1.default.remove(destPath);
+                        console.log(chalk_1.default.green(`[OK] Removed (unmodified): ${file.dest}`));
+                        // Clean up empty parent directories if applicable
+                        const dir = path_1.default.dirname(destPath);
+                        if (dir !== process.cwd()) {
+                            const files = await fs_extra_1.default.readdir(dir);
+                            if (files.length === 0) {
+                                await fs_extra_1.default.remove(dir);
+                                console.log(chalk_1.default.gray(`[CLEAN] Removed empty directory: ${path_1.default.relative(process.cwd(), dir)}`));
+                            }
+                        }
+                    }
+                    else {
+                        console.log(chalk_1.default.yellow(`[SKIP] Kept (modified): ${file.dest}`));
+                    }
+                }
+                catch (error) {
+                    console.error(chalk_1.default.red(`[ERROR] Failed to process ${file.dest}: ${error}`));
+                }
+            }
+            else {
+                console.warn(chalk_1.default.yellow(`[WARN] Template not found for comparison: ${file.src}`));
+            }
+        }
+    }
+    console.log('');
+    console.log(chalk_1.default.green('Cleanup complete!'));
+}

package/dist/commands/run.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const git_1 = require("../utils/git");
+const tokens_1 = require("../utils/tokens");
+// ... imports
+const driver_1 = require("../runtime/driver");
+async function runCommand(agentName, options) {
+    console.log(chalk_1.default.blue(`[INFO] Launching Agent: ${agentName}`));
+    if (options.goal) {
+        console.log(chalk_1.default.bold('Goal: ') + options.goal);
+    }
+    // 1. Locate the agent file
+    const agentPath = path_1.default.join(process.cwd(), 'docs/ai/agents', `${agentName}.md`);
+    if (!fs_extra_1.default.existsSync(agentPath)) {
+        console.error(chalk_1.default.red(`[ERROR] Agent definition not found at: ${agentPath}`));
+        console.log(chalk_1.default.yellow(`Available agents:`));
+        try {
+            const files = await fs_extra_1.default.readdir(path_1.default.join(process.cwd(), 'docs/ai/agents'));
+            files.forEach(f => {
+                if (f.endsWith('.md')) {
+                    console.log(`- ${f.replace('.md', '')}`);
+                }
+            });
+        }
+        catch (e) {
+            console.log(chalk_1.default.red('Could not list agents directory.'));
+        }
+        process.exit(1);
+    }
+    // 2. Parse the definition
+    let config;
+    try {
+        const fileContent = await fs_extra_1.default.readFile(agentPath, 'utf-8');
+        const parsed = (0, gray_matter_1.default)(fileContent);
+        config = parsed.data;
+        // Add default provider config if missing
+        if (!config.provider) {
+            config.provider = { type: 'mock', model: 'test' };
+        }
+        console.log(chalk_1.default.green(`[OK] Loaded agent definition`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('[ERROR] Failed to parse agent definition:'), error);
+        process.exit(1);
+    }
+    // 3. Prepare Runtime
+    const git = new git_1.GitManager(process.cwd());
+    const isGit = await git.isGitRepo();
+    let runtimeCwd = process.cwd();
+    let sessionId = Date.now().toString();
+    if (options.isolation === 'worktree') {
+        if (!isGit) {
+            console.error(chalk_1.default.red('[ERROR] --isolation=worktree require a git repository.'));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.blue('[INFO] Setting up Git Worktree...'));
+        try {
+            runtimeCwd = await git.createWorktree(config.name || agentName, sessionId);
+            console.log(chalk_1.default.green(`[OK] Worktree created at: ${runtimeCwd}`));
+        }
+        catch (e) {
+            console.error(chalk_1.default.red(`[ERROR] Failed to create worktree: ${e.message}`));
+            process.exit(1);
+        }
+    }
+    // 4. Simulate Execution (or Dry Run)
+    console.log(chalk_1.default.bold('\nAgent Runtime Environment:'));
+    console.log(`Working Directory: ${chalk_1.default.yellow(runtimeCwd)}`);
+    console.log(`Agent: ${config.name || agentName}`);
+    // Validate Configuration involves checking if requires fields exist
+    if (config.name && config.name !== agentName) {
+        console.warn(chalk_1.default.yellow(`[WARN] filename '${agentName}' does not match agent name '${config.name}'`));
+    }
+    console.log(chalk_1.default.bold('\nAgent Configuration:'));
+    console.log(`Name: ${config.name || agentName}`);
+    console.log(`Description: ${config.description || 'No description provided'}`);
+    if (config.capabilities && config.capabilities.length > 0) {
+        console.log(chalk_1.default.bold('\nCapabilities:'));
+        config.capabilities.forEach(cap => console.log(`- ${cap}`));
+    }
+    if (config.env && config.env.length > 0) {
+        console.log(chalk_1.default.bold('\nRequired Environment:'));
+        const missingEnv = [];
+        config.env.forEach(envVar => {
+            const exists = process.env[envVar] !== undefined;
+            const status = exists ? chalk_1.default.green('OK') : chalk_1.default.red('MISSING');
+            console.log(`- ${envVar}: ${status}`);
+            if (!exists)
+                missingEnv.push(envVar);
+        });
+        if (missingEnv.length > 0) {
+            console.warn(chalk_1.default.yellow(`[WARN] Missing ${missingEnv.length} environment variables.`));
+        }
+    }
+    const extraContext = [];
+    if (options.task) {
+        console.log(chalk_1.default.bold('\nTask Context:'));
+        const taskPath = path_1.default.join(process.cwd(), 'docs/ai/tasks', options.task);
+        if (!fs_extra_1.default.existsSync(taskPath)) {
+            console.error(chalk_1.default.red(`[ERROR] Task not found at: ${taskPath}`));
+            process.exit(1);
+        }
+        const scopeFile = path_1.default.join(taskPath, '00-project-scope.md');
+        if (fs_extra_1.default.existsSync(scopeFile)) {
+            console.log(`- Scope: ${chalk_1.default.green('FOUND')} (${scopeFile})`);
+            config.context = config.context || {};
+            config.context.files = config.context.files || [];
+            config.context.files.push(scopeFile);
+            extraContext.push(scopeFile);
+        }
+        else {
+            console.warn(chalk_1.default.yellow(`[WARN] Task scope not found: ${scopeFile}`));
+        }
+        // Find latest log
+        const logsDir = path_1.default.join(taskPath, 'logs');
+        if (fs_extra_1.default.existsSync(logsDir)) {
+            const logFiles = await fs_extra_1.default.readdir(logsDir);
+            const latestLog = logFiles.sort().reverse()[0];
+            if (latestLog) {
+                const logPath = path_1.default.join(logsDir, latestLog);
+                console.log(`- Latest Log: ${chalk_1.default.green('FOUND')} (${logPath})`);
+                config.context = config.context || {};
+                config.context.files = config.context.files || [];
+                config.context.files.push(logPath);
+                extraContext.push(logPath);
+            }
+        }
+    }
+    // Inject Project Structure Index if available
+    const indexFile = path_1.default.join(process.cwd(), 'docs/ai/project-structure.md');
+    if (await fs_extra_1.default.pathExists(indexFile)) {
+        console.log(`- Project Index: ${chalk_1.default.green('FOUND')} (${indexFile})`);
+        config.context = config.context || {};
+        config.context.files = config.context.files || [];
+        // Avoid duplicates
+        if (!config.context.files.includes(indexFile)) {
+            config.context.files.unshift(indexFile); // Add to beginning
+        }
+    }
+    if (config.context) {
+        console.log('\nLoading Context:');
+        // In a real implementation we would copy these files or process them
+        // For now we just verify they exist from the perspective of the runtimeCwd
+        const files = config.context.files || [];
+        let totalTokens = 0;
+        for (const file of files) {
+            // Check if absolute path (from task loading) or relative
+            const checkPath = path_1.default.isAbsolute(file) ? file : path_1.default.join(runtimeCwd, file);
+            const exists = await fs_extra_1.default.pathExists(checkPath);
+            const status = exists ? chalk_1.default.green('FOUND') : chalk_1.default.red('MISSING');
+            let fileTokens = 0;
+            if (exists) {
+                const content = await fs_extra_1.default.readFile(checkPath, 'utf-8');
+                fileTokens = (0, tokens_1.estimateTokens)(content);
+                totalTokens += fileTokens;
+            }
+            console.log(`- ${file}: ${status} (${fileTokens} tokens)`);
+        }
+        console.log(chalk_1.default.cyan(`\nTotal Context Size: ~${totalTokens} tokens`));
+        if (totalTokens > 32000) {
+            console.log(chalk_1.default.yellow(`[WARN] Context size is quite large (>32k). Consider removing files.`));
+        }
+        if (config.context.directories) {
+            config.context.directories.forEach(d => console.log(`- [DIR]  ${d}`));
+        }
+    }
+    if (!options.dryRun) {
+        // Here we would spawn the actual agent process or loop
+        console.log(chalk_1.default.magenta('\n*** AGENT EXECUTION STARTED ***'));
+        try {
+            const driver = new driver_1.LLMDriver({
+                provider: config.provider?.type || 'mock',
+                model: config.provider?.model || 'test',
+                capabilities: config.capabilities || []
+            }, options.goal || 'No explicit goal provided.', runtimeCwd, (config.context?.files || []).map(f => path_1.default.isAbsolute(f) ? f : path_1.default.join(runtimeCwd, f)));
+            await driver.run();
+        }
+        catch (e) {
+            console.error(chalk_1.default.red(`[ERROR] Execution failed: ${e.message}`));
+        }
+        console.log(chalk_1.default.magenta('*** AGENT EXECUTION FINISHED ***'));
+        // If worktree, ask to commit or verify
+        if (options.isolation === 'worktree') {
+            // For prototype, we just mention it
+            console.log(chalk_1.default.yellow(`\n[INFO] Worktree is preserved at: ${runtimeCwd}`));
+            console.log(`Inspect changes there, then delete with: git worktree remove "${runtimeCwd}"`);
+        }
+    }
+    else {
+        // Cleanup worktree immediately in dry-run to avoid litter
+        if (options.isolation === 'worktree') {
+            console.log(chalk_1.default.blue('\n[INFO] Cleaning up dry-run worktree...'));
+            await git.removeWorktree(runtimeCwd);
+            console.log(chalk_1.default.green('[OK] Worktree removed.'));
+        }
+    }
+}