@bhimudev/gnanai 0.4.0

package/dist/commands/setup-config.js

@@ -0,0 +1,663 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import { logger } from '../utils/logger.js';
+import { getPresetCommands, createClaudeSettings, generatePermissionsMarkdown, } from '../scaffold/create-claude-settings.js';
+const FILE_PATH = 'archai.config.md';
+const PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn', 'bun', 'pip', 'cargo', 'go', 'other'];
+export async function setupConfig(options) {
+    logger.banner();
+    // Check if file exists
+    const exists = await fs.pathExists(FILE_PATH);
+    if (!exists) {
+        logger.error('archai.config.md not found!');
+        console.log('');
+        logger.info('Run `archai init` first to create the configuration file.');
+        return;
+    }
+    // Load existing config
+    const existing = await parseExistingConfig();
+    console.log('');
+    logger.section('Configuration Wizard');
+    console.log(chalk.gray('   Configure your project settings and define specialists.'));
+    console.log(chalk.gray('   Press Enter to keep existing values.'));
+    console.log('');
+    // Section 1: Tech Stack
+    logger.section('1. Tech Stack');
+    console.log('');
+    const stackAnswers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'languages',
+            message: 'Programming languages:',
+            default: existing.languages || '',
+        },
+        {
+            type: 'input',
+            name: 'frameworks',
+            message: 'Frameworks/libraries:',
+            default: existing.frameworks || '',
+        },
+        {
+            type: 'input',
+            name: 'testing',
+            message: 'Testing framework:',
+            default: existing.testing || '',
+        },
+        {
+            type: 'input',
+            name: 'additionalTech',
+            message: 'Additional technologies (databases, caching, etc.):',
+            default: '',
+        },
+    ]);
+    // Section 2: Commands
+    console.log('');
+    logger.section('2. Commands');
+    console.log('');
+    const pmDefault = existing.packageManager || 'npm';
+    const pmCommands = getPackageManagerCommands(pmDefault);
+    const commandAnswers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'packageManager',
+            message: 'Package manager:',
+            choices: PACKAGE_MANAGERS,
+            default: pmDefault,
+        },
+        {
+            type: 'input',
+            name: 'installCommand',
+            message: 'Install command:',
+            default: (answers) => {
+                const cmds = getPackageManagerCommands(answers.packageManager);
+                return existing.installCommand || cmds.install || '';
+            },
+        },
+        {
+            type: 'input',
+            name: 'buildCommand',
+            message: 'Build command:',
+            default: (answers) => {
+                const cmds = getPackageManagerCommands(answers.packageManager);
+                return existing.buildCommand || cmds.build || '';
+            },
+        },
+        {
+            type: 'input',
+            name: 'testCommand',
+            message: 'Test command:',
+            default: (answers) => {
+                const cmds = getPackageManagerCommands(answers.packageManager);
+                return existing.testCommand || cmds.test || '';
+            },
+        },
+        {
+            type: 'input',
+            name: 'lintCommand',
+            message: 'Lint command:',
+            default: (answers) => {
+                const cmds = getPackageManagerCommands(answers.packageManager);
+                return existing.lintCommand || cmds.lint || '';
+            },
+        },
+        {
+            type: 'input',
+            name: 'devCommand',
+            message: 'Dev/run command:',
+            default: (answers) => {
+                const cmds = getPackageManagerCommands(answers.packageManager);
+                return existing.devCommand || cmds.dev || '';
+            },
+        },
+    ]);
+    // Section 3: Project Structure
+    console.log('');
+    logger.section('3. Project Structure');
+    console.log('');
+    const structureAnswers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'sourceDirectory',
+            message: 'Source directory:',
+            default: existing.sourceDirectory || 'src/',
+        },
+        {
+            type: 'input',
+            name: 'testsDirectory',
+            message: 'Tests directory:',
+            default: existing.testsDirectory || 'tests/',
+        },
+        {
+            type: 'input',
+            name: 'keyFiles',
+            message: 'Key files agents should know about (comma-separated, format: "file:purpose"):',
+            default: '',
+        },
+    ]);
+    // Section 4: Specialists
+    console.log('');
+    logger.section('4. Specialist Agents');
+    console.log('');
+    console.log(chalk.gray('   Define specialist agents for your project.'));
+    console.log(chalk.gray('   Common types: frontend, backend, api, database, auth, devops, testing'));
+    console.log('');
+    const specialists = await specialistWizard();
+    // Section 5: Permissions
+    console.log('');
+    logger.section('5. Permissions');
+    console.log('');
+    console.log(chalk.gray('   Configure what commands Claude agents can execute.'));
+    console.log('');
+    const permissionAnswers = await permissionsWizard(commandAnswers.packageManager);
+    // Section 6: MCP/Skills info
+    console.log('');
+    logger.section('6. MCP Servers & Skills');
+    console.log('');
+    console.log(chalk.gray('   MCP servers extend agent capabilities with external tools.'));
+    console.log(chalk.yellow('   Note: MCP configuration is added as a placeholder.'));
+    console.log(chalk.yellow('   Edit the config file manually to configure MCP servers.'));
+    console.log(chalk.cyan('   → See Claude Code documentation for MCP setup'));
+    console.log('');
+    // Combine answers
+    const answers = {
+        ...stackAnswers,
+        ...commandAnswers,
+        ...structureAnswers,
+        specialists,
+        ...permissionAnswers,
+    };
+    // Generate config
+    console.log('');
+    const spinner = ora('Updating configuration...').start();
+    const content = generateConfig(answers, existing);
+    await fs.writeFile(FILE_PATH, content);
+    // Generate .claude/settings.local.json
+    const permissionConfig = {
+        preset: answers.permissionPreset,
+        packageManager: answers.packageManager,
+        customAllowCommands: answers.customAllowCommands,
+        customDenyCommands: answers.customDenyCommands,
+    };
+    await createClaudeSettings(permissionConfig);
+    spinner.succeed('Updated archai.config.md');
+    if (answers.permissionPreset !== 'skip') {
+        console.log(chalk.green('   ✓ Created .claude/settings.local.json'));
+    }
+    // Final output
+    console.log('');
+    logger.divider();
+    console.log('');
+    logger.success('Configuration updated!');
+    console.log('');
+    if (specialists.length > 0) {
+        console.log(chalk.white(`Defined ${specialists.length} specialist(s):`));
+        specialists.forEach(s => {
+            console.log(chalk.cyan(`   • ${s.name}-specialist`));
+        });
+        console.log('');
+    }
+    logger.section('Next Steps');
+    console.log('');
+    console.log(chalk.white('1. Review your configuration:'));
+    console.log(chalk.cyan('   → archai.config.md'));
+    console.log('');
+    console.log(chalk.white('2. Configure MCP servers (optional):'));
+    console.log(chalk.cyan('   → Edit the "MCP Servers & Skills" section in archai.config.md'));
+    console.log('');
+    console.log(chalk.white('3. Generate specialist agents:'));
+    console.log(chalk.cyan('   → archai generate'));
+    console.log('');
+}
+async function specialistWizard() {
+    const specialists = [];
+    const { addSpecialists } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'addSpecialists',
+            message: 'Would you like to define specialist agents?',
+            default: true,
+        }]);
+    if (!addSpecialists) {
+        return specialists;
+    }
+    let addMore = true;
+    while (addMore) {
+        console.log('');
+        const { name } = await inquirer.prompt([{
+                type: 'input',
+                name: 'name',
+                message: 'Specialist name (e.g., "frontend", "api", "database"):',
+                validate: (input) => {
+                    if (!input.trim())
+                        return 'Name is required';
+                    if (input.includes(' '))
+                        return 'Use lowercase with no spaces (e.g., "frontend" not "front end")';
+                    return true;
+                },
+            }]);
+        const { focus } = await inquirer.prompt([{
+                type: 'input',
+                name: 'focus',
+                message: `What does ${name}-specialist focus on?`,
+                default: '',
+            }]);
+        const { concerns } = await inquirer.prompt([{
+                type: 'input',
+                name: 'concerns',
+                message: 'Key concerns (comma-separated):',
+                default: '',
+            }]);
+        const keyConcerns = concerns
+            .split(',')
+            .map((c) => c.trim())
+            .filter(Boolean);
+        specialists.push({ name: name.toLowerCase(), focus, keyConcerns });
+        console.log(chalk.green(`   ✓ Added ${name}-specialist`));
+        const { more } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'more',
+                message: 'Add another specialist?',
+                default: specialists.length < 3,
+            }]);
+        addMore = more;
+    }
+    return specialists;
+}
+async function permissionsWizard(packageManager) {
+    const { preset } = await inquirer.prompt([{
+            type: 'list',
+            name: 'preset',
+            message: 'Permission level:',
+            choices: [
+                {
+                    name: `${chalk.green('Permissive')} - ${chalk.gray('Everything except irreversible actions')}`,
+                    value: 'permissive',
+                },
+                {
+                    name: `${chalk.yellow('Strict')} - ${chalk.gray('Only safe operations (no network, no push)')}`,
+                    value: 'strict',
+                },
+                {
+                    name: `${chalk.cyan('Custom')} - ${chalk.gray('Define your own commands')}`,
+                    value: 'custom',
+                },
+                {
+                    name: `${chalk.gray('Skip')} - ${chalk.gray('Configure manually later')}`,
+                    value: 'skip',
+                },
+            ],
+            default: 'permissive',
+        }]);
+    if (preset === 'skip') {
+        return { permissionPreset: 'skip' };
+    }
+    // Show what the preset includes
+    const { allow, deny } = getPresetCommands(preset, packageManager);
+    console.log('');
+    if (preset === 'permissive') {
+        console.log(chalk.white('   This mode allows almost everything except:'));
+        console.log(chalk.red('   • rm -rf, git push --force, git reset --hard'));
+        console.log(chalk.red('   • sudo, credential exposure, remote code execution'));
+        console.log(chalk.red('   • Database drops, container destruction'));
+    }
+    else if (preset === 'strict') {
+        console.log(chalk.white('   This mode only allows:'));
+        console.log(chalk.green('   • Package manager (install, run, test)'));
+        console.log(chalk.green('   • Build tools (tsc, eslint, jest, pytest)'));
+        console.log(chalk.green('   • Read operations (cat, grep, ls, find)'));
+        console.log(chalk.green('   • Git (status, diff, add, commit, fetch, pull)'));
+        console.log(chalk.yellow('   • NO: git push, curl, npm publish'));
+    }
+    if (preset === 'custom') {
+        console.log(chalk.white('   Define allowed commands:'));
+        console.log(chalk.gray('   Use * for wildcards (e.g., "npm *", "git status")'));
+        console.log('');
+        const { allowInput } = await inquirer.prompt([{
+                type: 'input',
+                name: 'allowInput',
+                message: 'Allowed commands (comma-separated):',
+                default: `${packageManager} *, git status, git diff, git add *, git commit *`,
+            }]);
+        const { denyInput } = await inquirer.prompt([{
+                type: 'input',
+                name: 'denyInput',
+                message: 'Additional denied patterns (comma-separated, or Enter for defaults):',
+                default: '',
+            }]);
+        const customAllow = allowInput
+            .split(',')
+            .map((cmd) => cmd.trim())
+            .filter(Boolean);
+        const customDeny = denyInput
+            .split(',')
+            .map((cmd) => cmd.trim())
+            .filter(Boolean);
+        console.log('');
+        console.log(chalk.green(`   ✓ ${customAllow.length} allow patterns configured`));
+        if (customDeny.length > 0) {
+            console.log(chalk.yellow(`   ✓ ${customDeny.length} additional deny patterns`));
+        }
+        return {
+            permissionPreset: 'custom',
+            customAllowCommands: customAllow,
+            customDenyCommands: customDeny,
+        };
+    }
+    // For permissive/strict, ask if they want to add any additional allowed commands
+    const { addMore } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'addMore',
+            message: 'Add any additional allowed commands?',
+            default: false,
+        }]);
+    if (addMore) {
+        const { extraCommands } = await inquirer.prompt([{
+                type: 'input',
+                name: 'extraCommands',
+                message: 'Additional allowed commands (comma-separated):',
+                default: '',
+            }]);
+        const extra = extraCommands
+            .split(',')
+            .map((cmd) => cmd.trim())
+            .filter(Boolean);
+        if (extra.length > 0) {
+            console.log(chalk.green(`   ✓ Added ${extra.length} extra commands`));
+            return {
+                permissionPreset: preset,
+                customAllowCommands: [...allow, ...extra],
+            };
+        }
+    }
+    console.log(chalk.green(`   ✓ ${preset.charAt(0).toUpperCase() + preset.slice(1)} mode selected`));
+    return { permissionPreset: preset };
+}
+async function parseExistingConfig() {
+    const defaults = {
+        projectName: 'my-project',
+        projectType: '',
+        isMonorepo: false,
+        languages: '',
+        frameworks: '',
+        testing: '',
+        packageManager: 'npm',
+        installCommand: '',
+        buildCommand: '',
+        testCommand: '',
+        lintCommand: '',
+        devCommand: '',
+        sourceDirectory: 'src/',
+        testsDirectory: 'tests/',
+    };
+    try {
+        const content = await fs.readFile(FILE_PATH, 'utf-8');
+        // Parse basic info
+        const nameMatch = content.match(/\*\*Name:\*\*\s*(.+)/);
+        if (nameMatch)
+            defaults.projectName = nameMatch[1].trim();
+        const typeMatch = content.match(/\*\*Type:\*\*\s*(.+)/);
+        if (typeMatch && !typeMatch[1].includes('[TODO')) {
+            defaults.projectType = typeMatch[1].trim();
+        }
+        const monoMatch = content.match(/\*\*Monorepo:\*\*\s*(Yes|No)/i);
+        if (monoMatch)
+            defaults.isMonorepo = monoMatch[1].toLowerCase() === 'yes';
+        // Parse tech stack
+        const langMatch = content.match(/\*\*Languages:\*\*\s*(.+)/);
+        if (langMatch && !langMatch[1].includes('[TODO')) {
+            defaults.languages = langMatch[1].trim();
+        }
+        const fwMatch = content.match(/\*\*Frameworks:\*\*\s*(.+)/);
+        if (fwMatch && !fwMatch[1].includes('[TODO')) {
+            defaults.frameworks = fwMatch[1].trim();
+        }
+        const testMatch = content.match(/\*\*Testing:\*\*\s*(.+)/);
+        if (testMatch && !testMatch[1].includes('[TODO')) {
+            defaults.testing = testMatch[1].trim();
+        }
+        // Parse package manager
+        const pmMatch = content.match(/\*\*Package Manager:\*\*\s*(.+)/);
+        if (pmMatch && !pmMatch[1].includes('[TODO')) {
+            defaults.packageManager = pmMatch[1].trim();
+        }
+        // Parse commands from table
+        const installMatch = content.match(/\| Install \| (.+) \|/);
+        if (installMatch && !installMatch[1].includes('[TODO')) {
+            defaults.installCommand = installMatch[1].trim();
+        }
+        const buildMatch = content.match(/\| Build \| (.+) \|/);
+        if (buildMatch && !buildMatch[1].includes('[TODO')) {
+            defaults.buildCommand = buildMatch[1].trim();
+        }
+        const testCmdMatch = content.match(/\| Test \| (.+) \|/);
+        if (testCmdMatch && !testCmdMatch[1].includes('[TODO')) {
+            defaults.testCommand = testCmdMatch[1].trim();
+        }
+        const lintMatch = content.match(/\| Lint \| (.+) \|/);
+        if (lintMatch && !lintMatch[1].includes('[TODO')) {
+            defaults.lintCommand = lintMatch[1].trim();
+        }
+        const devMatch = content.match(/\| Dev \| (.+) \|/);
+        if (devMatch && !devMatch[1].includes('[TODO')) {
+            defaults.devCommand = devMatch[1].trim();
+        }
+        // Parse structure
+        const srcMatch = content.match(/\*\*Source Directory:\*\*\s*(.+)/);
+        if (srcMatch)
+            defaults.sourceDirectory = srcMatch[1].trim();
+        const testsMatch = content.match(/\*\*Tests Directory:\*\*\s*(.+)/);
+        if (testsMatch)
+            defaults.testsDirectory = testsMatch[1].trim();
+    }
+    catch (error) {
+        logger.debug('Failed to parse existing config', {
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+    return defaults;
+}
+function getPackageManagerCommands(pm) {
+    const commands = {
+        npm: {
+            install: 'npm install',
+            build: 'npm run build',
+            test: 'npm test',
+            lint: 'npm run lint',
+            dev: 'npm run dev',
+        },
+        pnpm: {
+            install: 'pnpm install',
+            build: 'pnpm build',
+            test: 'pnpm test',
+            lint: 'pnpm lint',
+            dev: 'pnpm dev',
+        },
+        yarn: {
+            install: 'yarn',
+            build: 'yarn build',
+            test: 'yarn test',
+            lint: 'yarn lint',
+            dev: 'yarn dev',
+        },
+        bun: {
+            install: 'bun install',
+            build: 'bun run build',
+            test: 'bun test',
+            lint: 'bun run lint',
+            dev: 'bun run dev',
+        },
+        pip: {
+            install: 'pip install -r requirements.txt',
+            build: 'python -m build',
+            test: 'pytest',
+            lint: 'ruff check .',
+            dev: 'python main.py',
+        },
+        cargo: {
+            install: 'cargo build',
+            build: 'cargo build --release',
+            test: 'cargo test',
+            lint: 'cargo clippy',
+            dev: 'cargo run',
+        },
+        go: {
+            install: 'go mod download',
+            build: 'go build',
+            test: 'go test ./...',
+            lint: 'golangci-lint run',
+            dev: 'go run .',
+        },
+        other: {
+            install: '',
+            build: '',
+            test: '',
+            lint: '',
+            dev: '',
+        },
+    };
+    return commands[pm] || commands.other;
+}
+function generateConfig(answers, existing) {
+    const formatAdditionalTech = (input) => {
+        if (!input.trim())
+            return '-';
+        return input.split(',')
+            .map(item => `- ${item.trim()}`)
+            .filter(Boolean)
+            .join('\n');
+    };
+    const formatKeyFiles = (input) => {
+        if (!input.trim())
+            return '| | |';
+        return input.split(',')
+            .map(item => {
+            const [file, purpose] = item.split(':').map(s => s.trim());
+            return `| ${file || ''} | ${purpose || ''} |`;
+        })
+            .join('\n');
+    };
+    const formatSpecialists = (specialists) => {
+        if (specialists.length === 0) {
+            return `### 1. [TODO: Specialist Name]
+**Focus:** [What this specialist handles]
+**Key Concerns:**
+- [Concern 1]
+- [Concern 2]
+
+### 2. [Add more as needed]
+**Focus:**
+**Key Concerns:**
+-`;
+        }
+        return specialists.map((s, i) => {
+            const concerns = s.keyConcerns.length > 0
+                ? s.keyConcerns.map(c => `- ${c}`).join('\n')
+                : '- [Add key concerns]';
+            return `### ${i + 1}. ${s.name}
+**Focus:** ${s.focus || '[What this specialist handles]'}
+**Key Concerns:**
+${concerns}`;
+        }).join('\n\n');
+    };
+    return `# archai Project Configuration
+
+> Configuration for your archai agent system.
+> Run \`archai generate\` after updating this file.
+
+---
+
+## Project Info
+
+**Name:** ${existing.projectName}
+**Type:** ${existing.projectType || '[TODO: web, mobile, cli, game, ml, devops]'}
+**Monorepo:** ${existing.isMonorepo ? 'Yes' : 'No'}
+
+---
+
+## Tech Stack
+
+**Languages:** ${answers.languages || '[TODO: TypeScript, Python, Go, etc.]'}
+**Frameworks:** ${answers.frameworks || '[TODO: React, Express, Django, etc.]'}
+**Testing:** ${answers.testing || '[TODO: vitest, jest, pytest, etc.]'}
+
+### Additional Technologies
+${formatAdditionalTech(answers.additionalTech)}
+
+---
+
+## Commands
+
+**Package Manager:** ${answers.packageManager}
+
+| Command | Script |
+|---------|--------|
+| Install | ${answers.installCommand || '[TODO]'} |
+| Build | ${answers.buildCommand || '[TODO]'} |
+| Test | ${answers.testCommand || '[TODO]'} |
+| Lint | ${answers.lintCommand || '[TODO]'} |
+| Dev | ${answers.devCommand || '[TODO]'} |
+
+---
+
+## Project Structure
+
+**Source Directory:** ${answers.sourceDirectory}
+**Tests Directory:** ${answers.testsDirectory}
+
+### Key Files
+| File | Purpose |
+|------|---------|
+${formatKeyFiles(answers.keyFiles)}
+
+---
+
+## Specialists to Generate
+
+<!--
+These specialist agents will be generated by Claude Code.
+Run \`archai generate\` to create them.
+-->
+
+${formatSpecialists(answers.specialists)}
+
+---
+
+## MCP Servers & Skills
+
+<!--
+Configure MCP servers to extend agent capabilities.
+MCP (Model Context Protocol) allows agents to interact with external tools and services.
+
+Example configuration (edit manually):
+
+### Database Tools
+- Server: @anthropic/mcp-server-postgres
+- Purpose: Query and manage database
+
+### File System
+- Server: @anthropic/mcp-server-filesystem
+- Purpose: Enhanced file operations
+
+For setup instructions, see Claude Code documentation.
+-->
+
+[TODO: Configure MCP servers if needed]
+
+---
+
+${generatePermissionsMarkdown({
+        preset: answers.permissionPreset,
+        packageManager: answers.packageManager,
+        customAllowCommands: answers.customAllowCommands,
+        customDenyCommands: answers.customDenyCommands,
+    })}
+---
+
+## Notes
+
+<!-- Any additional context for agents -->
+
+`;
+}
+//# sourceMappingURL=setup-config.js.map