task-o-matic-core 0.1.0

package/dist/lib/prompt-builder.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptBuilder = void 0;
+const prompt_registry_1 = require("./prompt-registry");
+const fs_1 = require("fs");
+const config_1 = require("./config");
+const ai_service_factory_1 = require("../utils/ai-service-factory");
+const path_1 = require("path");
+const logger_1 = require("./logger");
+class PromptBuilder {
+    /**
+     * Build a prompt with variable replacement
+     */
+    static buildPrompt(options) {
+        const { name, type = "user", variables, ...directVars } = options;
+        // Get the prompt name with type suffix if specified
+        const promptName = type === "system" ? `${name}-system` : name;
+        // Get prompt metadata from registry
+        const metadata = prompt_registry_1.PromptRegistry.getPrompt(promptName);
+        if (!metadata) {
+            return {
+                success: false,
+                error: `Prompt not found: ${promptName}. Available prompts:\n${prompt_registry_1.PromptRegistry.listPrompts()}`,
+            };
+        }
+        // Combine all variables (direct variables + variables object)
+        const allVariables = { ...variables, ...directVars };
+        // Validate required variables
+        const validation = prompt_registry_1.PromptRegistry.validatePrompt(promptName, allVariables);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: `Missing required variables: ${validation.missingRequired.join(", ")}`,
+                missingVariables: validation.missingRequired,
+            };
+        }
+        // Log missing optional variables for user awareness
+        if (validation.missingOptional.length > 0) {
+            logger_1.logger.warn(`Note: Missing optional variables: ${validation.missingOptional.join(", ")}`);
+        }
+        try {
+            // Replace variables in the prompt text
+            let promptText = metadata.promptText;
+            // Replace all {VAR_NAME} patterns with their values
+            for (const [key, value] of Object.entries(allVariables)) {
+                const pattern = new RegExp(`\\{${key}\\}`, "g");
+                promptText = promptText.replace(pattern, value || "");
+            }
+            // Check for any unreplaced variables (optional ones that weren't provided)
+            const unreplacedVars = promptText.match(/\{[^}]+\}/g);
+            if (unreplacedVars && unreplacedVars.length > 0) {
+                const varNames = unreplacedVars.map((v) => v.slice(1, -1));
+                const optionalUnreplaced = varNames.filter((v) => metadata.optionalVariables.includes(v));
+                if (optionalUnreplaced.length > 0) {
+                    logger_1.logger.warn(`Note: Optional variables not replaced: ${optionalUnreplaced.join(", ")}`);
+                }
+            }
+            return {
+                success: true,
+                prompt: promptText,
+                metadata,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Error building prompt: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+        }
+    }
+    /**
+     * List all available prompts
+     */
+    static listPrompts() {
+        return prompt_registry_1.PromptRegistry.listPrompts();
+    }
+    /**
+     * Get metadata for a specific prompt
+     */
+    static getPromptMetadata(name, type) {
+        const promptName = type === "system" ? `${name}-system` : name;
+        return prompt_registry_1.PromptRegistry.getPrompt(promptName) || null;
+    }
+    /**
+     * Load PRD content from file
+     */
+    static loadPRDContent(filePath) {
+        if (!(0, fs_1.existsSync)(filePath)) {
+            throw new Error(`PRD file not found: ${filePath}`);
+        }
+        return (0, fs_1.readFileSync)(filePath, "utf-8");
+    }
+    /**
+     * Auto-detect and load PRD content from project
+     */
+    static async autoDetectPRDContent() {
+        try {
+            const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
+            // Build context for a dummy task to get PRD content
+            const context = await contextBuilder.buildContextForNewTask("Dummy Task", "For PRD detection");
+            return context.prdContent;
+        }
+        catch (error) {
+            logger_1.logger.warn(`Could not auto-detect PRD content: ${error}`);
+            return undefined;
+        }
+    }
+    /**
+     * Build task context from file or content using ContextBuilder
+     */
+    static async buildTaskContext(taskTitle, content, filePath) {
+        let taskDescription = "";
+        if (filePath) {
+            if (!(0, fs_1.existsSync)(filePath)) {
+                throw new Error(`Task file not found: ${filePath}`);
+            }
+            taskDescription = (0, fs_1.readFileSync)(filePath, "utf-8");
+        }
+        else if (content) {
+            taskDescription = content;
+        }
+        // Use ContextBuilder to get rich context if we have a title
+        if (taskTitle) {
+            try {
+                const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
+                const context = await contextBuilder.buildContextForNewTask(taskTitle, taskDescription);
+                // Return formatted context instead of just description
+                return contextBuilder.formatContextForAI(context);
+            }
+            catch (error) {
+                logger_1.logger.warn(`Could not build rich task context, using basic description: ${error}`);
+                return taskDescription;
+            }
+        }
+        return taskDescription;
+    }
+    /**
+     * Detect stack info using ContextBuilder (proper BTS config loading)
+     */
+    static async detectStackInfo(projectPath) {
+        try {
+            // Default to current working directory if not provided
+            const workDir = projectPath || process.cwd();
+            config_1.configManager.setWorkingDirectory(workDir);
+            await config_1.configManager.load();
+            const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
+            // Build context for a dummy task to get stack info
+            const context = await contextBuilder.buildContextForNewTask("Dummy Task", "For stack detection");
+            if (context.stack && context.stack._source === "file") {
+                const parts = [
+                    `Frontend: ${context.stack.frontend}`,
+                    `Backend: ${context.stack.backend}`,
+                ];
+                if (context.stack.database !== "none") {
+                    parts.push(`Database: ${context.stack.database}`);
+                }
+                if (context.stack.orm !== "none") {
+                    parts.push(`ORM: ${context.stack.orm}`);
+                }
+                parts.push(`Auth: ${context.stack.auth}`);
+                if (context.stack.addons.length > 0) {
+                    parts.push(`Addons: ${context.stack.addons.join(", ")}`);
+                }
+                return parts.join(", ");
+            }
+            return "Not detected";
+        }
+        catch (error) {
+            logger_1.logger.warn(`Could not detect stack info using ContextBuilder: ${error}`);
+            return "Not detected";
+        }
+    }
+    /**
+     * Build comprehensive project context for external executors
+     */
+    static async buildFullProjectContext(projectPath) {
+        const contextParts = [];
+        contextParts.push("**Project Context:**");
+        // Detect package.json and dependencies
+        const packageJsonPath = (0, path_1.join)(projectPath, "package.json");
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
+                const deps = Object.keys(packageJson.dependencies || {});
+                const devDeps = Object.keys(packageJson.devDependencies || {});
+                contextParts.push(`\n**Dependencies:**`);
+                if (deps.length > 0) {
+                    contextParts.push(`- Production: ${deps.slice(0, 10).join(", ")}${deps.length > 10 ? ` (+${deps.length - 10} more)` : ""}`);
+                }
+                if (devDeps.length > 0) {
+                    contextParts.push(`- Development: ${devDeps.slice(0, 10).join(", ")}${devDeps.length > 10 ? ` (+${devDeps.length - 10} more)` : ""}`);
+                }
+                if (packageJson.scripts) {
+                    const scripts = Object.keys(packageJson.scripts);
+                    contextParts.push(`\n**Available Scripts:** ${scripts.join(", ")}`);
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`Could not parse package.json: ${error}`);
+            }
+        }
+        // Detect project structure
+        try {
+            const files = (0, fs_1.readdirSync)(projectPath);
+            const directories = files.filter((f) => {
+                try {
+                    const stat = (0, fs_1.statSync)((0, path_1.join)(projectPath, f));
+                    return stat.isDirectory() && !f.startsWith(".");
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (directories.length > 0) {
+                contextParts.push(`\n**Project Structure:** ${directories.join(", ")}`);
+            }
+            // Detect configuration files
+            const configFiles = files.filter((f) => f.match(/\.(config|rc)\.(js|ts|json|yaml|yml)$/) ||
+                [
+                    "tsconfig.json",
+                    "next.config.js",
+                    "vite.config.ts",
+                    "tailwind.config.js",
+                ].includes(f));
+            if (configFiles.length > 0) {
+                contextParts.push(`\n**Configuration Files:** ${configFiles.join(", ")}`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn(`Could not read project structure: ${error}`);
+        }
+        // Detect frameworks and tools
+        const detectedTools = [];
+        if ((0, fs_1.existsSync)((0, path_1.join)(projectPath, "next.config.js")) ||
+            (0, fs_1.existsSync)((0, path_1.join)(projectPath, "next.config.ts"))) {
+            detectedTools.push("Next.js");
+        }
+        if ((0, fs_1.existsSync)((0, path_1.join)(projectPath, "vite.config.ts")) ||
+            (0, fs_1.existsSync)((0, path_1.join)(projectPath, "vite.config.js"))) {
+            detectedTools.push("Vite");
+        }
+        if ((0, fs_1.existsSync)((0, path_1.join)(projectPath, "tailwind.config.js")) ||
+            (0, fs_1.existsSync)((0, path_1.join)(projectPath, "tailwind.config.ts"))) {
+            detectedTools.push("Tailwind CSS");
+        }
+        if ((0, fs_1.existsSync)((0, path_1.join)(projectPath, "convex"))) {
+            detectedTools.push("Convex");
+        }
+        if ((0, fs_1.existsSync)((0, path_1.join)(projectPath, "turbo.json"))) {
+            detectedTools.push("Turborepo");
+        }
+        if (detectedTools.length > 0) {
+            contextParts.push(`\n**Detected Tools:** ${detectedTools.join(", ")}`);
+        }
+        return contextParts.join("\n");
+    }
+    /**
+     * Format prompt for specific executor
+     */
+    static formatForExecutor(prompt, executor) {
+        // Most executors work well with plain text prompts
+        // This method exists for future customization if needed
+        switch (executor) {
+            case "claude":
+                // Claude Code works well with structured markdown
+                return prompt;
+            case "gemini":
+                // Gemini CLI supports file references with @
+                return prompt;
+            case "codex":
+                // Codex CLI supports structured prompts
+                return prompt;
+            case "opencode":
+            default:
+                return prompt;
+        }
+    }
+    /**
+     * Build execution prompt with task context
+     */
+    static buildExecutionPrompt(options) {
+        const { taskTitle, taskDescription, taskPlan, stack, documentation, retryContext, prdContent, } = options;
+        // Build TASK_PLAN variable
+        let taskPlanText = "";
+        if (taskPlan) {
+            taskPlanText = `# Task Plan\n\n${taskPlan}\n`;
+        }
+        else {
+            taskPlanText = `# Task: ${taskTitle}\n\n${taskDescription || "No description"}\n`;
+        }
+        // Build STACK_INFO variable
+        let stackInfo = "";
+        if (stack) {
+            const stackParts = [];
+            stackParts.push(`- **Project**: ${stack.projectName}`);
+            stackParts.push(`- **Frontend**: ${stack.frontend}`);
+            stackParts.push(`- **Backend**: ${stack.backend}`);
+            if (stack.database !== "none") {
+                stackParts.push(`- **Database**: ${stack.database}`);
+            }
+            if (stack.orm !== "none") {
+                stackParts.push(`- **ORM**: ${stack.orm}`);
+            }
+            stackParts.push(`- **Auth**: ${stack.auth}`);
+            if (stack.addons && stack.addons.length > 0) {
+                stackParts.push(`- **Addons**: ${stack.addons.join(", ")}`);
+            }
+            stackParts.push(`- **Package Manager**: ${stack.packageManager}`);
+            stackInfo = stackParts.join("\n");
+        }
+        // Build DOCUMENTATION_CONTEXT variable
+        let docContext = "";
+        if (documentation) {
+            const docParts = [];
+            docParts.push(`\n# Documentation Context\n`);
+            docParts.push(documentation.recap);
+            if (documentation.files && documentation.files.length > 0) {
+                docParts.push(`\n**Relevant Documentation Files**:`);
+                documentation.files.forEach((file) => {
+                    docParts.push(`- ${file.path}`);
+                });
+            }
+            docContext = docParts.join("\n");
+        }
+        // Build PRD_CONTENT variable
+        let prdCtx = "";
+        if (prdContent) {
+            prdCtx = `\n# Product Requirements Document\n\n${prdContent}\n`;
+        }
+        // Build RETRY_CONTEXT variable
+        const retryCtx = retryContext || "";
+        return this.buildPrompt({
+            name: "task-execution",
+            variables: {
+                RETRY_CONTEXT: retryCtx,
+                TASK_PLAN: taskPlanText,
+                STACK_INFO: stackInfo,
+                DOCUMENTATION_CONTEXT: docContext,
+                PRD_CONTENT: prdCtx,
+            },
+        });
+    }
+}
+exports.PromptBuilder = PromptBuilder;

package/dist/lib/prompt-registry.d.ts

@@ -0,0 +1,22 @@
+export interface PromptMetadata {
+    name: string;
+    description: string;
+    type: "system" | "user";
+    requiredVariables: string[];
+    optionalVariables: string[];
+    promptText: string;
+}
+export declare class PromptRegistry {
+    private static prompts;
+    static getPrompt(name: string): PromptMetadata | undefined;
+    static getAllPrompts(): PromptMetadata[];
+    static getPromptsByType(type: "system" | "user"): PromptMetadata[];
+    static hasPrompt(name: string): boolean;
+    static listPrompts(): string;
+    static validatePrompt(name: string, variables: Record<string, string>): {
+        valid: boolean;
+        missingRequired: string[];
+        missingOptional: string[];
+    };
+}
+//# sourceMappingURL=prompt-registry.d.ts.map

package/dist/lib/prompt-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-registry.d.ts","sourceRoot":"","sources":["../../src/lib/prompt-registry.ts"],"names":[],"mappings":"AAgCA,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,OAAO,CA6VnB;IAEH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI1D,MAAM,CAAC,aAAa,IAAI,cAAc,EAAE;IAIxC,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,cAAc,EAAE;IAMlE,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIvC,MAAM,CAAC,WAAW,IAAI,MAAM;IAiD5B,MAAM,CAAC,cAAc,CACnB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC;QACD,KAAK,EAAE,OAAO,CAAC;QACf,eAAe,EAAE,MAAM,EAAE,CAAC;QAC1B,eAAe,EAAE,MAAM,EAAE,CAAC;KAC3B;CAuBF"}