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

package/scripts/init.js

@@ -2,7 +2,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const os = require('os');
 const chalk = require('chalk');
-const { input, select, confirm } = require('@inquirer/prompts');
+const { input, checkbox, confirm } = require('@inquirer/prompts');
 
 const PKG_DIR = path.join(__dirname, '..');
 const GLOBAL_AIFLOW_DIR = path.join(os.homedir(), '.aiflow');
@@ -23,7 +23,7 @@ const AI_TOOL_FILES = {
     'cursor':   '.cursorrules',
     'gemini':   'GEMINI.md',
     'copilot':  '.github/copilot-instructions.md',
-    'generic':  '.aiflow/AI_INSTRUCTIONS.md'
+    'generic':  '.aiflow/docs/AI_INSTRUCTIONS.md',
 };
 
 /**
@@ -79,15 +79,14 @@ async function detectFramework(projectDir) {
 }
 
 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 },
+    { 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' },
 ];
 
 async function copyAssetsToVersion(versionDir, framework) {
@@ -279,32 +278,20 @@ async function setupFramework(projectDir, framework, multi = false, selectedTool
         const fileExists = await fs.pathExists(targetPath);
 
         if (!multi) {
+            const relPath = path.relative(projectDir, targetPath).replace(/\\/g, '/');
             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)}`));
+                // File already exists — save aiflow template to .aiflow/reference/ for comparison.
+                // Developer owns the file in root; we never overwrite without explicit action.
+                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, '/');
+                console.log(chalk.gray(`  ✓ ${relPath} exists — aiflow template saved to ${refRel}`));
+                skipped.push(relPath);
+            } else {
+                await fs.writeFile(targetPath, finalContent);
+                written.push(AI_TOOL_FILES[tool]);
             }
-            await fs.writeFile(targetPath, finalContent);
-            written.push(AI_TOOL_FILES[tool]);
         } else {
             if (fileExists) {
                 await fs.appendFile(targetPath, separator + frameworkContent);
@@ -536,6 +523,74 @@ function maskSecret(value) {
     return `${value.slice(0, 4)}***${value.slice(-4)}`;
 }
 
+// ── RTK (token compression) helpers ──────────────────────────────
+
+async function detectRtk() {
+    const { execSync } = require('child_process');
+    try {
+        const out = execSync('rtk --version', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+        return { installed: true, version: out.replace(/^rtk\s*/i, '') };
+    } catch (_) {
+        return { installed: false };
+    }
+}
+
+async function isRtkHookConfigured(projectDir) {
+    const settingsPath = path.join(projectDir, '.claude', 'settings.json');
+    if (!(await fs.pathExists(settingsPath))) return false;
+    const settings = await fs.readJson(settingsPath).catch(() => ({}));
+    const preHooks = settings?.hooks?.PreToolUse || [];
+    return preHooks.some(h =>
+        (h.hooks || []).some(entry =>
+            typeof entry.command === 'string' && entry.command.includes('rtk')
+        )
+    );
+}
+
+async function setupRtkHook(projectDir) {
+    const settingsPath = path.join(projectDir, '.claude', 'settings.json');
+    let settings = {};
+    if (await fs.pathExists(settingsPath)) {
+        settings = await fs.readJson(settingsPath).catch(() => ({}));
+    }
+    if (!settings.hooks) settings.hooks = {};
+    if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
+
+    const alreadySet = settings.hooks.PreToolUse.some(h =>
+        (h.hooks || []).some(e => typeof e.command === 'string' && e.command.includes('rtk'))
+    );
+    if (alreadySet) return;
+
+    settings.hooks.PreToolUse.push({
+        matcher: 'Bash',
+        hooks: [{ type: 'command', command: 'rtk rewrite' }],
+    });
+    await fs.ensureDir(path.join(projectDir, '.claude'));
+    await fs.writeJson(settingsPath, settings, { spaces: 2 });
+    console.log(chalk.green('✓ RTK token compression hook configured (.claude/settings.json)'));
+}
+
+async function maybeSetupRtk(projectDir, forceSetup) {
+    const rtk = await detectRtk();
+    if (!rtk.installed && !forceSetup) return;
+
+    if (forceSetup && !rtk.installed) {
+        console.log(chalk.yellow('⚠ --with-rtk specified but rtk binary not found. Install: cargo install rtk'));
+        return;
+    }
+
+    if (await isRtkHookConfigured(projectDir)) {
+        console.log(chalk.gray('  RTK hook already configured — skipping.'));
+        return;
+    }
+
+    const enable = forceSetup || await confirm({
+        message: `RTK detected (${rtk.version}). Enable token compression for Claude Code?`,
+        default: true,
+    });
+    if (enable) await setupRtkHook(projectDir);
+}
+
 async function init(options) {
     const projectDir = process.cwd();
     const aiflowDir  = path.join(projectDir, '.aiflow');
@@ -548,27 +603,23 @@ async function init(options) {
         // ── Auto-detect or prompt for framework if not supplied ──────
         if (frameworks.length === 0) {
             const detected = await detectFramework(projectDir);
+            const hint = chalk.gray('  Space to select/unselect · Enter to confirm · Leave empty to skip');
             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];
-                }
+                console.log(hint);
             } 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];
+                console.log(hint);
             }
+            const chosen = await checkbox({
+                message: 'Select framework(s):',
+                choices: FRAMEWORK_CHOICES.map(c => ({
+                    ...c,
+                    checked: c.value === detected,
+                })),
+            });
+            frameworks = chosen;
         }
 
         const primaryFramework = frameworks[0] || null;
@@ -600,6 +651,12 @@ async function init(options) {
             await fs.writeJson(stateFile, state);
         }
 
+        // ── Optional: RTK token compression ─────────────────────────
+        // Commander sets options.rtk=false when --no-rtk is passed
+        if (options.rtk !== false) {
+            await maybeSetupRtk(projectDir, options.withRtk || false);
+        }
+
         console.log(chalk.green('\n✨ Initialized AI Flow Kit successfully!'));
         console.log(chalk.blue('\n' + '─'.repeat(62)));
         console.log(chalk.bold.white('  Next steps:'));
@@ -623,3 +680,5 @@ async function init(options) {
 
 module.exports = init;
 module.exports.AI_TOOL_FILES = AI_TOOL_FILES;
+module.exports.detectRtk = detectRtk;
+module.exports.isRtkHookConfigured = isRtkHookConfigured;