task-o-matic-core 0.1.0

package/dist/lib/context-builder.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextBuilder = void 0;
+exports.createDefaultContextCallbacks = createDefaultContextCallbacks;
+const path_1 = require("path");
+const config_1 = require("./config");
+const fs_1 = require("fs");
+const logger_1 = require("./logger");
+function createDefaultContextCallbacks() {
+    return {
+        readFile: async (path) => {
+            if ((0, fs_1.existsSync)(path)) {
+                return (0, fs_1.readFileSync)(path, "utf-8");
+            }
+            return null;
+        },
+        fileExists: async (path) => {
+            return (0, fs_1.existsSync)(path);
+        },
+        listFiles: async (dir) => {
+            if ((0, fs_1.existsSync)(dir) && (0, fs_1.statSync)(dir).isDirectory()) {
+                return (0, fs_1.readdirSync)(dir);
+            }
+            return [];
+        },
+        stat: async (path) => {
+            if ((0, fs_1.existsSync)(path)) {
+                const stats = (0, fs_1.statSync)(path);
+                return {
+                    mtime: stats.mtime.getTime(),
+                    isDirectory: stats.isDirectory(),
+                };
+            }
+            return null;
+        },
+    };
+}
+class ContextBuilder {
+    storage;
+    callbacks;
+    taskOMatic = null;
+    initialized = false;
+    constructor(storage, callbacks) {
+        this.storage = storage;
+        this.callbacks = callbacks || createDefaultContextCallbacks();
+    }
+    ensureInitialized() {
+        if (this.initialized) {
+            return;
+        }
+        this.taskOMatic = config_1.configManager.getTaskOMaticDir();
+        this.initialized = true;
+    }
+    /**
+     * Build comprehensive context for AI operations
+     */
+    async buildContext(taskId) {
+        this.ensureInitialized();
+        const task = await this.storage.getTask(taskId);
+        if (!task) {
+            throw new Error(`Task with ID ${taskId} not found`);
+        }
+        const stack = await this.getStackConfig();
+        const documentation = this.getTaskDocumentation(task);
+        const fullContent = await this.getTaskFullContent(task);
+        const prdContent = task.prdFile
+            ? await this.getPRDContent(task.prdFile)
+            : await this.getRelevantPRDContent(task.title, task.description);
+        return {
+            task: {
+                id: task.id,
+                title: task.title,
+                description: task.description ?? "",
+                fullContent,
+            },
+            stack,
+            documentation: documentation
+                ? {
+                    recap: documentation.recap,
+                    files: documentation.files.map((file) => ({
+                        path: file,
+                        // Content loading is skipped as per original code comment
+                    })),
+                }
+                : undefined,
+            existingContent: documentation?.recap,
+            prdContent,
+            existingResearch: documentation?.research || {},
+        };
+    }
+    /**
+     * Build context for new tasks (without requiring existing task)
+     */
+    async buildContextForNewTask(title, description, prdFile) {
+        this.ensureInitialized();
+        const stack = await this.getStackConfig();
+        const prdContent = prdFile
+            ? await this.getPRDContent(prdFile)
+            : await this.getRelevantPRDContent(title, description);
+        return {
+            task: {
+                id: "new-task",
+                title,
+                description: description ?? "",
+                fullContent: undefined,
+            },
+            stack,
+            documentation: undefined, // New tasks don't have documentation yet
+            existingContent: undefined,
+            prdContent,
+        };
+    }
+    /**
+     * Get stack configuration from project (set by bootstrap)
+     */
+    async getStackConfig() {
+        if (!this.taskOMatic) {
+            return undefined;
+        }
+        // Return sensible defaults for Better-T-Stack
+        const fallbackConfig = {
+            projectName: "default",
+            frontend: "next",
+            backend: "convex",
+            database: "none", // Convex has its own database
+            auth: "better-auth",
+            runtime: "none",
+            api: "none",
+            payments: "none",
+            orm: "none", // Convex doesn't use ORM
+            dbSetup: "none",
+            packageManager: "npm",
+            git: true,
+            webDeploy: "none",
+            serverDeploy: "none",
+            install: true,
+            addons: ["turborepo"],
+            examples: [],
+        };
+        try {
+            const stackFile = (0, path_1.join)(this.taskOMatic, "stack.json");
+            const content = await this.callbacks.readFile(stackFile);
+            if (content) {
+                const config = JSON.parse(content);
+                config._source = "file"; // Track source
+                return config;
+            }
+            fallbackConfig._source = "fallback"; // Track source
+            return fallbackConfig;
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to load stack configuration, using defaults: ${error}`);
+            fallbackConfig._source = "fallback"; // Track source
+            return fallbackConfig;
+        }
+    }
+    /**
+     * Get task documentation references
+     */
+    getTaskDocumentation(task) {
+        return task.documentation;
+    }
+    /**
+     * Get full task content from MD file
+     */
+    async getTaskFullContent(task) {
+        if (!task.contentFile || !this.taskOMatic) {
+            return undefined;
+        }
+        try {
+            const contentPath = (0, path_1.join)(this.taskOMatic, task.contentFile);
+            return (await this.callbacks.readFile(contentPath)) || undefined;
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to read task content file ${task.contentFile}: ${error}`);
+        }
+        return undefined;
+    }
+    /**
+     * Read documentation file content
+     */
+    async readDocumentationFile(filePath) {
+        if (!this.taskOMatic) {
+            return `# ContextBuilder Not Initialized\n\nFile: ${filePath}\n\nContextBuilder has not been properly initialized.`;
+        }
+        try {
+            const fullPath = (0, path_1.join)(this.taskOMatic, filePath);
+            const content = await this.callbacks.readFile(fullPath);
+            if (content) {
+                return content;
+            }
+            return `# Documentation File Not Found\n\nFile: ${filePath}\n\nThis documentation file could not be found on disk.`;
+        }
+        catch (error) {
+            return `# Error Reading Documentation\n\nFile: ${filePath}\n\nError: ${error instanceof Error ? error.message : "Unknown error"}`;
+        }
+    }
+    /**
+     * Check if documentation is fresh (less than 7 days old)
+     */
+    isDocumentationFresh(documentation) {
+        const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+        return documentation.lastFetched > sevenDaysAgo;
+    }
+    /**
+     * Check if documentation is stale (more than 30 days old)
+     */
+    isDocumentationStale(documentation) {
+        const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1000;
+        return documentation.lastFetched < thirtyDaysAgo;
+    }
+    /**
+     * Get PRD content from file path
+     */
+    async getPRDContent(prdFile) {
+        if (!this.taskOMatic) {
+            return undefined;
+        }
+        try {
+            // Handle relative paths from .task-o-matic directory
+            const fullPath = prdFile.startsWith("/")
+                ? prdFile
+                : (0, path_1.join)(this.taskOMatic, prdFile);
+            return (await this.callbacks.readFile(fullPath)) || undefined;
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to read PRD file ${prdFile}: ${error}`);
+            return undefined;
+        }
+    }
+    /**
+     * Get relevant PRD content based on task title/description
+     */
+    async getRelevantPRDContent(taskTitle, taskDescription) {
+        if (!this.taskOMatic)
+            return undefined;
+        // Look for PRD files in known locations
+        const prdPaths = [
+            (0, path_1.join)(this.taskOMatic, "prd"),
+            (0, path_1.join)(this.taskOMatic, "..", "docs"),
+            (0, path_1.join)(config_1.configManager.getWorkingDirectory(), ".task-o-matic", "prd"),
+            (0, path_1.join)(config_1.configManager.getWorkingDirectory(), "prd"),
+            (0, path_1.join)(config_1.configManager.getWorkingDirectory(), "docs"),
+        ];
+        for (const prdPath of prdPaths) {
+            if (await this.callbacks.fileExists(prdPath)) {
+                try {
+                    // Look for ANY text files in PRD directory
+                    const files = await this.callbacks.listFiles(prdPath);
+                    const prdFiles = files.filter((f) => f.endsWith(".md") || f.endsWith(".txt"));
+                    if (prdFiles.length > 0) {
+                        // Get the MOST RECENT PRD file by modification time
+                        const prdFilesWithStats = await Promise.all(prdFiles.map(async (file) => {
+                            const path = (0, path_1.join)(prdPath, file);
+                            const stats = await this.callbacks.stat(path);
+                            return {
+                                file,
+                                path,
+                                mtime: stats ? stats.mtime : 0,
+                            };
+                        }));
+                        prdFilesWithStats.sort((a, b) => b.mtime - a.mtime); // Sort by newest first
+                        const mostRecentPrd = prdFilesWithStats[0];
+                        return ((await this.callbacks.readFile(mostRecentPrd.path)) || undefined);
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.warn(`Failed to read PRD directory ${prdPath}: ${error}`);
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Format context for AI prompts
+     */
+    formatContextForAI(context) {
+        let formatted = `# Task Context\n\n`;
+        formatted += `## Task Information\n`;
+        formatted += `- **ID**: ${context.task.id}\n`;
+        formatted += `- **Title**: ${context.task.title}\n`;
+        formatted += `- **Description**: ${context.task.description}\n`;
+        if (context.task.fullContent) {
+            formatted += `- **Full Content**:\n${context.task.fullContent}\n\n`;
+        }
+        if (context.prdContent) {
+            formatted += `## Product Requirements Document\n`;
+            formatted += `${context.prdContent}\n\n`;
+        }
+        if (context.stack) {
+            formatted += `## Technology Stack\n`;
+            formatted += `- **Project**: ${context.stack.projectName}\n`;
+            formatted += `- **Frontend**: ${context.stack.frontend}\n`;
+            formatted += `- **Backend**: ${context.stack.backend}\n`;
+            if (context.stack.database !== "none") {
+                formatted += `- **Database**: ${context.stack.database}\n`;
+            }
+            if (context.stack.orm !== "none") {
+                formatted += `- **ORM**: ${context.stack.orm}\n`;
+            }
+            formatted += `- **Auth**: ${context.stack.auth}\n`;
+            if (context.stack.addons.length > 0) {
+                formatted += `- **Addons**: ${context.stack.addons.join(", ")}\n`;
+            }
+            formatted += `- **Package Manager**: ${context.stack.packageManager}\n`;
+            formatted += `\n`;
+        }
+        if (context.documentation) {
+            formatted += `## Available Documentation\n`;
+            formatted += `**Recap**: ${context.documentation.recap}\n\n`;
+            if (context.documentation.files.length > 0) {
+                formatted += `### Documentation Files\n\n`;
+                context.documentation.files.forEach((file, index) => {
+                    formatted += `#### ${index + 1}. ${file.path}\n`;
+                    // formatted += `${file.content}\n\n`;
+                });
+            }
+        }
+        return formatted;
+    }
+}
+exports.ContextBuilder = ContextBuilder;

package/dist/lib/executors/claude-code-executor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutorConfig, ExternalExecutor } from "../../types";
+export declare class ClaudeCodeExecutor implements ExternalExecutor {
+    name: string;
+    private config?;
+    constructor(config?: ExecutorConfig);
+    supportsSessionResumption(): boolean;
+    execute(message: string, dry?: boolean, config?: ExecutorConfig): Promise<void>;
+}
+//# sourceMappingURL=claude-code-executor.d.ts.map

package/dist/lib/executors/claude-code-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code-executor.d.ts","sourceRoot":"","sources":["../../../src/lib/executors/claude-code-executor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpE,qBAAa,kBAAmB,YAAW,gBAAgB;IACzD,IAAI,SAAY;IAChB,OAAO,CAAC,MAAM,CAAC,CAAiB;gBAEpB,MAAM,CAAC,EAAE,cAAc;IAInC,yBAAyB,IAAI,OAAO;IAI9B,OAAO,CACX,OAAO,EAAE,MAAM,EACf,GAAG,GAAE,OAAe,EACpB,MAAM,CAAC,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC;CA6DjB"}

package/dist/lib/executors/claude-code-executor.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCodeExecutor = void 0;
+const node_child_process_1 = require("node:child_process");
+const logger_1 = require("../logger");
+class ClaudeCodeExecutor {
+    name = "claude";
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    supportsSessionResumption() {
+        return true;
+    }
+    async execute(message, dry = false, config) {
+        // Merge constructor config with execution config (execution takes precedence)
+        const finalConfig = { ...this.config, ...config };
+        // Build arguments array
+        const args = [];
+        // Add model if specified
+        if (finalConfig.model) {
+            args.push("--model", finalConfig.model);
+            logger_1.logger.progress(`🤖 Using model: ${finalConfig.model}`);
+        }
+        // Add session resumption if specified
+        if (finalConfig.continueLastSession) {
+            args.push("-c");
+            logger_1.logger.progress("🔄 Continuing last session");
+        }
+        else if (finalConfig.sessionId) {
+            args.push("-r", finalConfig.sessionId);
+            logger_1.logger.progress(`🔄 Resuming session: ${finalConfig.sessionId}`);
+        }
+        // Add --print for non-interactive mode (required for automation)
+        // args.push("-p");
+        // Auto-approve file edits for automation
+        args.push("--permission-mode", "acceptEdits");
+        // Add prompt as positional argument
+        args.push(message);
+        if (dry) {
+            logger_1.logger.progress(`🔧 Using executor: ${this.name}`);
+            logger_1.logger.progress(`claude ${args.join(" ")}`);
+            return;
+        }
+        // Launch claude and wait for it to complete
+        const child = (0, node_child_process_1.spawn)("claude", args, {
+            stdio: "inherit", // Give tool full terminal control
+        });
+        // Wait for completion (blocking)
+        await new Promise((resolve, reject) => {
+            child.on("close", (code) => {
+                if (code === 0) {
+                    logger_1.logger.success("✅ Claude Code execution completed successfully");
+                    resolve();
+                }
+                else {
+                    const error = new Error(`Claude Code exited with code ${code}`);
+                    logger_1.logger.error(`❌ ${error.message}`);
+                    reject(error);
+                }
+            });
+            child.on("error", (error) => {
+                logger_1.logger.error(`❌ Failed to launch Claude Code: ${error.message}`);
+                reject(error);
+            });
+        });
+    }
+}
+exports.ClaudeCodeExecutor = ClaudeCodeExecutor;

package/dist/lib/executors/codex-executor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutorConfig, ExternalExecutor } from "../../types";
+export declare class CodexExecutor implements ExternalExecutor {
+    name: string;
+    private config?;
+    constructor(config?: ExecutorConfig);
+    supportsSessionResumption(): boolean;
+    execute(message: string, dry?: boolean, config?: ExecutorConfig): Promise<void>;
+}
+//# sourceMappingURL=codex-executor.d.ts.map

package/dist/lib/executors/codex-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-executor.d.ts","sourceRoot":"","sources":["../../../src/lib/executors/codex-executor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpE,qBAAa,aAAc,YAAW,gBAAgB;IACpD,IAAI,SAAW;IACf,OAAO,CAAC,MAAM,CAAC,CAAiB;gBAEpB,MAAM,CAAC,EAAE,cAAc;IAInC,yBAAyB,IAAI,OAAO;IAI9B,OAAO,CACX,OAAO,EAAE,MAAM,EACf,GAAG,GAAE,OAAe,EACpB,MAAM,CAAC,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC;CA+DjB"}

package/dist/lib/executors/codex-executor.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexExecutor = void 0;
+const node_child_process_1 = require("node:child_process");
+const logger_1 = require("../logger");
+class CodexExecutor {
+    name = "codex";
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    supportsSessionResumption() {
+        return true;
+    }
+    async execute(message, dry = false, config) {
+        // Merge constructor config with execution config (execution takes precedence)
+        const finalConfig = { ...this.config, ...config };
+        // Build arguments array - structure depends on session resumption
+        const args = [];
+        // Add model via config if specified (codex uses -c for config overrides)
+        if (finalConfig.model) {
+            args.push("-c", `model="${finalConfig.model}"`);
+            logger_1.logger.progress(`🤖 Using model: ${finalConfig.model}`);
+        }
+        // Session resumption uses different subcommand
+        if (finalConfig.continueLastSession) {
+            // Use 'exec resume --last' subcommand
+            args.push("exec", "resume", "--last");
+            logger_1.logger.progress("🔄 Continuing last session");
+        }
+        else if (finalConfig.sessionId) {
+            // Use 'exec resume <session-id>' subcommand
+            args.push("exec", "resume", finalConfig.sessionId);
+            logger_1.logger.progress(`🔄 Resuming session: ${finalConfig.sessionId}`);
+        }
+        else {
+            // Normal execution
+            args.push("exec");
+        }
+        // Add full write access for automation
+        args.push("--sandbox", "workspace-write");
+        // Add prompt as positional argument
+        args.push(message);
+        if (dry) {
+            logger_1.logger.progress(`🔧 Using executor: ${this.name}`);
+            logger_1.logger.progress(`codex ${args.join(" ")}`);
+            return;
+        }
+        // Launch codex and wait for it to complete
+        const child = (0, node_child_process_1.spawn)("codex", args, {
+            stdio: "inherit", // Give tool full terminal control
+        });
+        // Wait for completion (blocking)
+        await new Promise((resolve, reject) => {
+            child.on("close", (code) => {
+                if (code === 0) {
+                    logger_1.logger.success("✅ Codex CLI execution completed successfully");
+                    resolve();
+                }
+                else {
+                    const error = new Error(`Codex CLI exited with code ${code}`);
+                    logger_1.logger.error(`❌ ${error.message}`);
+                    reject(error);
+                }
+            });
+            child.on("error", (error) => {
+                logger_1.logger.error(`❌ Failed to launch Codex CLI: ${error.message}`);
+                reject(error);
+            });
+        });
+    }
+}
+exports.CodexExecutor = CodexExecutor;

package/dist/lib/executors/executor-factory.d.ts

@@ -0,0 +1,5 @@
+import { ExternalExecutor, ExecutorTool, ExecutorConfig } from "../../types";
+export declare class ExecutorFactory {
+    static create(tool?: ExecutorTool, config?: ExecutorConfig): ExternalExecutor;
+}
+//# sourceMappingURL=executor-factory.d.ts.map

package/dist/lib/executors/executor-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor-factory.d.ts","sourceRoot":"","sources":["../../../src/lib/executors/executor-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAO7E,qBAAa,eAAe;IAC1B,MAAM,CAAC,MAAM,CACX,IAAI,GAAE,YAAyB,EAC/B,MAAM,CAAC,EAAE,cAAc,GACtB,gBAAgB;CAgBpB"}

package/dist/lib/executors/executor-factory.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutorFactory = void 0;
+const opencode_executor_1 = require("./opencode-executor");
+const claude_code_executor_1 = require("./claude-code-executor");
+const gemini_executor_1 = require("./gemini-executor");
+const codex_executor_1 = require("./codex-executor");
+const kilo_executor_1 = require("./kilo-executor");
+class ExecutorFactory {
+    static create(tool = "opencode", config) {
+        switch (tool) {
+            case "opencode":
+                return new opencode_executor_1.OpencodeExecutor(config);
+            case "claude":
+                return new claude_code_executor_1.ClaudeCodeExecutor(config);
+            case "gemini":
+                return new gemini_executor_1.GeminiExecutor(config);
+            case "codex":
+                return new codex_executor_1.CodexExecutor(config);
+            case "kilo":
+                return new kilo_executor_1.KiloExecutor(config);
+            default:
+                throw new Error(`Unknown executor tool: ${tool}`);
+        }
+    }
+}
+exports.ExecutorFactory = ExecutorFactory;

package/dist/lib/executors/gemini-executor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutorConfig, ExternalExecutor } from "../../types";
+export declare class GeminiExecutor implements ExternalExecutor {
+    name: string;
+    private config?;
+    constructor(config?: ExecutorConfig);
+    supportsSessionResumption(): boolean;
+    execute(message: string, dry?: boolean, config?: ExecutorConfig): Promise<void>;
+}
+//# sourceMappingURL=gemini-executor.d.ts.map

package/dist/lib/executors/gemini-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini-executor.d.ts","sourceRoot":"","sources":["../../../src/lib/executors/gemini-executor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpE,qBAAa,cAAe,YAAW,gBAAgB;IACrD,IAAI,SAAY;IAChB,OAAO,CAAC,MAAM,CAAC,CAAiB;gBAEpB,MAAM,CAAC,EAAE,cAAc;IAInC,yBAAyB,IAAI,OAAO;IAI9B,OAAO,CACX,OAAO,EAAE,MAAM,EACf,GAAG,GAAE,OAAe,EACpB,MAAM,CAAC,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC;CA0DjB"}

package/dist/lib/executors/gemini-executor.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiExecutor = void 0;
+const node_child_process_1 = require("node:child_process");
+const logger_1 = require("../logger");
+class GeminiExecutor {
+    name = "gemini";
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    supportsSessionResumption() {
+        return true;
+    }
+    async execute(message, dry = false, config) {
+        // Merge constructor config with execution config (execution takes precedence)
+        const finalConfig = { ...this.config, ...config };
+        // Build arguments array
+        const args = [];
+        // Add model if specified
+        if (finalConfig.model) {
+            args.push("-m", finalConfig.model);
+            logger_1.logger.progress(`🤖 Using model: ${finalConfig.model}`);
+        }
+        // Add session resumption if specified
+        if (finalConfig.continueLastSession) {
+            args.push("-r", "latest");
+            logger_1.logger.progress("🔄 Continuing last session");
+        }
+        else if (finalConfig.sessionId) {
+            args.push("-r", finalConfig.sessionId);
+            logger_1.logger.progress(`🔄 Resuming session: ${finalConfig.sessionId}`);
+        }
+        // Enable auto-approval of all tools (yolo mode) - required for file writes
+        args.push("--yolo");
+        // Add prompt as positional argument (the -p flag is deprecated)
+        args.push(message);
+        if (dry) {
+            logger_1.logger.progress(`🔧 Using executor: ${this.name}`);
+            logger_1.logger.progress(`gemini ${args.join(" ")}`);
+            return;
+        }
+        // Launch gemini and wait for it to complete
+        const child = (0, node_child_process_1.spawn)("gemini", args, {
+            stdio: "inherit", // Give tool full terminal control
+        });
+        // Wait for completion (blocking)
+        await new Promise((resolve, reject) => {
+            child.on("close", (code) => {
+                if (code === 0) {
+                    logger_1.logger.success("✅ Gemini CLI execution completed successfully");
+                    resolve();
+                }
+                else {
+                    const error = new Error(`Gemini CLI exited with code ${code}`);
+                    logger_1.logger.error(`❌ ${error.message}`);
+                    reject(error);
+                }
+            });
+            child.on("error", (error) => {
+                logger_1.logger.error(`❌ Failed to launch Gemini CLI: ${error.message}`);
+                reject(error);
+            });
+        });
+    }
+}
+exports.GeminiExecutor = GeminiExecutor;

package/dist/lib/executors/kilo-executor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutorConfig, ExternalExecutor } from "../../types";
+export declare class KiloExecutor implements ExternalExecutor {
+    name: string;
+    private config?;
+    constructor(config?: ExecutorConfig);
+    supportsSessionResumption(): boolean;
+    execute(message: string, dry?: boolean, config?: ExecutorConfig): Promise<void>;
+}
+//# sourceMappingURL=kilo-executor.d.ts.map

package/dist/lib/executors/kilo-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kilo-executor.d.ts","sourceRoot":"","sources":["../../../src/lib/executors/kilo-executor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpE,qBAAa,YAAa,YAAW,gBAAgB;IACnD,IAAI,SAAU;IACd,OAAO,CAAC,MAAM,CAAC,CAAiB;gBAEpB,MAAM,CAAC,EAAE,cAAc;IAInC,yBAAyB,IAAI,OAAO;IAI9B,OAAO,CACX,OAAO,EAAE,MAAM,EACf,GAAG,GAAE,OAAe,EACpB,MAAM,CAAC,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC;CA6DjB"}