@intentsolutions/blueprint 2.5.0 → 2.8.0

package/dist/cli.js

@@ -12,7 +12,7 @@ const program = new Command();
 program
     .name('blueprint')
     .description('Intent Blueprint - Enterprise AI Documentation Generator')
-    .version('2.5.0');
+    .version('2.7.0');
 // Init command
 program
     .command('init')
@@ -292,19 +292,21 @@ program
     }
     console.log(chalk.dim(`\nTotal: ${templates.length} templates`));
 });
-// Export command - GitHub, Linear, and Jira integration
+// Export command - GitHub, Linear, Jira, and Notion integration
 program
     .command('export <target>')
-    .description('Export to GitHub, Linear, or Jira (issues, milestones, sprints)')
+    .description('Export to GitHub, Linear, Jira, or Notion')
     .option('-p, --project <name>', 'Project name')
     .option('-d, --docs <dir>', 'Generated docs directory')
-    .option('-t, --token <token>', 'API token (or use GITHUB_TOKEN / LINEAR_API_KEY / JIRA_API_TOKEN env)')
+    .option('-t, --token <token>', 'API token (or use GITHUB_TOKEN / LINEAR_API_KEY / JIRA_API_TOKEN / NOTION_API_KEY env)')
     .option('-o, --owner <owner>', 'Repository owner (GitHub)')
     .option('-r, --repo <repo>', 'Repository name (GitHub)')
     .option('--team <id>', 'Linear team ID')
     .option('--base-url <url>', 'Jira instance URL (e.g., https://your-domain.atlassian.net)')
     .option('--email <email>', 'Jira user email')
     .option('--project-key <key>', 'Jira project key')
+    .option('--page-id <id>', 'Notion parent page ID')
+    .option('--database-id <id>', 'Notion database ID')
     .option('--dry-run', 'Preview what would be exported without making changes')
     .option('--no-issues', 'Skip creating issues')
     .option('--no-milestones', 'Skip creating milestones/cycles/sprints')
@@ -313,10 +315,11 @@ program
     .option('--create-project', 'Create a new project in Linear')
     .option('--create-epic', 'Create an Epic in Jira')
     .option('--create-versions', 'Create versions/releases in Jira')
+    .option('--create-database', 'Create a Notion database for documents')
     .action(async (target, options) => {
-    if (target !== 'github' && target !== 'linear' && target !== 'jira') {
+    if (target !== 'github' && target !== 'linear' && target !== 'jira' && target !== 'notion') {
         console.log(chalk.yellow(`\n⚠️  Export to ${target} not supported.\n`));
-        console.log(chalk.dim('Currently supported: github, linear, jira'));
+        console.log(chalk.dim('Currently supported: github, linear, jira, notion'));
         return;
     }
     // Handle Linear export
@@ -329,6 +332,11 @@ program
         await handleJiraExport(options);
         return;
     }
+    // Handle Notion export
+    if (target === 'notion') {
+        await handleNotionExport(options);
+        return;
+    }
     console.log(chalk.blue('\n🚀 Intent Blueprint - GitHub Export\n'));
     const { GitHubExporter } = await import('./integrations/github/index.js');
     // Get GitHub config
@@ -511,6 +519,364 @@ program
     .action(() => {
     console.log(chalk.yellow('\n⚠️  Sync feature coming soon!\n'));
 });
+// Enterprise: API Server command
+program
+    .command('serve')
+    .description('Start the Blueprint REST API server')
+    .option('-p, --port <port>', 'Port to listen on', '3456')
+    .option('-h, --host <host>', 'Host to bind to', 'localhost')
+    .option('-k, --api-key <key>', 'API key for authentication')
+    .option('--no-cors', 'Disable CORS')
+    .option('-t, --templates <dir>', 'Custom templates directory')
+    .action(async (options) => {
+    console.log(chalk.blue('\n🚀 Intent Blueprint - API Server\n'));
+    const { ApiServer } = await import('./enterprise/api/index.js');
+    const { TemplateLoader } = await import('./enterprise/templates/index.js');
+    const server = new ApiServer({
+        port: parseInt(options.port),
+        host: options.host,
+        apiKey: options.apiKey,
+        cors: options.cors !== false,
+        logging: true,
+    });
+    // Load custom templates if specified
+    if (options.templates) {
+        const { existsSync } = await import('fs');
+        if (existsSync(options.templates)) {
+            const loader = new TemplateLoader(options.templates);
+            try {
+                const templates = loader.loadDirectory(options.templates);
+                server.loadTemplates(templates);
+                console.log(chalk.dim(`Loaded ${templates.length} custom templates\n`));
+            }
+            catch (error) {
+                console.log(chalk.yellow(`Warning: Failed to load templates from ${options.templates}`));
+            }
+        }
+    }
+    try {
+        await server.start();
+        console.log(chalk.dim('Press Ctrl+C to stop\n'));
+        // Handle shutdown
+        process.on('SIGINT', async () => {
+            console.log(chalk.dim('\nShutting down...'));
+            await server.stop();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        console.log(chalk.red('Failed to start server'));
+        console.error(error);
+        process.exit(1);
+    }
+});
+// Enterprise: Template management
+program
+    .command('template <action>')
+    .description('Manage custom templates (list, create, validate, export)')
+    .option('-i, --id <id>', 'Template ID')
+    .option('-n, --name <name>', 'Template name')
+    .option('-f, --file <path>', 'Template file path')
+    .option('-o, --output <path>', 'Output file path')
+    .action(async (action, options) => {
+    const { TemplateLoader, TemplateEngine } = await import('./enterprise/templates/index.js');
+    const loader = new TemplateLoader();
+    switch (action) {
+        case 'list': {
+            console.log(chalk.blue('\n📋 Custom Templates\n'));
+            const { existsSync, readdirSync } = await import('fs');
+            const templatesDir = './templates';
+            if (!existsSync(templatesDir)) {
+                console.log(chalk.dim('No custom templates directory found.'));
+                console.log(chalk.dim('Create templates in ./templates/ directory.'));
+                return;
+            }
+            try {
+                const templates = loader.loadDirectory(templatesDir);
+                if (templates.length === 0) {
+                    console.log(chalk.dim('No templates found.'));
+                    return;
+                }
+                for (const t of templates) {
+                    console.log(`  ${chalk.cyan(t.meta.id.padEnd(25))} ${t.meta.name}`);
+                    console.log(chalk.dim(`    ${t.meta.description}`));
+                }
+                console.log(chalk.dim(`\nTotal: ${templates.length} templates`));
+            }
+            catch (error) {
+                console.log(chalk.red('Failed to load templates'));
+                console.error(error);
+            }
+            break;
+        }
+        case 'create': {
+            console.log(chalk.blue('\n✨ Create Custom Template\n'));
+            const id = options.id || 'custom-template';
+            const name = options.name || 'Custom Template';
+            const template = TemplateLoader.createBlankTemplate(id, name);
+            const yaml = TemplateLoader.toYaml(template);
+            if (options.output) {
+                const { writeFileSync, mkdirSync, existsSync } = await import('fs');
+                const { dirname } = await import('path');
+                const dir = dirname(options.output);
+                if (!existsSync(dir)) {
+                    mkdirSync(dir, { recursive: true });
+                }
+                writeFileSync(options.output, yaml);
+                console.log(chalk.green(`Created: ${options.output}`));
+            }
+            else {
+                console.log(yaml);
+            }
+            break;
+        }
+        case 'validate': {
+            console.log(chalk.blue('\n✅ Validate Template\n'));
+            if (!options.file) {
+                console.log(chalk.red('Error: --file required'));
+                return;
+            }
+            try {
+                const template = loader.loadFile(options.file);
+                console.log(chalk.green('Template is valid!'));
+                console.log(`  ID: ${template.meta.id}`);
+                console.log(`  Name: ${template.meta.name}`);
+                console.log(`  Variables: ${template.variables.length}`);
+                console.log(`  Sections: ${template.sections.length}`);
+            }
+            catch (error) {
+                console.log(chalk.red('Template validation failed:'));
+                console.error(error);
+            }
+            break;
+        }
+        case 'export': {
+            console.log(chalk.blue('\n📤 Export Template to YAML\n'));
+            if (!options.file && !options.id) {
+                console.log(chalk.red('Error: --file or --id required'));
+                return;
+            }
+            try {
+                const template = options.file
+                    ? loader.loadFile(options.file)
+                    : TemplateLoader.createBlankTemplate(options.id, options.name || options.id);
+                const yaml = TemplateLoader.toYaml(template);
+                if (options.output) {
+                    const { writeFileSync } = await import('fs');
+                    writeFileSync(options.output, yaml);
+                    console.log(chalk.green(`Exported to: ${options.output}`));
+                }
+                else {
+                    console.log(yaml);
+                }
+            }
+            catch (error) {
+                console.log(chalk.red('Export failed:'));
+                console.error(error);
+            }
+            break;
+        }
+        default:
+            console.log(chalk.yellow(`Unknown action: ${action}`));
+            console.log(chalk.dim('Available actions: list, create, validate, export'));
+    }
+});
+// Enterprise: Team management
+program
+    .command('team <action>')
+    .description('Manage team configuration (init, members, libraries)')
+    .option('-i, --id <id>', 'Team or member ID')
+    .option('-n, --name <name>', 'Name')
+    .option('-e, --email <email>', 'Email')
+    .option('-r, --role <role>', 'Role: owner, admin, member, viewer')
+    .action(async (action, options) => {
+    const { TeamConfigManager } = await import('./enterprise/team/index.js');
+    const manager = new TeamConfigManager();
+    switch (action) {
+        case 'init': {
+            console.log(chalk.blue('\n🏢 Initialize Team Configuration\n'));
+            const id = options.id || 'my-team';
+            const name = options.name || 'My Team';
+            const config = manager.init(id, name);
+            console.log(chalk.green('Team configuration created!'));
+            console.log(`  ID: ${config.id}`);
+            console.log(`  Name: ${config.name}`);
+            console.log(`  Config: ${manager.getConfigPath()}`);
+            break;
+        }
+        case 'info': {
+            console.log(chalk.blue('\n🏢 Team Information\n'));
+            const config = manager.get();
+            if (!config) {
+                console.log(chalk.dim('No team configuration found.'));
+                console.log(chalk.dim('Run: blueprint team init'));
+                return;
+            }
+            console.log(`  ID: ${config.id}`);
+            console.log(`  Name: ${config.name}`);
+            console.log(`  Members: ${config.members?.length || 0}`);
+            console.log(`  Libraries: ${config.libraries?.length || 0}`);
+            console.log(`  Audit: ${config.audit?.enabled ? 'enabled' : 'disabled'}`);
+            break;
+        }
+        case 'add-member': {
+            console.log(chalk.blue('\n👤 Add Team Member\n'));
+            if (!options.id || !options.name) {
+                console.log(chalk.red('Error: --id and --name required'));
+                return;
+            }
+            try {
+                manager.addMember({
+                    id: options.id,
+                    name: options.name,
+                    email: options.email,
+                    role: options.role || 'member',
+                });
+                console.log(chalk.green(`Added member: ${options.name}`));
+            }
+            catch (error) {
+                console.log(chalk.red('Failed to add member:'));
+                console.error(error);
+            }
+            break;
+        }
+        case 'remove-member': {
+            console.log(chalk.blue('\n👤 Remove Team Member\n'));
+            if (!options.id) {
+                console.log(chalk.red('Error: --id required'));
+                return;
+            }
+            const removed = manager.removeMember(options.id);
+            if (removed) {
+                console.log(chalk.green(`Removed member: ${options.id}`));
+            }
+            else {
+                console.log(chalk.yellow(`Member not found: ${options.id}`));
+            }
+            break;
+        }
+        case 'list-members': {
+            console.log(chalk.blue('\n👥 Team Members\n'));
+            const members = manager.listMembers();
+            if (members.length === 0) {
+                console.log(chalk.dim('No team members.'));
+                return;
+            }
+            for (const m of members) {
+                console.log(`  ${chalk.cyan(m.id.padEnd(20))} ${m.name} (${m.role})`);
+                if (m.email)
+                    console.log(chalk.dim(`    ${m.email}`));
+            }
+            break;
+        }
+        case 'audit': {
+            console.log(chalk.blue('\n📊 Audit Log\n'));
+            const { AuditTrail } = await import('./enterprise/team/index.js');
+            const config = manager.get();
+            const audit = config
+                ? AuditTrail.fromTeamConfig(config)
+                : new AuditTrail();
+            const stats = audit.getStats();
+            console.log(`  Total generations: ${stats.totalGenerations}`);
+            console.log(`  Successful: ${stats.successfulGenerations}`);
+            console.log(`  Failed: ${stats.failedGenerations}`);
+            console.log(`  Avg duration: ${Math.round(stats.averageDuration)}ms`);
+            if (stats.recentActivity.length > 0) {
+                console.log(chalk.yellow('\nRecent activity:'));
+                for (const entry of stats.recentActivity.slice(0, 5)) {
+                    console.log(`  ${chalk.dim(entry.timestamp)} ${entry.action} ${entry.template}`);
+                }
+            }
+            break;
+        }
+        default:
+            console.log(chalk.yellow(`Unknown action: ${action}`));
+            console.log(chalk.dim('Available actions: init, info, add-member, remove-member, list-members, audit'));
+    }
+});
+// Enterprise: Model configuration
+program
+    .command('model <action>')
+    .description('Configure AI models (list, use, test)')
+    .option('-p, --provider <provider>', 'Provider: claude, openai, gemini, ollama')
+    .option('-m, --model <model>', 'Model ID or alias')
+    .option('-k, --key <key>', 'API key')
+    .option('--prompt <prompt>', 'Test prompt')
+    .action(async (action, options) => {
+    const { ModelRegistry } = await import('./enterprise/models/index.js');
+    switch (action) {
+        case 'list': {
+            console.log(chalk.blue('\n🤖 Available Models\n'));
+            const registry = new ModelRegistry();
+            const providers = registry.listProviders();
+            for (const p of providers) {
+                const status = p.configured ? chalk.green('✓') : chalk.red('✗');
+                console.log(`  ${status} ${chalk.cyan(p.name.padEnd(10))} ${p.configured ? 'configured' : 'not configured'}`);
+            }
+            console.log(chalk.dim('\nSet API keys via environment variables:'));
+            console.log(chalk.dim('  ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY'));
+            break;
+        }
+        case 'test': {
+            console.log(chalk.blue('\n🧪 Test Model\n'));
+            const provider = options.provider || 'claude';
+            const prompt = options.prompt || 'Say hello in one sentence.';
+            const registry = new ModelRegistry();
+            const providerInstance = registry.getProvider(provider);
+            if (!providerInstance) {
+                console.log(chalk.red(`Unknown provider: ${provider}`));
+                return;
+            }
+            if (!providerInstance.isConfigured()) {
+                console.log(chalk.red(`Provider ${provider} is not configured.`));
+                console.log(chalk.dim('Set the appropriate API key environment variable.'));
+                return;
+            }
+            const spinner = ora(`Testing ${provider}...`).start();
+            try {
+                const response = await registry.complete({
+                    messages: [{ role: 'user', content: prompt }],
+                    maxTokens: 100,
+                }, provider);
+                spinner.succeed(chalk.green('Model responded!'));
+                console.log(`\n${chalk.cyan('Response:')} ${response.content}`);
+                if (response.usage) {
+                    console.log(chalk.dim(`\nTokens: ${response.usage.promptTokens} in, ${response.usage.completionTokens} out`));
+                }
+            }
+            catch (error) {
+                spinner.fail(chalk.red('Test failed'));
+                console.error(error);
+            }
+            break;
+        }
+        case 'info': {
+            console.log(chalk.blue('\n📋 Model Information\n'));
+            const modelId = options.model || 'claude';
+            const registry = new ModelRegistry();
+            const { provider, model } = registry.resolveAlias(modelId);
+            console.log(`  Alias: ${modelId}`);
+            console.log(`  Provider: ${provider}`);
+            console.log(`  Model: ${model}`);
+            const info = await registry.getModelInfo(model);
+            if (info) {
+                if (info.contextWindow)
+                    console.log(`  Context: ${info.contextWindow.toLocaleString()} tokens`);
+                if (info.maxOutput)
+                    console.log(`  Max output: ${info.maxOutput.toLocaleString()} tokens`);
+                if (info.capabilities)
+                    console.log(`  Capabilities: ${info.capabilities.join(', ')}`);
+                if (info.pricing) {
+                    console.log(`  Pricing: $${info.pricing.input}/M in, $${info.pricing.output}/M out`);
+                }
+            }
+            break;
+        }
+        default:
+            console.log(chalk.yellow(`Unknown action: ${action}`));
+            console.log(chalk.dim('Available actions: list, test, info'));
+    }
+});
 /**
  * Handle Linear export
  */
@@ -849,5 +1215,194 @@ async function handleJiraExport(options) {
         process.exit(1);
     }
 }
+/**
+ * Handle Notion export
+ */
+async function handleNotionExport(options) {
+    console.log(chalk.blue('\n📝 Intent Blueprint - Notion Export\n'));
+    const { NotionExporter, NotionClient } = await import('./integrations/notion/index.js');
+    // Get Notion API key
+    const apiKey = options.token || process.env.NOTION_API_KEY;
+    if (!apiKey) {
+        console.log(chalk.red('Error: Notion API key required'));
+        console.log(chalk.dim('Use --token or set NOTION_API_KEY environment variable'));
+        console.log(chalk.dim('Get your integration token from: https://www.notion.so/my-integrations'));
+        process.exit(1);
+    }
+    let parentPageId = options.pageId;
+    let databaseId = options.databaseId;
+    // Verify connection
+    try {
+        const tempClient = new NotionClient({ apiKey });
+        await tempClient.verify();
+        console.log(chalk.dim('Connected to Notion\n'));
+    }
+    catch (error) {
+        console.log(chalk.red('Error: Could not connect to Notion. Check your API key.'));
+        console.error(error);
+        process.exit(1);
+    }
+    // If no parent page or database specified, try to list available pages
+    if (!parentPageId && !databaseId) {
+        console.log(chalk.dim('No parent page or database specified. Searching for accessible pages...\n'));
+        const tempClient = new NotionClient({ apiKey });
+        try {
+            const pages = await tempClient.listPages();
+            const databases = await tempClient.listDatabases();
+            if (pages.length === 0 && databases.length === 0) {
+                console.log(chalk.red('Error: No pages or databases accessible to this integration.'));
+                console.log(chalk.dim('Make sure you\'ve shared a page with your integration in Notion.'));
+                process.exit(1);
+            }
+            // Let user choose
+            const choices = [];
+            for (const page of pages.slice(0, 10)) {
+                const title = page.properties.title?.title?.[0]?.plain_text || 'Untitled';
+                choices.push({ name: `📄 ${title} (page)`, value: { type: 'page', id: page.id } });
+            }
+            for (const db of databases.slice(0, 10)) {
+                const title = db.title?.[0]?.plain_text || 'Untitled';
+                choices.push({ name: `🗃️ ${title} (database)`, value: { type: 'database', id: db.id } });
+            }
+            const answer = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'target',
+                    message: 'Select where to export documents:',
+                    choices,
+                },
+            ]);
+            if (answer.target.type === 'page') {
+                parentPageId = answer.target.id;
+            }
+            else {
+                databaseId = answer.target.id;
+            }
+        }
+        catch (error) {
+            console.log(chalk.red('Error: Could not list pages/databases.'));
+            console.error(error);
+            process.exit(1);
+        }
+    }
+    // Read generated docs
+    const docsDir = options.docs || './docs';
+    const { readdirSync, readFileSync, existsSync } = await import('fs');
+    const { join } = await import('path');
+    if (!existsSync(docsDir)) {
+        console.log(chalk.red(`Error: Docs directory not found: ${docsDir}`));
+        console.log(chalk.dim('Generate docs first with: blueprint generate'));
+        process.exit(1);
+    }
+    // Find project folder
+    const projects = readdirSync(docsDir).filter((f) => {
+        const path = join(docsDir, f);
+        return existsSync(path) && readdirSync(path).some((file) => file.endsWith('.md'));
+    });
+    if (projects.length === 0) {
+        console.log(chalk.red('Error: No documentation projects found'));
+        process.exit(1);
+    }
+    let projectDir = projects[0];
+    if (projects.length > 1 && !options.project) {
+        const answer = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'project',
+                message: 'Select project:',
+                choices: projects,
+            },
+        ]);
+        projectDir = answer.project;
+    }
+    else if (options.project) {
+        projectDir = options.project;
+    }
+    const projectPath = join(docsDir, projectDir);
+    const files = readdirSync(projectPath).filter((f) => f.endsWith('.md'));
+    const documents = files.map((f) => ({
+        name: f.replace('.md', '').replace(/-/g, ' '),
+        content: readFileSync(join(projectPath, f), 'utf-8'),
+    }));
+    console.log(`Found ${documents.length} documents in ${projectDir}\n`);
+    const exporter = new NotionExporter({
+        apiKey,
+        parentPageId,
+        databaseId,
+    });
+    if (options.dryRun) {
+        console.log(chalk.yellow('Dry run - showing what would be created:\n'));
+        const preview = await exporter.preview(documents, {
+            createDatabase: options.createDatabase,
+            databaseTitle: projectDir,
+            parentPageId,
+            addCategory: true,
+            addStatus: true,
+            convertContent: true,
+            dryRun: true,
+        });
+        if (preview.database) {
+            console.log(chalk.cyan('Database:'), preview.database.title[0]?.text?.content || 'Blueprint Documents');
+        }
+        console.log(chalk.cyan('Pages:'), preview.pages.length);
+        if (preview.pages.length > 0) {
+            console.log(chalk.dim('\nSample pages:'));
+            for (const page of preview.pages.slice(0, 5)) {
+                const title = page.properties.Name?.title?.[0]?.text?.content || 'Untitled';
+                console.log(`  ${chalk.dim('•')} ${title}`);
+            }
+            if (preview.pages.length > 5) {
+                console.log(chalk.dim(`  ... and ${preview.pages.length - 5} more`));
+            }
+        }
+        return;
+    }
+    const spinner = ora('Exporting to Notion...').start();
+    try {
+        const result = await exporter.export(documents, {
+            createDatabase: options.createDatabase,
+            databaseTitle: projectDir,
+            parentPageId,
+            addCategory: true,
+            addStatus: true,
+            convertContent: true,
+            dryRun: false,
+        });
+        if (result.errors.length === 0) {
+            spinner.succeed(chalk.green('Export complete!'));
+            if (result.database) {
+                console.log(`\n  Database created: ${result.database.title[0]?.text?.content || 'Blueprint Documents'}`);
+                console.log(chalk.dim(`    ${result.database.url}`));
+            }
+            console.log(`  Pages created: ${result.pages.length}`);
+            if (result.pages.length > 0) {
+                console.log(chalk.cyan('\nCreated pages:'));
+                for (const page of result.pages.slice(0, 5)) {
+                    const title = page.properties.Name?.title?.[0]?.text?.content ||
+                        page.properties.title?.title?.[0]?.text?.content ||
+                        'Untitled';
+                    console.log(`  ${title}`);
+                    console.log(chalk.dim(`    ${page.url}`));
+                }
+                if (result.pages.length > 5) {
+                    console.log(chalk.dim(`  ... and ${result.pages.length - 5} more`));
+                }
+            }
+        }
+        else {
+            spinner.fail(chalk.red('Export completed with errors'));
+            console.log(`\n  Pages created: ${result.pages.length}`);
+            console.log(chalk.red('\nErrors:'));
+            for (const error of result.errors) {
+                console.log(chalk.red(`  ${error}`));
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Export failed'));
+        console.error(error);
+        process.exit(1);
+    }
+}
 program.parse();
 //# sourceMappingURL=cli.js.map