feature-architect-agent 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_js_1 = require("../commands/init.js");
+const plan_js_1 = require("../commands/plan.js");
+const verify_js_1 = require("../commands/verify.js");
+const logger_js_1 = require("../utils/logger.js");
+const program = new commander_1.Command();
+program
+    .name('feature-architect')
+    .description('AI-powered feature planning agent - generate complete technical specifications')
+    .version('1.0.0');
+program
+    .command('init')
+    .description('Initialize in project (analyze codebase)')
+    .option('-f, --force', 'Re-initialize even if already initialized')
+    .action(async (options) => {
+    try {
+        await (0, init_js_1.initCommand)(options.force);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('plan <feature>')
+    .description('Plan a new feature')
+    .option('-p, --provider <provider>', 'AI provider (claude, openai)', 'claude')
+    .option('-o, --output <path>', 'Output file path')
+    .option('--no-diagrams', 'Skip diagram generation')
+    .action(async (feature, options) => {
+    try {
+        await (0, plan_js_1.planCommand)(feature, options);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('verify')
+    .description('Verify setup and configuration')
+    .action(async () => {
+    try {
+        await (0, verify_js_1.verifyCommand)();
+    }
+    catch (err) {
+        process.exit(1);
+    }
+});
+// Default: show help if no command
+program.on('command:*', () => {
+    (0, logger_js_1.header)('Feature Architect Agent v1.0.0');
+    (0, logger_js_1.info)('AI-powered feature planning for development teams\n');
+    (0, logger_js_1.dim)('Quick start:');
+    (0, logger_js_1.dim)('  1. feature-architect init          # Analyze codebase');
+    (0, logger_js_1.dim)('  2. export ANTHROPIC_API_KEY=xxx   # Set API key');
+    (0, logger_js_1.dim)('  3. feature-architect plan "feature"  # Plan feature');
+    console.log('');
+});
+program.parse();

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+export declare function initCommand(force?: boolean): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAOA,wBAAsB,WAAW,CAAC,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA+EvE"}

package/dist/commands/init.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const path_1 = __importDefault(require("path"));
+const Scanner_js_1 = require("../services/Scanner.js");
+const Analyzer_js_1 = require("../services/Analyzer.js");
+const ContextManager_js_1 = require("../services/ContextManager.js");
+const logger_js_1 = require("../utils/logger.js");
+async function initCommand(force = false) {
+    (0, logger_js_1.header)('🔍 Feature Architect Agent - Initialization');
+    const contextManager = new ContextManager_js_1.ContextManager();
+    // Check if already initialized
+    if (!force && await contextManager.contextExists()) {
+        const context = await contextManager.loadContext();
+        (0, logger_js_1.info)(`Already initialized on ${context?.metadata.analyzedAt}`);
+        (0, logger_js_1.info)('Use --force to re-initialize');
+        return;
+    }
+    // Scan codebase
+    (0, logger_js_1.info)('Scanning codebase...');
+    const scanner = new Scanner_js_1.ScannerService();
+    const { files, stats } = await scanner.scanWithStats();
+    (0, logger_js_1.bullet)(`Found ${stats.total} files`);
+    for (const [lang, count] of Object.entries(stats.byLanguage)) {
+        (0, logger_js_1.bullet)(`  ${lang}: ${count} files`, 1);
+    }
+    // Analyze patterns
+    (0, logger_js_1.info)('\nAnalyzing patterns...');
+    const analyzer = new Analyzer_js_1.AnalyzerService();
+    const patterns = await analyzer.analyze(files);
+    (0, logger_js_1.bullet)(`API Routes: ${patterns.apiRoutes.length}`);
+    (0, logger_js_1.bullet)(`Database Tables: ${patterns.databaseSchemas.length}`);
+    (0, logger_js_1.bullet)(`Components: ${patterns.components.length}`);
+    (0, logger_js_1.bullet)(`Type Definitions: ${patterns.types.length}`);
+    // Detect frameworks
+    const frameworks = detectFrameworks(patterns);
+    // Build context
+    (0, logger_js_1.info)('\nBuilding context...');
+    const projectName = path_1.default.basename(process.cwd());
+    const projectType = detectProjectType(files, patterns);
+    const context = {
+        project: {
+            name: projectName,
+            type: projectType,
+            root: process.cwd()
+        },
+        summary: {
+            totalFiles: stats.total,
+            languages: stats.byLanguage,
+            frameworks: Object.values(frameworks).filter(Boolean),
+            patterns: patterns.apiRoutes.length +
+                patterns.databaseSchemas.length +
+                patterns.components.length +
+                patterns.types.length
+        },
+        frameworks: frameworks,
+        patterns: patterns,
+        metadata: {
+            version: '1.0.0',
+            analyzedAt: new Date().toISOString(),
+            hash: ''
+        }
+    };
+    // Save context
+    await contextManager.saveContext(context);
+    (0, logger_js_1.success)('\n✅ Initialization complete!');
+    (0, logger_js_1.info)(`Project: ${projectName}`);
+    (0, logger_js_1.info)(`Type: ${projectType}`);
+    (0, logger_js_1.info)(`Frameworks: ${context.summary.frameworks.join(', ') || 'Unknown'}`);
+    (0, logger_js_1.info)(`Patterns indexed: ${context.summary.patterns}`);
+    const contextPath = await contextManager.getContextPath();
+    (0, logger_js_1.dim)(`\nContext saved to: ${contextPath}`);
+    (0, logger_js_1.info)('\nYou can now plan features:');
+    (0, logger_js_1.info)('  feature-architect plan "your feature here"');
+}
+function detectProjectType(files, patterns) {
+    const hasTS = files.some(f => f.endsWith('.ts') || f.endsWith('.tsx'));
+    const hasReact = patterns.components.some((c) => c.type === 'Component');
+    const hasNext = files.some(f => f.includes('next.config.') || f.includes('/pages/') || f.includes('/app/'));
+    if (hasNext && hasTS)
+        return 'Next.js + TypeScript';
+    if (hasReact && hasTS)
+        return 'React + TypeScript';
+    if (hasTS)
+        return 'TypeScript';
+    return 'JavaScript';
+}
+function detectFrameworks(patterns) {
+    const frameworks = {};
+    // Detect API framework
+    if (patterns.apiRoutes.length > 0) {
+        const hasExpress = patterns.apiRoutes.some((r) => r.path.includes(':'));
+        if (hasExpress) {
+            frameworks.backend = 'Express.js';
+        }
+        else {
+            frameworks.backend = 'REST API';
+        }
+    }
+    // Detect frontend framework
+    if (patterns.components.length > 0) {
+        const hasPages = patterns.components.some((c) => c.file.includes('/pages/'));
+        if (hasPages) {
+            frameworks.frontend = 'Next.js';
+        }
+        else {
+            frameworks.frontend = 'React';
+        }
+    }
+    // Detect database
+    if (patterns.databaseSchemas.length > 0) {
+        const hasPrisma = patterns.databaseSchemas.some((s) => s.file.includes('.prisma'));
+        if (hasPrisma) {
+            frameworks.orm = 'Prisma';
+            frameworks.database = 'PostgreSQL';
+        }
+        else {
+            frameworks.database = 'SQL';
+        }
+    }
+    return frameworks;
+}

package/dist/commands/plan.d.ts

@@ -0,0 +1,6 @@
+export declare function planCommand(feature: string, options?: {
+    provider?: string;
+    output?: string;
+    noDiagrams?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=plan.d.ts.map

package/dist/commands/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/commands/plan.ts"],"names":[],"mappings":"AAQA,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;CACjB,GACL,OAAO,CAAC,IAAI,CAAC,CAiJf"}

package/dist/commands/plan.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCommand = planCommand;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const ContextManager_js_1 = require("../services/ContextManager.js");
+const Planner_js_1 = require("../services/Planner.js");
+const factory_js_1 = require("../llm/factory.js");
+const logger_js_1 = require("../utils/logger.js");
+const api_config_js_1 = require("../config/api.config.js");
+async function planCommand(feature, options = {}) {
+    (0, logger_js_1.header)('🧠 Feature Architect Agent - Plan Feature');
+    if (!feature) {
+        (0, logger_js_1.error)('Please provide a feature description');
+        (0, logger_js_1.info)('Usage: feature-architect plan "your feature description"');
+        return;
+    }
+    // Load context
+    const contextManager = new ContextManager_js_1.ContextManager();
+    if (!(await contextManager.contextExists())) {
+        (0, logger_js_1.error)('Not initialized. Run: feature-architect init');
+        return;
+    }
+    const context = await contextManager.loadContext();
+    if (!context) {
+        (0, logger_js_1.error)('Failed to load context');
+        return;
+    }
+    (0, logger_js_1.info)(`Feature: ${feature}`);
+    (0, logger_js_1.info)(`Project: ${context.project.name}`);
+    (0, logger_js_1.info)(`Frameworks: ${context.summary.frameworks.join(', ') || 'Unknown'}`);
+    // Auto-detect provider and API key
+    let provider = options.provider;
+    let apiKey;
+    let usingBuiltinKey = false;
+    // Auto-detect if not specified
+    if (!provider) {
+        // Check user environment variables first
+        if (process.env.ANTHROPIC_API_KEY) {
+            provider = 'anthropic';
+            apiKey = process.env.ANTHROPIC_API_KEY;
+        }
+        else if (process.env.OPENAI_API_KEY) {
+            provider = 'openai';
+            apiKey = process.env.OPENAI_API_KEY;
+        }
+        else if (process.env.GOOGLE_API_KEY) {
+            provider = 'google';
+            apiKey = process.env.GOOGLE_API_KEY;
+        }
+        else if (process.env.AI_API_KEY) {
+            // Generic API key - try OpenAI first (default built-in)
+            provider = 'openai';
+            apiKey = process.env.AI_API_KEY;
+        }
+        else {
+            // Fall back to built-in team API key
+            const builtinOpenAIKey = (0, api_config_js_1.getBuiltinKey)('openai');
+            if (builtinOpenAIKey && builtinOpenAIKey !== 'sk-your-team-openai-key-here') {
+                provider = 'openai';
+                apiKey = builtinOpenAIKey;
+                usingBuiltinKey = true;
+            }
+            else {
+                (0, logger_js_1.error)('No API key found');
+                (0, logger_js_1.dim)('Set any of these environment variables:');
+                (0, logger_js_1.dim)('  export ANTHROPIC_API_KEY=sk-ant-xxx  # For Claude');
+                (0, logger_js_1.dim)('  export OPENAI_API_KEY=sk-xxx        # For OpenAI');
+                (0, logger_js_1.dim)('  export GOOGLE_API_KEY=xxx           # For Gemini');
+                (0, logger_js_1.dim)('  export AI_API_KEY=xxx               # Generic');
+                (0, logger_js_1.dim)('\nOr contact your team admin to set up the built-in API key.');
+                return;
+            }
+        }
+    }
+    else {
+        // Use specified provider
+        const providerLower = provider.toLowerCase();
+        if (providerLower === 'claude' || providerLower === 'anthropic') {
+            provider = 'anthropic';
+            apiKey = (0, api_config_js_1.getApiKey)('anthropic');
+        }
+        else if (providerLower === 'openai') {
+            provider = 'openai';
+            apiKey = (0, api_config_js_1.getApiKey)('openai');
+        }
+        else if (providerLower === 'gemini' || providerLower === 'google') {
+            provider = 'google';
+            apiKey = (0, api_config_js_1.getApiKey)('google');
+        }
+        if (!apiKey) {
+            (0, logger_js_1.error)(`No API key found for ${provider}`);
+            (0, logger_js_1.dim)(`Set it with: export ${provider.toUpperCase()}_API_KEY=xxx`);
+            return;
+        }
+        // Check if using built-in key
+        const builtinKey = (0, api_config_js_1.getBuiltinKey)(provider);
+        if (builtinKey === apiKey && !process.env[`${provider.toUpperCase()}_API_KEY`]) {
+            usingBuiltinKey = true;
+        }
+    }
+    // Create AI provider
+    (0, logger_js_1.info)(`\nUsing AI: ${provider}${usingBuiltinKey ? ' (built-in team key)' : ''}...`);
+    const llm = (0, factory_js_1.createProvider)({
+        provider: provider,
+        apiKey
+    });
+    const planner = new Planner_js_1.PlannerService(llm);
+    // Generate plan
+    (0, logger_js_1.info)('Generating feature plan...\n');
+    try {
+        const plan = await planner.planFeature(feature, context, {
+            output: options.output,
+            includeDiagrams: !options.noDiagrams
+        });
+        // Ensure output directory exists
+        const slug = plan.slug;
+        const outputFile = options.output || path_1.default.join('docs', 'features', `${slug}.md`);
+        await promises_1.default.mkdir(path_1.default.dirname(outputFile), { recursive: true });
+        await promises_1.default.writeFile(outputFile, plan.markdown, 'utf-8');
+        (0, logger_js_1.success)('✅ Feature plan generated!');
+        (0, logger_js_1.info)(`Saved to: ${outputFile}`);
+        // Show preview
+        const lines = plan.markdown.split('\n');
+        const preview = lines.slice(0, 20).join('\n');
+        (0, logger_js_1.dim)('\n--- Preview (first 20 lines) ---\n');
+        console.log(preview);
+        if (lines.length > 20) {
+            (0, logger_js_1.dim)('\n... (truncated)');
+        }
+        (0, logger_js_1.info)('\n📖 Next steps:');
+        (0, logger_js_1.bullet)('Review the generated plan');
+        (0, logger_js_1.bullet)('Use it with your AI tool:');
+        (0, logger_js_1.dim)(`  claude "Implement this feature" < ${outputFile}`);
+        (0, logger_js_1.dim)(`  # Or paste into ChatGPT/Cursor/Copilot`);
+    }
+    catch (err) {
+        (0, logger_js_1.error)(`Failed to generate plan: ${err instanceof Error ? err.message : String(err)}`);
+        (0, logger_js_1.warn)('\nTroubleshooting:');
+        (0, logger_js_1.bullet)('Check your API key is set correctly');
+        (0, logger_js_1.bullet)('Ensure you have network connectivity');
+        (0, logger_js_1.bullet)('Try a shorter feature description');
+    }
+}

package/dist/commands/verify.d.ts

@@ -0,0 +1,2 @@
+export declare function verifyCommand(): Promise<void>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/commands/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../src/commands/verify.ts"],"names":[],"mappings":"AAKA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CA0FnD"}

package/dist/commands/verify.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyCommand = verifyCommand;
+const path_1 = __importDefault(require("path"));
+const ContextManager_js_1 = require("../services/ContextManager.js");
+const logger_js_1 = require("../utils/logger.js");
+const api_config_js_1 = require("../config/api.config.js");
+async function verifyCommand() {
+    (0, logger_js_1.header)('🔍 Feature Architect Agent - Verification');
+    const contextManager = new ContextManager_js_1.ContextManager();
+    let allGood = true;
+    // Check 1: Context exists
+    (0, logger_js_1.info)('Configuration:');
+    if (await contextManager.contextExists()) {
+        const context = await contextManager.loadContext();
+        (0, logger_js_1.check)(`Context file found`);
+        (0, logger_js_1.bullet)(`Project: ${context?.project.name}`, 1);
+        (0, logger_js_1.bullet)(`Type: ${context?.project.type}`, 1);
+        (0, logger_js_1.bullet)(`Initialized: ${context?.metadata.analyzedAt}`, 1);
+    }
+    else {
+        (0, logger_js_1.error)('✗ Context file not found');
+        (0, logger_js_1.bullet)('Run: feature-architect init', 1);
+        allGood = false;
+    }
+    // Check 2: API key
+    (0, logger_js_1.info)('\nAI Provider:');
+    // Check for user API keys
+    const keysFound = [];
+    if (process.env.ANTHROPIC_API_KEY)
+        keysFound.push('Claude (ANTHROPIC_API_KEY)');
+    if (process.env.OPENAI_API_KEY)
+        keysFound.push('OpenAI (OPENAI_API_KEY)');
+    if (process.env.GOOGLE_API_KEY)
+        keysFound.push('Gemini (GOOGLE_API_KEY)');
+    if (process.env.AI_API_KEY)
+        keysFound.push('Generic (AI_API_KEY)');
+    // Check for built-in team keys
+    const builtinOpenAIKey = (0, api_config_js_1.getBuiltinKey)('openai');
+    const builtinAnthropicKey = (0, api_config_js_1.getBuiltinKey)('anthropic');
+    const builtinGoogleKey = (0, api_config_js_1.getBuiltinKey)('google');
+    if (builtinOpenAIKey && builtinOpenAIKey !== 'sk-your-team-openai-key-here') {
+        keysFound.push('OpenAI (built-in team key) ✓');
+    }
+    if (builtinAnthropicKey) {
+        keysFound.push('Claude (built-in team key) ✓');
+    }
+    if (builtinGoogleKey) {
+        keysFound.push('Gemini (built-in team key) ✓');
+    }
+    if (keysFound.length > 0) {
+        (0, logger_js_1.check)('API keys found:');
+        keysFound.forEach(key => (0, logger_js_1.bullet)(key, 1));
+        // Show which will be used
+        let defaultProvider = 'openai'; // Default to OpenAI (built-in)
+        if (process.env.ANTHROPIC_API_KEY)
+            defaultProvider = 'anthropic';
+        else if (process.env.OPENAI_API_KEY)
+            defaultProvider = 'openai';
+        else if (process.env.GOOGLE_API_KEY)
+            defaultProvider = 'google';
+        else if (builtinOpenAIKey && builtinOpenAIKey !== 'sk-your-team-openai-key-here')
+            defaultProvider = 'openai (built-in)';
+        (0, logger_js_1.bullet)(`Default provider: ${defaultProvider}`, 1);
+    }
+    else {
+        (0, logger_js_1.error)('✗ No API key found');
+        (0, logger_js_1.bullet)('Set any API key:', 1);
+        (0, logger_js_1.bullet)('export ANTHROPIC_API_KEY=sk-ant-xxx  # Claude', 2);
+        (0, logger_js_1.bullet)('export OPENAI_API_KEY=sk-xxx        # OpenAI', 2);
+        (0, logger_js_1.bullet)('export GOOGLE_API_KEY=xxx           # Gemini', 2);
+        (0, logger_js_1.bullet)('export AI_API_KEY=xxx               # Generic', 2);
+        (0, logger_js_1.bullet)('\nOr contact your team admin to set up built-in keys.', 2);
+        allGood = false;
+    }
+    // Check 3: Output directory
+    (0, logger_js_1.info)('\nOutput:');
+    const docsDir = path_1.default.join(process.cwd(), 'docs', 'features');
+    try {
+        const { opendir } = await import('fs/promises');
+        await opendir(docsDir);
+        (0, logger_js_1.check)(`Output directory exists: ${docsDir}`);
+    }
+    catch {
+        (0, logger_js_1.dim)(`Output directory will be created: ${docsDir}`);
+    }
+    // Summary
+    if (allGood) {
+        (0, logger_js_1.success)('\n✅ All checks passed!');
+        (0, logger_js_1.info)('You can now plan features:');
+        (0, logger_js_1.dim)('  feature-architect plan "your feature here"\n');
+    }
+    else {
+        (0, logger_js_1.error)('\n❌ Some checks failed');
+        (0, logger_js_1.info)('Fix the issues above before planning features.\n');
+    }
+    return allGood ? Promise.resolve() : Promise.reject(new Error('Verification failed'));
+}

package/dist/config/api.config.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Built-in API Configuration for Internal Team Use
+ *
+ * This file contains the pre-configured API key for team use.
+ * The package is published to a private registry for internal team access.
+ *
+ * SECURITY: This file is included in the published package.
+ * Only publish to PRIVATE npm registries (GitHub Packages, npm private, etc.)
+ */
+export declare const API_CONFIG: {
+    /**
+     * Built-in OpenAI API Key for team use
+     * Replace with your actual team API key
+     */
+    openai: {
+        apiKey: string;
+        baseURL: string;
+    };
+    /**
+     * Built-in Anthropic API Key (optional)
+     */
+    anthropic: {
+        apiKey: string;
+        baseURL: string;
+    };
+    /**
+     * Built-in Google API Key (optional)
+     */
+    google: {
+        apiKey: string;
+    };
+    /**
+     * Default provider to use when no user key is set
+     */
+    defaultProvider: "openai";
+};
+/**
+ * Get the built-in API key for a provider
+ */
+export declare function getBuiltinKey(provider: 'openai' | 'anthropic' | 'google'): string | undefined;
+/**
+ * Check if a built-in key is available
+ */
+export declare function hasBuiltinKey(provider: 'openai' | 'anthropic' | 'google'): boolean;
+/**
+ * Get the best available API key (user env var first, then built-in)
+ */
+export declare function getApiKey(provider: 'openai' | 'anthropic' | 'google'): string | undefined;
+//# sourceMappingURL=api.config.d.ts.map

package/dist/config/api.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.config.d.ts","sourceRoot":"","sources":["../../src/config/api.config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,UAAU;IACrB;;;OAGG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;IAKH;;OAEG;;CAEJ,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAW7F;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,OAAO,CAGlF;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAUzF"}

package/dist/config/api.config.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Built-in API Configuration for Internal Team Use
+ *
+ * This file contains the pre-configured API key for team use.
+ * The package is published to a private registry for internal team access.
+ *
+ * SECURITY: This file is included in the published package.
+ * Only publish to PRIVATE npm registries (GitHub Packages, npm private, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_CONFIG = void 0;
+exports.getBuiltinKey = getBuiltinKey;
+exports.hasBuiltinKey = hasBuiltinKey;
+exports.getApiKey = getApiKey;
+exports.API_CONFIG = {
+    /**
+     * Built-in OpenAI API Key for team use
+     * Replace with your actual team API key
+     */
+    openai: {
+        apiKey: process.env.TEAM_OPENAI_API_KEY || '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',
+        baseURL: 'https://api.openai.com/v1',
+    },
+    /**
+     * Built-in Anthropic API Key (optional)
+     */
+    anthropic: {
+        apiKey: process.env.TEAM_ANTHROPIC_API_KEY || '',
+        baseURL: 'https://api.anthropic.com',
+    },
+    /**
+     * Built-in Google API Key (optional)
+     */
+    google: {
+        apiKey: process.env.TEAM_GOOGLE_API_KEY || '',
+    },
+    /**
+     * Default provider to use when no user key is set
+     */
+    defaultProvider: 'openai',
+};
+/**
+ * Get the built-in API key for a provider
+ */
+function getBuiltinKey(provider) {
+    switch (provider) {
+        case 'openai':
+            return exports.API_CONFIG.openai.apiKey || undefined;
+        case 'anthropic':
+            return exports.API_CONFIG.anthropic.apiKey || undefined;
+        case 'google':
+            return exports.API_CONFIG.google.apiKey || undefined;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Check if a built-in key is available
+ */
+function hasBuiltinKey(provider) {
+    const key = getBuiltinKey(provider);
+    return !!key && key !== '' && !key.startsWith('sk-');
+}
+/**
+ * Get the best available API key (user env var first, then built-in)
+ */
+function getApiKey(provider) {
+    // First check user's environment variable
+    const userKey = process.env[`${provider.toUpperCase()}_API_KEY`];
+    if (userKey)
+        return userKey;
+    // Then check generic AI_API_KEY
+    if (process.env.AI_API_KEY)
+        return process.env.AI_API_KEY;
+    // Finally fall back to built-in key
+    return getBuiltinKey(provider);
+}

package/dist/llm/Claude.d.ts

@@ -0,0 +1,8 @@
+import type { LLMProvider, GenerateOptions } from './types.js';
+export declare class ClaudeProvider implements LLMProvider {
+    private apiKey;
+    private model;
+    constructor(apiKey: string, model?: string);
+    generate(prompt: string, options?: GenerateOptions): Promise<string>;
+}
+//# sourceMappingURL=Claude.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Claude.d.ts","sourceRoot":"","sources":["../../src/llm/Claude.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE/D,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAS;gBAEV,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,MAAqC;IAKlE,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,MAAM,CAAC;CAqC/E"}

package/dist/llm/Claude.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeProvider = void 0;
+class ClaudeProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = 'claude-3-5-sonnet-20241022') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async generate(prompt, options = {}) {
+        const temperature = options.temperature ?? 0.7;
+        const maxTokens = options.maxTokens ?? 8000;
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'x-api-key': this.apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json'
+            },
+            body: JSON.stringify({
+                model: this.model,
+                max_tokens: maxTokens,
+                temperature,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ]
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Claude API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(`Claude API error: ${data.error.message}`);
+        }
+        return data.content[0].text;
+    }
+}
+exports.ClaudeProvider = ClaudeProvider;

package/dist/llm/OpenAI.d.ts

@@ -0,0 +1,8 @@
+import type { LLMProvider, GenerateOptions } from './types.js';
+export declare class OpenAIProvider implements LLMProvider {
+    private apiKey;
+    private model;
+    constructor(apiKey: string, model?: string);
+    generate(prompt: string, options?: GenerateOptions): Promise<string>;
+}
+//# sourceMappingURL=OpenAI.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAI.d.ts","sourceRoot":"","sources":["../../src/llm/OpenAI.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE/D,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAS;gBAEV,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,MAAsB;IAKnD,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,MAAM,CAAC;CAoC/E"}