@relipa/ai-flow-kit 0.0.5-beta.0 → 0.0.5

package/scripts/init.js

@@ -1,9 +1,12 @@
 const fs = require('fs-extra');
 const path = require('path');
+const os = require('os');
 const chalk = require('chalk');
-const { input } = require('@inquirer/prompts');
+const { input, select, confirm } = require('@inquirer/prompts');
 
 const PKG_DIR = path.join(__dirname, '..');
+const GLOBAL_AIFLOW_DIR = path.join(os.homedir(), '.aiflow');
+const GLOBAL_CREDENTIALS_PATH = path.join(GLOBAL_AIFLOW_DIR, 'credentials.json');
 const PKG_VERSION = require('../package.json').version;
 
 // Map framework → language family for picking the right rules
@@ -20,43 +23,73 @@ const AI_TOOL_FILES = {
     'cursor':   '.cursorrules',
     'gemini':   'GEMINI.md',
     'copilot':  '.github/copilot-instructions.md',
-    'generic':  'AI_INSTRUCTIONS.md'
+    'generic':  '.aiflow/AI_INSTRUCTIONS.md'
 };
 
 /**
- * Copy documentation files and the docs/ folder to the project
+ * Copy only docs/common/ to .aiflow/docs in the project.
+ * Internal aiflow docs (changelog, architecture…) are never copied out.
  */
 async function copyDocsToProject(projectDir) {
-    const aiflowDocsDir = path.join(projectDir, '.aiflow', 'docs');
-    const srcDocsDir = path.join(PKG_DIR, 'docs');
-
-    // 1. Copy the entire docs/ folder to .aiflow/docs
-    if (await fs.pathExists(srcDocsDir)) {
-        await fs.ensureDir(aiflowDocsDir);
-        await fs.copy(srcDocsDir, aiflowDocsDir, { overwrite: true });
-        
-        // Ensure README.md is pulled into docs folder for developer visibility
-        const srcReadme = path.join(PKG_DIR, 'README.md');
-        if (await fs.pathExists(srcReadme)) {
-            await fs.copy(srcReadme, path.join(aiflowDocsDir, 'README.md'), { overwrite: true });
-        }
-        
-        console.log(chalk.green(`✓ Documentation folder copied to .aiflow/docs`));
-    }
+    const srcCommonDir = path.join(PKG_DIR, 'docs', 'common');
+    if (!(await fs.pathExists(srcCommonDir))) return;
 
-    // 2. Copy key markdown files to project root for easy access
-    const keyFiles = ['QUICK_START.md', 'AIFLOW.md'];
-    for (const file of keyFiles) {
-        const srcPath = path.join(srcDocsDir, file);
-        const destPath = path.join(projectDir, file);
-        if (await fs.pathExists(srcPath)) {
-            // We overwrite these to ensure they are up to date with the installed version
-            await fs.copy(srcPath, destPath, { overwrite: true });
-            console.log(chalk.gray(`  ✓ ${file} updated in project root`));
-        }
+    const destDir = path.join(projectDir, '.aiflow', 'docs');
+    await fs.ensureDir(destDir);
+    await fs.copy(srcCommonDir, destDir, { overwrite: true });
+    console.log(chalk.green(`✓ Documentation copied to .aiflow/docs`));
+}
+
+/**
+ * Scan the project directory to guess the framework.
+ * Returns a framework key or null if undetected.
+ */
+async function detectFramework(projectDir) {
+    // JS / TS — check package.json dependencies
+    const pkgPath = path.join(projectDir, 'package.json');
+    if (await fs.pathExists(pkgPath)) {
+        const pkg = await fs.readJson(pkgPath).catch(() => ({}));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps['next'])          return 'nextjs';
+        if (deps['nuxt'])          return 'vue-nuxt';
+        if (deps['vue'])           return 'vue-nuxt';
+        if (deps['@nestjs/core'])  return 'nodejs-express';
+        if (deps['react'])         return 'reactjs';
+        if (deps['express'] || deps['fastify']) return 'nodejs-express';
+    }
+    // Java — pom.xml / Gradle
+    if (await fs.pathExists(path.join(projectDir, 'pom.xml')))            return 'spring-boot';
+    if (await fs.pathExists(path.join(projectDir, 'build.gradle')))       return 'spring-boot';
+    if (await fs.pathExists(path.join(projectDir, 'build.gradle.kts')))   return 'spring-boot';
+    // PHP — composer.json
+    const composerPath = path.join(projectDir, 'composer.json');
+    if (await fs.pathExists(composerPath)) {
+        const composer = await fs.readJson(composerPath).catch(() => ({}));
+        if ((composer.require || {})['laravel/framework']) return 'laravel';
     }
+    // Python
+    if (await fs.pathExists(path.join(projectDir, 'manage.py'))) return 'python-django';
+    const reqPath = path.join(projectDir, 'requirements.txt');
+    if (await fs.pathExists(reqPath)) {
+        const reqs = (await fs.readFile(reqPath, 'utf-8').catch(() => '')).toLowerCase();
+        if (reqs.includes('fastapi')) return 'python-fastapi';
+        if (reqs.includes('django'))  return 'python-django';
+    }
+    return null;
 }
 
+const FRAMEWORK_CHOICES = [
+    { name: 'Spring Boot (Java)',  value: 'spring-boot' },
+    { name: 'React',               value: 'reactjs' },
+    { name: 'Next.js',             value: 'nextjs' },
+    { name: 'Vue / Nuxt',          value: 'vue-nuxt' },
+    { name: 'Laravel (PHP)',        value: 'laravel' },
+    { name: 'Node.js / Express',   value: 'nodejs-express' },
+    { name: 'Python Django',       value: 'python-django' },
+    { name: 'Python FastAPI',      value: 'python-fastapi' },
+    { name: 'Skip (no framework)', value: null },
+];
+
 async function copyAssetsToVersion(versionDir, framework) {
     // ── Skills: merge upstream + custom ──────────────────────────────
     const upstreamSkills = path.join(PKG_DIR, 'upstream', 'skills');
@@ -217,6 +250,9 @@ async function setupFramework(projectDir, framework, multi = false, selectedTool
     const separator = `\n\n---\n\n`;
     const skillRegistry = await generateSkillRegistry(projectDir);
 
+    const written = [];
+    const skipped = [];
+
     for (const tool of selectedTools) {
         const targetPath = path.join(projectDir, AI_TOOL_FILES[tool]);
         if (!targetPath) continue;
@@ -240,18 +276,51 @@ async function setupFramework(projectDir, framework, multi = false, selectedTool
 
         finalContent += frameworkContent;
 
+        const fileExists = await fs.pathExists(targetPath);
+
         if (!multi) {
+            if (fileExists) {
+                const relPath = path.relative(projectDir, targetPath).replace(/\\/g, '/');
+                const overwrite = await confirm({
+                    message: `  ${relPath} already exists — overwrite with aiflow template?`,
+                    default: false
+                });
+
+                if (!overwrite) {
+                    // Save aiflow template to .aiflow/reference/ so dev can compare/merge manually
+                    const refPath = path.join(projectDir, '.aiflow', 'reference', path.basename(targetPath));
+                    await fs.ensureDir(path.dirname(refPath));
+                    await fs.writeFile(refPath, finalContent);
+                    const refRel = path.relative(projectDir, refPath).replace(/\\/g, '/');
+                    skipped.push(relPath);
+                    console.log(chalk.gray(`    aiflow template saved to ${refRel} for reference`));
+                    continue;
+                }
+
+                // Backup existing file before overwriting
+                const backupPath = path.join(projectDir, '.aiflow', 'backup', path.basename(targetPath));
+                await fs.ensureDir(path.dirname(backupPath));
+                await fs.copy(targetPath, backupPath, { overwrite: true });
+                console.log(chalk.gray(`    Backed up ${relPath} → .aiflow/backup/${path.basename(targetPath)}`));
+            }
             await fs.writeFile(targetPath, finalContent);
+            written.push(AI_TOOL_FILES[tool]);
         } else {
-            if (await fs.pathExists(targetPath)) {
+            if (fileExists) {
                 await fs.appendFile(targetPath, separator + frameworkContent);
             } else {
                 await fs.writeFile(targetPath, finalContent);
             }
+            written.push(AI_TOOL_FILES[tool]);
         }
     }
 
-    console.log(chalk.green(`✓ AI instruction files updated for framework: ${framework} (${selectedTools.join(', ')})`));
+    if (written.length) {
+        console.log(chalk.green(`✓ AI instruction files updated for framework: ${framework} (${written.join(', ')})`));
+    }
+    if (skipped.length) {
+        console.log(chalk.yellow(`  Skipped (kept existing): ${skipped.join(', ')}`));
+    }
 }
 
 async function setupAdapter(projectDir, adapter) {
@@ -266,10 +335,10 @@ async function setupAdapter(projectDir, adapter) {
     const serverKey    = Object.keys(mcpServers)[0];
     const serverConfig = mcpServers[serverKey];
 
-    const credsFile = path.join(projectDir, '.aiflow', 'credentials.json');
     let existingCreds = {};
-    if (await fs.pathExists(credsFile)) {
-        existingCreds = await fs.readJson(credsFile).catch(() => ({}));
+    if (await fs.pathExists(GLOBAL_CREDENTIALS_PATH)) {
+        const globalData = await fs.readJson(GLOBAL_CREDENTIALS_PATH).catch(() => ({}));
+        existingCreds = globalData.mcp || {};
     }
 
     console.log(chalk.cyan(`\nSetup MCP adapter for ${adapter}:`));
@@ -328,8 +397,13 @@ async function setupAdapter(projectDir, adapter) {
         { spaces: 2 }
     );
 
-    Object.assign(existingCreds, credentials);
-    await fs.writeJson(credsFile, existingCreds, { spaces: 2 });
+    await fs.ensureDir(GLOBAL_AIFLOW_DIR);
+    let globalData = {};
+    if (await fs.pathExists(GLOBAL_CREDENTIALS_PATH)) {
+        globalData = await fs.readJson(GLOBAL_CREDENTIALS_PATH).catch(() => ({}));
+    }
+    globalData.mcp = { ...(globalData.mcp || {}), ...credentials };
+    await fs.writeJson(GLOBAL_CREDENTIALS_PATH, globalData, { spaces: 2 });
     await ensureCredentialsGitignored(projectDir);
 
     console.log(chalk.green(`✓ MCP configuration saved (global + local + credentials).`));
@@ -435,7 +509,7 @@ function verifyFigma(credentials) {
 
 async function ensureCredentialsGitignored(projectDir) {
     const gitignorePath = path.join(projectDir, '.gitignore');
-    const entries = ['.aiflow/credentials.json', '.aiflow/no-telemetry'];
+    const entries = ['.aiflow/no-telemetry'];
     let content = '';
     if (await fs.pathExists(gitignorePath)) {
         content = await fs.readFile(gitignorePath, 'utf-8');
@@ -465,13 +539,41 @@ function maskSecret(value) {
 async function init(options) {
     const projectDir = process.cwd();
     const aiflowDir  = path.join(projectDir, '.aiflow');
-    const frameworks = options.frameworks || (options.framework ? [options.framework] : []);
-    const adapters   = options.adapters   || (options.adapter   ? [options.adapter]   : []);
-    const primaryFramework = frameworks[0] || null;
-    const versionDir = path.join(aiflowDir, 'versions', PKG_VERSION);
+    let frameworks = options.frameworks || (options.framework ? [options.framework] : []);
+    const adapters = options.adapters   || (options.adapter   ? [options.adapter]   : []);
 
     try {
         console.log(chalk.blue(`Initializing ai-flow-kit (v${PKG_VERSION})...`));
+
+        // ── Auto-detect or prompt for framework if not supplied ──────
+        if (frameworks.length === 0) {
+            const detected = await detectFramework(projectDir);
+            if (detected) {
+                const label = FRAMEWORK_CHOICES.find(c => c.value === detected)?.name || detected;
+                console.log(chalk.cyan(`\n  Detected framework: ${chalk.bold(label)}`));
+                const useDetected = await confirm({ message: `Use "${label}"?`, default: true });
+                if (useDetected) {
+                    frameworks = [detected];
+                } else {
+                    const chosen = await select({
+                        message: 'Select framework:',
+                        choices: FRAMEWORK_CHOICES,
+                    });
+                    if (chosen) frameworks = [chosen];
+                }
+            } else {
+                console.log(chalk.gray('\n  No framework detected.'));
+                const chosen = await select({
+                    message: 'Select framework (or skip):',
+                    choices: FRAMEWORK_CHOICES,
+                });
+                if (chosen) frameworks = [chosen];
+            }
+        }
+
+        const primaryFramework = frameworks[0] || null;
+        const versionDir = path.join(aiflowDir, 'versions', PKG_VERSION);
+
         if (frameworks.length) console.log(chalk.gray(`  Frameworks: ${frameworks.join(', ')}`));
         if (adapters.length)   console.log(chalk.gray(`  Adapters:   ${adapters.join(', ')}`));
 
@@ -479,8 +581,6 @@ async function init(options) {
         await copyAssetsToVersion(versionDir, primaryFramework);
         await verifySuperpowersSkills(versionDir);
         await updateSymlinks(projectDir, versionDir);
-        
-        // --- Added: Copy docs to project ---
         await copyDocsToProject(projectDir);
 
         const selectedTools = options.aiTools || Object.keys(AI_TOOL_FILES);
@@ -503,11 +603,18 @@ async function init(options) {
         console.log(chalk.green('\n✨ Initialized AI Flow Kit successfully!'));
         console.log(chalk.blue('\n' + '─'.repeat(62)));
         console.log(chalk.bold.white('  Next steps:'));
-        console.log(`  ${chalk.green('aiflow use PROJ-33')}    ${chalk.gray('← load ticket context')}`);
-        console.log(`  ${chalk.green('claude')}                ${chalk.gray('← Use Claude Code CLI (recommended)')}`);
-        console.log(`  ${chalk.green('Cursor / Gemini')}       ${chalk.gray('← Instructions loaded in .cursorrules / GEMINI.md')}`);
+
+        if (adapters.length > 0) {
+            console.log(`  ${chalk.green('aiflow use PROJ-33')}    ${chalk.gray('← load ticket from ' + adapters.join('/'))} `);
+        } else {
+            console.log(`  ${chalk.green('aiflow use --manual')}   ${chalk.gray('← input ticket content in terminal')}`);
+            console.log(`  ${chalk.green('aiflow use --file req.md')} ${chalk.gray('← load from local file')}`);
+        }
+
+        console.log(`  ${chalk.green('claude')}                ${chalk.gray('← Claude Code CLI (recommended)')}`);
+        console.log(`  ${chalk.green('Cursor / Gemini')}       ${chalk.gray('← Instructions in .cursorrules / GEMINI.md')}`);
         console.log(chalk.blue('─'.repeat(62)));
-        console.log(chalk.gray(`  Full guide: ${chalk.green('aiflow guide')} | Command list: ${chalk.green('aiflow guide --commands')}`));
+        console.log(chalk.gray(`  Full guide: ${chalk.green('aiflow guide')} | Commands: ${chalk.green('aiflow guide --commands')}`));
         console.log(chalk.blue('─'.repeat(62)) + '\n');
     } catch (err) {
         console.error(chalk.red(`Error during initialization: ${err.message}`));