feature-architect-agent 1.0.0

package/dist/llm/OpenAI.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+class OpenAIProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = 'gpt-4-turbo') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async generate(prompt, options = {}) {
+        const temperature = options.temperature ?? 0.7;
+        const maxTokens = options.maxTokens ?? 4000;
+        const response = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                temperature,
+                max_tokens: maxTokens
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenAI API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(`OpenAI API error: ${data.error.message}`);
+        }
+        return data.choices[0].message.content;
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

package/dist/llm/factory.d.ts

@@ -0,0 +1,9 @@
+import type { LLMProvider } from './types.js';
+export type ProviderType = 'claude' | 'anthropic' | 'openai' | 'gemini' | 'google' | 'opencode' | 'ollama';
+export interface ProviderConfig {
+    provider: ProviderType;
+    apiKey?: string;
+    model?: string;
+}
+export declare function createProvider(config: ProviderConfig): LLMProvider;
+//# sourceMappingURL=factory.d.ts.map

package/dist/llm/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/llm/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI9C,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE3G,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,YAAY,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAWD,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,CAmClE"}

package/dist/llm/factory.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProvider = createProvider;
+const Claude_js_1 = require("./Claude.js");
+const OpenAI_js_1 = require("./OpenAI.js");
+/**
+ * Normalize provider name - accepts both 'claude'/'anthropic' and 'gemini'/'google'
+ */
+function normalizeProvider(provider) {
+    if (provider === 'anthropic')
+        return 'claude';
+    if (provider === 'google')
+        return 'gemini';
+    return provider;
+}
+function createProvider(config) {
+    const normalizedProvider = normalizeProvider(config.provider);
+    const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+    if (!apiKey && ['claude', 'openai'].includes(normalizedProvider)) {
+        throw new Error(`API key required for ${config.provider}. Set ${config.provider.toUpperCase()}_API_KEY environment variable.`);
+    }
+    switch (normalizedProvider) {
+        case 'claude':
+            return new Claude_js_1.ClaudeProvider(apiKey, config.model || 'claude-3-5-sonnet-20241022');
+        case 'openai':
+            return new OpenAI_js_1.OpenAIProvider(apiKey, config.model || 'gpt-4o');
+        case 'gemini':
+            throw new Error('Gemini provider not yet implemented');
+        case 'opencode':
+            throw new Error('OpenCode provider not yet implemented');
+        case 'ollama':
+            throw new Error('Ollama provider not yet implemented');
+        default:
+            throw new Error(`Unknown provider: ${config.provider}`);
+    }
+}

package/dist/llm/types.d.ts

@@ -0,0 +1,8 @@
+export interface LLMProvider {
+    generate(prompt: string, options?: GenerateOptions): Promise<string>;
+}
+export interface GenerateOptions {
+    temperature?: number;
+    maxTokens?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/llm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/llm/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACtE;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/dist/llm/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/Analyzer.d.ts

@@ -0,0 +1,18 @@
+import type { CodebasePatterns } from '../types/index.js';
+export declare class AnalyzerService {
+    analyze(files: string[]): Promise<CodebasePatterns>;
+    private analyzeTypeScriptFile;
+    private analyzeSQLFile;
+    private analyzePrismaFile;
+    private isReactComponent;
+    private isAPIRoute;
+    private extractComponentName;
+    private getComponentType;
+    private extractProps;
+    private extractAPIRoutes;
+    private extractTypeDefinitions;
+    private extractTables;
+    private extractPrismaModels;
+    private findLine;
+}
+//# sourceMappingURL=Analyzer.d.ts.map

package/dist/services/Analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Analyzer.d.ts","sourceRoot":"","sources":["../../src/services/Analyzer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAuD,MAAM,mBAAmB,CAAC;AAE/G,qBAAa,eAAe;IACpB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA+BzD,OAAO,CAAC,qBAAqB;IAkC7B,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,oBAAoB;IAgB5B,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,gBAAgB;IAwCxB,OAAO,CAAC,sBAAsB;IA2C9B,OAAO,CAAC,aAAa;IAgCrB,OAAO,CAAC,mBAAmB;IAqB3B,OAAO,CAAC,QAAQ;CAQjB"}

package/dist/services/Analyzer.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzerService = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+class AnalyzerService {
+    async analyze(files) {
+        const patterns = {
+            apiRoutes: [],
+            databaseSchemas: [],
+            components: [],
+            types: [],
+            utilities: []
+        };
+        for (const file of files) {
+            const ext = path_1.default.extname(file);
+            try {
+                const content = await promises_1.default.readFile(file, 'utf-8');
+                const lines = content.split('\n');
+                if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+                    this.analyzeTypeScriptFile(file, content, lines, patterns);
+                }
+                else if (ext === '.sql') {
+                    this.analyzeSQLFile(file, content, lines, patterns);
+                }
+                else if (ext === '.prisma') {
+                    this.analyzePrismaFile(file, content, lines, patterns);
+                }
+            }
+            catch (error) {
+                // Skip files that can't be read
+            }
+        }
+        return patterns;
+    }
+    analyzeTypeScriptFile(file, content, lines, patterns) {
+        const isComponent = this.isReactComponent(file, content);
+        const isRoute = this.isAPIRoute(file, content);
+        // Extract components
+        if (isComponent) {
+            const componentName = this.extractComponentName(content);
+            if (componentName) {
+                patterns.components.push({
+                    file,
+                    line: this.findLine(lines, componentName),
+                    name: componentName,
+                    type: this.getComponentType(file),
+                    props: this.extractProps(content)
+                });
+            }
+        }
+        // Extract API routes
+        if (isRoute) {
+            const routes = this.extractAPIRoutes(file, lines);
+            patterns.apiRoutes.push(...routes);
+        }
+        // Extract type definitions
+        const types = this.extractTypeDefinitions(file, lines);
+        patterns.types.push(...types);
+    }
+    analyzeSQLFile(file, content, lines, patterns) {
+        const tables = this.extractTables(file, lines);
+        patterns.databaseSchemas.push(...tables);
+    }
+    analyzePrismaFile(file, content, lines, patterns) {
+        const models = this.extractPrismaModels(file, lines);
+        patterns.databaseSchemas.push(...models);
+    }
+    isReactComponent(file, content) {
+        return ((file.endsWith('.tsx') || file.endsWith('.jsx')) ||
+            content.includes('React.FC') ||
+            content.includes('export function') && content.includes('JSX'));
+    }
+    isAPIRoute(file, content) {
+        return (file.includes('/api/') ||
+            file.includes('/routes/') ||
+            file.includes('router.') ||
+            content.includes('express.Router') ||
+            content.includes('.get(') ||
+            content.includes('.post('));
+    }
+    extractComponentName(content) {
+        // Match: export function ComponentName
+        const funcMatch = content.match(/export\s+function\s+(\w+)/);
+        if (funcMatch)
+            return funcMatch[1];
+        // Match: const ComponentName = () =>
+        const arrowMatch = content.match(/(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+        if (arrowMatch)
+            return arrowMatch[1];
+        // Match: export class ComponentName
+        const classMatch = content.match(/export\s+class\s+(\w+)\s+extends/);
+        if (classMatch)
+            return classMatch[1];
+        return null;
+    }
+    getComponentType(file) {
+        if (file.includes('/pages/') || file.includes('/app/'))
+            return 'Page';
+        if (file.includes('/components/'))
+            return 'Component';
+        if (file.includes('/layouts/'))
+            return 'Layout';
+        return 'Component';
+    }
+    extractProps(content) {
+        const interfaceMatch = content.match(/interface\s+(\w+Props)\s*{([^}]+)}/s);
+        if (interfaceMatch) {
+            return interfaceMatch[2].trim();
+        }
+        return undefined;
+    }
+    extractAPIRoutes(file, lines) {
+        const routes = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Match: router.get('/path', handler)
+            const routeMatch = line.match(/\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*(\w+)/);
+            if (routeMatch) {
+                routes.push({
+                    file,
+                    line: i + 1,
+                    method: routeMatch[1].toUpperCase(),
+                    path: routeMatch[2],
+                    handler: routeMatch[3]
+                });
+            }
+            // Match: app.get('/path', handler)
+            const appMatch = line.match(/\b(app|router)\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/);
+            if (appMatch) {
+                routes.push({
+                    file,
+                    line: i + 1,
+                    method: appMatch[2].toUpperCase(),
+                    path: appMatch[3],
+                    handler: 'anonymous'
+                });
+            }
+        }
+        return routes;
+    }
+    extractTypeDefinitions(file, lines) {
+        const types = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Match: interface Name
+            const interfaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+            if (interfaceMatch) {
+                types.push({
+                    file,
+                    line: i + 1,
+                    name: interfaceMatch[1],
+                    kind: 'interface'
+                });
+            }
+            // Match: type Name =
+            const typeMatch = line.match(/(?:export\s+)?type\s+(\w+)\s*=/);
+            if (typeMatch) {
+                types.push({
+                    file,
+                    line: i + 1,
+                    name: typeMatch[1],
+                    kind: 'type'
+                });
+            }
+            // Match: enum Name
+            const enumMatch = line.match(/(?:export\s+)?enum\s+(\w+)/);
+            if (enumMatch) {
+                types.push({
+                    file,
+                    line: i + 1,
+                    name: enumMatch[1],
+                    kind: 'enum'
+                });
+            }
+        }
+        return types;
+    }
+    extractTables(file, lines) {
+        const schemas = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Match: CREATE TABLE name
+            const tableMatch = line.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`?(\w+)`?)/i);
+            if (tableMatch) {
+                schemas.push({
+                    file,
+                    line: i + 1,
+                    type: 'table',
+                    name: tableMatch[1]
+                });
+            }
+            // Match: CREATE VIEW name
+            const viewMatch = line.match(/CREATE\s+VIEW\s+(?:`?(\w+)`?)/i);
+            if (viewMatch) {
+                schemas.push({
+                    file,
+                    line: i + 1,
+                    type: 'view',
+                    name: viewMatch[1]
+                });
+            }
+        }
+        return schemas;
+    }
+    extractPrismaModels(file, lines) {
+        const schemas = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Match: model Name {
+            const modelMatch = line.match(/model\s+(\w+)\s*{/);
+            if (modelMatch) {
+                schemas.push({
+                    file,
+                    line: i + 1,
+                    type: 'table',
+                    name: modelMatch[1]
+                });
+            }
+        }
+        return schemas;
+    }
+    findLine(lines, text) {
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(text)) {
+                return i + 1;
+            }
+        }
+        return 1;
+    }
+}
+exports.AnalyzerService = AnalyzerService;

package/dist/services/ContextManager.d.ts

@@ -0,0 +1,16 @@
+import type { CodebaseContext } from '../types/index.js';
+export declare class ContextManager {
+    private contextDir;
+    private contextFile;
+    constructor(root?: string);
+    saveContext(context: CodebaseContext): Promise<void>;
+    loadContext(): Promise<CodebaseContext | null>;
+    updateContext(updates: Partial<CodebaseContext>): Promise<void>;
+    contextExists(): Promise<boolean>;
+    getContextPath(): Promise<string>;
+    exportContext(outputPath: string): Promise<void>;
+    importContext(inputPath: string): Promise<void>;
+    private ensureContextDir;
+    private generateHash;
+}
+//# sourceMappingURL=ContextManager.d.ts.map

package/dist/services/ContextManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextManager.d.ts","sourceRoot":"","sources":["../../src/services/ContextManager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,qBAAa,cAAc;IACzB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAS;gBAEhB,IAAI,GAAE,MAAsB;IAKlC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAapD,WAAW,IAAI,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAS9C,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAU/D,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC;IASjC,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAIjC,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAShD,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAQvC,gBAAgB;IAQ9B,OAAO,CAAC,YAAY;CAIrB"}

package/dist/services/ContextManager.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextManager = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+class ContextManager {
+    contextDir;
+    contextFile;
+    constructor(root = process.cwd()) {
+        this.contextDir = path_1.default.join(root, '.feature-architect');
+        this.contextFile = path_1.default.join(this.contextDir, 'context.json');
+    }
+    async saveContext(context) {
+        await this.ensureContextDir();
+        // Update metadata
+        context.metadata = {
+            version: '1.0.0',
+            analyzedAt: new Date().toISOString(),
+            hash: this.generateHash(context)
+        };
+        await promises_1.default.writeFile(this.contextFile, JSON.stringify(context, null, 2), 'utf-8');
+    }
+    async loadContext() {
+        try {
+            const content = await promises_1.default.readFile(this.contextFile, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    async updateContext(updates) {
+        const current = await this.loadContext();
+        if (!current) {
+            throw new Error('No context found. Run init first.');
+        }
+        const updated = { ...current, ...updates };
+        await this.saveContext(updated);
+    }
+    async contextExists() {
+        try {
+            await promises_1.default.access(this.contextFile);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getContextPath() {
+        return this.contextFile;
+    }
+    async exportContext(outputPath) {
+        const context = await this.loadContext();
+        if (!context) {
+            throw new Error('No context found. Run init first.');
+        }
+        await promises_1.default.writeFile(outputPath, JSON.stringify(context, null, 2), 'utf-8');
+    }
+    async importContext(inputPath) {
+        const content = await promises_1.default.readFile(inputPath, 'utf-8');
+        const context = JSON.parse(content);
+        await this.ensureContextDir();
+        await this.saveContext(context);
+    }
+    async ensureContextDir() {
+        try {
+            await promises_1.default.mkdir(this.contextDir, { recursive: true });
+        }
+        catch {
+            // Ignore if already exists
+        }
+    }
+    generateHash(context) {
+        const content = JSON.stringify(context);
+        return crypto_1.default.createHash('sha256').update(content).digest('hex').substring(0, 16);
+    }
+}
+exports.ContextManager = ContextManager;

package/dist/services/Planner.d.ts

@@ -0,0 +1,16 @@
+import type { LLMProvider } from '../llm/types.js';
+import type { CodebaseContext, FeaturePlan } from '../types/index.js';
+interface PlanOptions {
+    output?: string;
+    includeDiagrams?: boolean;
+}
+export declare class PlannerService {
+    private llm;
+    constructor(llm: LLMProvider);
+    planFeature(feature: string, context: CodebaseContext, options?: PlanOptions): Promise<FeaturePlan>;
+    private buildPrompt;
+    private generateId;
+    private slugify;
+}
+export {};
+//# sourceMappingURL=Planner.d.ts.map

package/dist/services/Planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Planner.d.ts","sourceRoot":"","sources":["../../src/services/Planner.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEtE,UAAU,WAAW;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,cAAc;IACb,OAAO,CAAC,GAAG;gBAAH,GAAG,EAAE,WAAW;IAE9B,WAAW,CACf,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,eAAe,EACxB,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,WAAW,CAAC;IAqBvB,OAAO,CAAC,WAAW;IAgJnB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,OAAO;CAUhB"}

package/dist/services/Planner.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlannerService = void 0;
+const path_1 = __importDefault(require("path"));
+class PlannerService {
+    llm;
+    constructor(llm) {
+        this.llm = llm;
+    }
+    async planFeature(feature, context, options = {}) {
+        const prompt = this.buildPrompt(feature, context);
+        const response = await this.llm.generate(prompt, {
+            temperature: 0.7,
+            maxTokens: 8000
+        });
+        const slug = this.slugify(feature);
+        const outputFile = options.output || path_1.default.join('docs', 'features', `${slug}.md`);
+        const plan = {
+            id: this.generateId(),
+            feature,
+            slug,
+            createdAt: new Date().toISOString(),
+            markdown: response
+        };
+        return plan;
+    }
+    buildPrompt(feature, context) {
+        const patterns = context.patterns;
+        let relevantPatterns = '';
+        // API Routes
+        if (patterns.apiRoutes.length > 0) {
+            relevantPatterns += `\n### Existing API Routes (${patterns.apiRoutes.length}):\n`;
+            patterns.apiRoutes.slice(0, 20).forEach(route => {
+                relevantPatterns += `- ${route.method} ${route.path} (${path_1.default.basename(route.file)})\n`;
+            });
+            if (patterns.apiRoutes.length > 20) {
+                relevantPatterns += `... and ${patterns.apiRoutes.length - 20} more\n`;
+            }
+        }
+        // Database Tables
+        if (patterns.databaseSchemas.length > 0) {
+            relevantPatterns += `\n### Existing Database Tables (${patterns.databaseSchemas.length}):\n`;
+            patterns.databaseSchemas.slice(0, 20).forEach(schema => {
+                relevantPatterns += `- ${schema.name} (${schema.type})\n`;
+            });
+            if (patterns.databaseSchemas.length > 20) {
+                relevantPatterns += `... and ${patterns.databaseSchemas.length - 20} more\n`;
+            }
+        }
+        // Components
+        if (patterns.components.length > 0) {
+            relevantPatterns += `\n### Existing Components (${patterns.components.length}):\n`;
+            patterns.components.slice(0, 20).forEach(component => {
+                relevantPatterns += `- ${component.name} (${component.type})\n`;
+            });
+            if (patterns.components.length > 20) {
+                relevantPatterns += `... and ${patterns.components.length - 20} more\n`;
+            }
+        }
+        // Frameworks
+        const frameworks = Object.values(context.frameworks).filter(Boolean).join(', ') || 'Unknown';
+        return `You are a senior software architect. Plan the following feature based on the existing codebase context.
+
+FEATURE TO PLAN: ${feature}
+
+---
+
+## CODEBASE CONTEXT
+
+**Project Type:** ${context.project.type}
+**Frameworks:** ${frameworks}
+**Total Files:** ${context.summary.totalFiles}
+**Languages:** ${Object.entries(context.summary.languages)
+            .map(([lang, count]) => `${lang} (${count})`)
+            .join(', ')}
+
+${relevantPatterns}
+
+---
+
+## YOUR TASK
+
+Generate a complete, detailed feature plan that:
+
+1. **Follows existing patterns** in the codebase
+2. **Uses the same frameworks and conventions** detected above
+3. **Integrates seamlessly** with existing API routes and database tables
+
+## OUTPUT FORMAT (Markdown)
+
+# Feature Plan: ${feature}
+
+## Overview
+[Brief description of what this feature does and why it's needed]
+
+## Use Cases
+| ID | Description | Priority |
+|----|-------------|----------|
+| UC1 | [Specific use case] | Must Have |
+| UC2 | [Specific use case] | Should Have |
+...
+
+## Database Design
+### New Tables
+\`\`\`sql
+[SQL CREATE statements for any new tables]
+\`\`\`
+
+### Modified Tables
+\`\`\`sql
+[SQL ALTER statements for any modifications to existing tables]
+\`\`\`
+
+## Backend API
+### New Endpoints
+| Method | Endpoint | Description | Auth |
+|--------|----------|-------------|------|
+| GET | /api/v1/... | [Description] | Required |
+...
+
+### Request/Response Examples
+\`\`\`typescript
+[TypeScript interfaces for requests and responses]
+\`\`\`
+
+## Frontend Components
+### Component Structure
+\`\`\`
+src/features/[feature-name]/
+├── ComponentName.tsx
+└── ...
+\`\`\`
+
+### Component Specs
+\`\`\`typescript
+[Component interfaces and props]
+\`\`\`
+
+## Architecture Flow
+\`\`\`mermaid
+sequenceDiagram
+    [Sequence diagram showing the flow]
+\`\`\`
+
+## Implementation Tasks
+### Phase 1: Database (X days)
+- [ ] [Task 1]
+- [ ] [Task 2]
+
+### Phase 2: Backend (X days)
+- [ ] [Task 1]
+
+...
+
+## Edge Cases
+| Case | Handling |
+|------|----------|
+| [Edge case] | [How to handle] |
+...
+
+Generate the complete plan now. Be specific and detailed.
+`;
+    }
+    generateId() {
+        return `plan_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    slugify(text) {
+        return text
+            .toString()
+            .toLowerCase()
+            .trim()
+            .replace(/\s+/g, '-')
+            .replace(/[^\w\-]+/g, '')
+            .replace(/\-\-+/g, '-')
+            .replace(/[^a-z0-9\-]/g, '');
+    }
+}
+exports.PlannerService = PlannerService;