tsic-ainode 1.0.0 → 1.2.0

package/bin/index.js

@@ -6,11 +6,11 @@
 
 'use strict';
 
-const fs   = require('fs');
-const path = require('path');
-const os   = require('os');
+const fs    = require('fs');
+const path  = require('path');
+const os    = require('os');
 const { execSync } = require('child_process');
-const readline = require('readline');
+const clack = require('@clack/prompts');
 
 // ---------------------------------------------------------------------------
 // Paths
@@ -19,7 +19,6 @@ const PKG_ROOT    = path.join(__dirname, '..');
 const LOCALES_DIR = path.join(PKG_ROOT, 'locales');
 const TMPL_DIR    = path.join(PKG_ROOT, 'templates');
 const HOME        = os.homedir();
-const CWD         = process.cwd();
 const IS_WIN      = process.platform === 'win32';
 
 // ---------------------------------------------------------------------------
@@ -27,7 +26,7 @@ const IS_WIN      = process.platform === 'win32';
 // ---------------------------------------------------------------------------
 let T = {};
 function loadLocale(lang) {
-  const file = path.join(LOCALES_DIR, `${lang}.json`);
+  const file     = path.join(LOCALES_DIR, `${lang}.json`);
   const fallback = path.join(LOCALES_DIR, 'en.json');
   try {
     T = JSON.parse(fs.readFileSync(fs.existsSync(file) ? file : fallback, 'utf8'));
@@ -40,9 +39,6 @@ function t(key, fallback = key) {
   return T[key] || fallback;
 }
 
-// ---------------------------------------------------------------------------
-// Detect OS locale
-// ---------------------------------------------------------------------------
 function detectLocale() {
   const env = process.env.LANG || process.env.LC_ALL || process.env.LANGUAGE || '';
   if (env.toLowerCase().includes('zh')) return 'zh-TW';
@@ -50,52 +46,51 @@ function detectLocale() {
 }
 
 // ---------------------------------------------------------------------------
-// Tool definitions
+// Tool detection
 // ---------------------------------------------------------------------------
+function cmdExists(cmd) {
+  try {
+    execSync(IS_WIN ? `where ${cmd}` : `which ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 const TOOLS = [
   {
-    id:       'claude',
-    nameKey:  'tool_claude',
-    detect:   () => fs.existsSync(path.join(HOME, '.claude')),
-    install:  installClaude,
+    id:      'claude',
+    nameKey: 'tool_claude',
+    detect:  () => fs.existsSync(path.join(HOME, '.claude')),
+    install: installClaude,
   },
   {
-    id:       'cursor',
-    nameKey:  'tool_cursor',
-    detect:   () => fs.existsSync(path.join(HOME, '.cursor')) ||
-                    fs.existsSync(path.join(CWD, '.cursor')),
-    install:  installCursor,
+    id:      'cursor',
+    nameKey: 'tool_cursor',
+    detect:  () => cmdExists('cursor') ||
+                   fs.existsSync(path.join(HOME, '.cursor')),
+    install: installCursor,
   },
   {
-    id:       'codex',
-    nameKey:  'tool_codex',
-    detect:   () => cmdExists('codex') || fs.existsSync(path.join(HOME, '.codex')),
-    install:  installCodex,
+    id:      'codex',
+    nameKey: 'tool_codex',
+    detect:  () => cmdExists('codex'),
+    install: installCodex,
   },
   {
-    id:       'gemini',
-    nameKey:  'tool_gemini',
-    detect:   () => cmdExists('gemini') || fs.existsSync(path.join(HOME, '.gemini')),
-    install:  installGemini,
+    id:      'gemini',
+    nameKey: 'tool_gemini',
+    detect:  () => cmdExists('gemini') || cmdExists('gemini-cli'),
+    install: installGemini,
   },
   {
-    id:       'antigravity',
-    nameKey:  'tool_antigravity',
-    detect:   () => cmdExists('antigravity') ||
-                    fs.existsSync(path.join(HOME, '.antigravity')),
-    install:  installAntigravity,
+    id:      'antigravity',
+    nameKey: 'tool_antigravity',
+    detect:  () => cmdExists('antigravity'),
+    install: installAntigravity,
   },
 ];
 
-function cmdExists(cmd) {
-  try {
-    execSync(IS_WIN ? `where ${cmd}` : `which ${cmd}`, { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Install functions
 // ---------------------------------------------------------------------------
@@ -105,11 +100,11 @@ function copyTemplate(src, dest) {
 }
 
 function appendToFile(src, dest) {
-  const tag    = '<!-- tsic-ainode -->';
+  const tag     = '<!-- tsic-ainode -->';
   const content = fs.readFileSync(src, 'utf8');
   if (fs.existsSync(dest)) {
     const existing = fs.readFileSync(dest, 'utf8');
-    if (existing.includes(tag)) return; // already installed
+    if (existing.includes(tag)) return;
     fs.appendFileSync(dest, `\n\n${tag}\n${content}`);
   } else {
     fs.mkdirSync(path.dirname(dest), { recursive: true });
@@ -117,180 +112,144 @@ function appendToFile(src, dest) {
   }
 }
 
-function installClaude(scope) {
+function installClaude(scope, projectPath) {
   const dest = path.join(HOME, '.claude', 'skills', 'tsic-ainode', 'SKILL.md');
   copyTemplate(path.join(TMPL_DIR, 'claude-code', 'SKILL.md'), dest);
   return dest;
 }
 
-function installCursor(scope) {
+function installCursor(scope, projectPath) {
   const rulesDir = scope === 'global'
     ? path.join(HOME, '.cursor', 'rules')
-    : path.join(CWD, '.cursor', 'rules');
+    : path.join(projectPath, '.cursor', 'rules');
   const dest = path.join(rulesDir, 'tsic-ainode.mdc');
   copyTemplate(path.join(TMPL_DIR, 'cursor', 'tsic-ainode.mdc'), dest);
   return dest;
 }
 
-function installCodex(scope) {
+function installCodex(scope, projectPath) {
   const dest = scope === 'global'
     ? path.join(HOME, '.codex', 'AGENTS.md')
-    : path.join(CWD, 'AGENTS.md');
+    : path.join(projectPath, 'AGENTS.md');
   appendToFile(path.join(TMPL_DIR, 'codex', 'AGENTS.md'), dest);
   return dest;
 }
 
-function installGemini(scope) {
+function installGemini(scope, projectPath) {
   const dest = scope === 'global'
     ? path.join(HOME, '.gemini', 'GEMINI.md')
-    : path.join(CWD, 'GEMINI.md');
+    : path.join(projectPath, 'GEMINI.md');
   appendToFile(path.join(TMPL_DIR, 'gemini-cli', 'GEMINI.md'), dest);
   return dest;
 }
 
-function installAntigravity(scope) {
+function installAntigravity(scope, projectPath) {
   const dest = scope === 'global'
     ? path.join(HOME, '.antigravity', 'AGENTS.md')
-    : path.join(CWD, '.antigravity', 'AGENTS.md');
+    : path.join(projectPath, '.antigravity', 'AGENTS.md');
   appendToFile(path.join(TMPL_DIR, 'antigravity', 'AGENTS.md'), dest);
   return dest;
 }
 
-// ---------------------------------------------------------------------------
-// Readline helpers
-// ---------------------------------------------------------------------------
-function createRL() {
-  return readline.createInterface({ input: process.stdin, output: process.stdout });
-}
-
-function ask(rl, question) {
-  return new Promise(resolve => rl.question(question, resolve));
-}
-
-function askChoice(rl, question, choices) {
-  return new Promise(resolve => {
-    const opts = choices.map((c, i) => `  ${i + 1}. ${c}`).join('\n');
-    rl.question(`${question}\n${opts}\n> `, ans => {
-      const idx = parseInt(ans.trim(), 10) - 1;
-      resolve(choices[Math.max(0, Math.min(idx, choices.length - 1))]);
-    });
-  });
-}
-
-async function askCheckbox(rl, question, items) {
-  console.log(`\n${question}`);
-  const selected = new Set(items.filter(i => i.detected).map(i => i.id));
-  items.forEach((item, i) => {
-    const check = selected.has(item.id) ? '◉' : '○';
-    const hint  = item.detected ? ' (detected)' : '';
-    console.log(`  ${i + 1}. ${check} ${item.label}${hint}`);
-  });
-  console.log('  (Enter numbers to toggle, e.g. "1 3", or Enter to confirm)');
-
-  while (true) {
-    const ans = await ask(rl, '> ');
-    if (ans.trim() === '') break;
-    ans.trim().split(/\s+/).forEach(n => {
-      const idx = parseInt(n, 10) - 1;
-      if (idx >= 0 && idx < items.length) {
-        const id = items[idx].id;
-        selected.has(id) ? selected.delete(id) : selected.add(id);
-      }
-    });
-    // redraw
-    items.forEach((item, i) => {
-      const check = selected.has(item.id) ? '◉' : '○';
-      process.stdout.write(`  ${i + 1}. ${check} ${item.label}\n`);
-    });
-    console.log('  (Enter to confirm, or toggle more)');
-  }
-  return items.filter(i => selected.has(i.id));
-}
-
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
 async function main() {
-  // Load default locale first
-  let locale = detectLocale();
-  loadLocale(locale);
-
-  const rl = createRL();
-
-  // Banner
-  console.log('\n' + '─'.repeat(50));
-  console.log(` ${t('welcome')}`);
-  console.log(` ${t('welcome_sub')}`);
-  console.log('─'.repeat(50));
-
-  // Language selection
-  const langChoice = await askChoice(rl, `\n${t('lang_prompt')}`, [
-    '繁體中文 (zh-TW)',
-    'English (en)',
-  ]);
-  locale = langChoice.startsWith('繁') ? 'zh-TW' : 'en';
-  loadLocale(locale);
+  // Load default locale
+  loadLocale(detectLocale());
+
+  clack.intro(` ${t('welcome')} `);
+
+  // Language
+  const langVal = await clack.select({
+    message: t('lang_prompt', 'Language'),
+    options: [
+      { value: 'zh-TW', label: '繁體中文' },
+      { value: 'en',    label: 'English'  },
+    ],
+  });
+  if (clack.isCancel(langVal)) { clack.cancel('Cancelled.'); process.exit(0); }
+  loadLocale(langVal);
 
   // Detect tools
-  const detectedIds = TOOLS.filter(t => t.detect()).map(t => t.id);
-  if (detectedIds.length > 0) {
-    console.log(`\n${T.detect_title}`);
-    detectedIds.forEach(id => {
-      const tool = TOOLS.find(t => t.id === id);
-      console.log(`  ✓ ${T[tool.nameKey] || tool.id}`);
-    });
-  } else {
-    console.log(`\n${T.detect_none}`);
-  }
-
-  // Choose tools
-  const toolItems = TOOLS.map(tool => ({
-    id:       tool.id,
-    label:    T[tool.nameKey] || tool.id,
-    detected: detectedIds.includes(tool.id),
-    install:  tool.install,
-  }));
-  const chosen = await askCheckbox(rl, T.tools_prompt, toolItems);
+  const detectedIds = TOOLS.filter(tool => tool.detect()).map(tool => tool.id);
+
+  // Tool selection — arrow keys + space to toggle, Enter to confirm
+  const selectedIds = await clack.multiselect({
+    message: T.tools_prompt || 'Select tools to install',
+    options: TOOLS.map(tool => ({
+      value: tool.id,
+      label: T[tool.nameKey] || tool.id,
+      hint:  detectedIds.includes(tool.id)
+               ? (langVal === 'zh-TW' ? '已偵測' : 'detected')
+               : undefined,
+    })),
+    initialValues: detectedIds,
+    required: false,
+  });
 
-  if (chosen.length === 0) {
-    console.log('\nNo tools selected. Exiting.');
-    rl.close();
-    return;
+  if (clack.isCancel(selectedIds) || selectedIds.length === 0) {
+    clack.cancel(langVal === 'zh-TW' ? '未選擇任何工具。' : 'No tools selected.');
+    process.exit(0);
   }
 
   // Scope
-  const scopeChoice = await askChoice(rl, `\n${T.scope_prompt}`, [
-    T.scope_global,
-    T.scope_project,
-  ]);
-  const scope = scopeChoice === T.scope_global ? 'global' : 'project';
+  const scope = await clack.select({
+    message: T.scope_prompt || 'Installation scope',
+    options: [
+      { value: 'global',  label: T.scope_global  || 'Global'  },
+      { value: 'project', label: T.scope_project || 'Project' },
+    ],
+  });
+  if (clack.isCancel(scope)) { clack.cancel('Cancelled.'); process.exit(0); }
+
+  // Project path (only when scope = project)
+  let projectPath = process.cwd();
+  if (scope === 'project') {
+    const inputPath = await clack.text({
+      message:      T.project_path_prompt || 'Target project directory',
+      placeholder:  process.cwd(),
+      defaultValue: process.cwd(),
+      validate(v) {
+        const p = (v || '').trim() || process.cwd();
+        if (!fs.existsSync(p)) return `Directory does not exist: ${p}`;
+      },
+    });
+    if (clack.isCancel(inputPath)) { clack.cancel('Cancelled.'); process.exit(0); }
+    if (inputPath && inputPath.trim()) projectPath = inputPath.trim();
+  }
 
   // Install
-  console.log(`\n${T.installing}`);
+  const spinner = clack.spinner();
+  spinner.start(T.installing || 'Installing...');
+
   const results = [];
-  for (const tool of chosen) {
+  for (const toolId of selectedIds) {
+    const tool = TOOLS.find(tool => tool.id === toolId);
     try {
-      const dest = tool.install(scope);
-      console.log(`  ${T.installed_ok}: ${tool.label}`);
-      console.log(`    → ${dest}`);
-      results.push({ tool, dest, ok: true });
+      const dest = tool.install(scope, projectPath);
+      results.push({ label: T[tool.nameKey] || tool.id, dest, ok: true });
     } catch (err) {
-      console.error(`  ✗ ${T.err_write}: ${tool.label} — ${err.message}`);
-      results.push({ tool, ok: false });
+      results.push({ label: T[tool.nameKey] || tool.id, err: err.message, ok: false });
+    }
+  }
+
+  spinner.stop(T.done_title || 'Done!');
+
+  for (const r of results) {
+    if (r.ok) {
+      clack.log.success(`${r.label}\n  → ${r.dest}`);
+    } else {
+      clack.log.error(`${r.label}: ${r.err}`);
     }
   }
 
-  // Done
-  console.log('\n' + '─'.repeat(50));
-  console.log(` ${T.done_title}`);
-  console.log('─'.repeat(50));
-  console.log(`\n${T.done_usage}`);
-  console.log(`  ${T.done_example_zh}`);
-  console.log(`  ${T.done_example_en}`);
-  console.log(`\n${T.done_docs} https://github.com/TSIC-tech/TSIC-AINode`);
-  console.log();
+  clack.note(
+    `${T.done_example_zh || ''}\n${T.done_example_en || ''}`,
+    T.done_usage || 'Usage'
+  );
 
-  rl.close();
+  clack.outro(`${T.done_docs || 'Docs'}: https://github.com/TSIC-tech/TSIC-AINode`);
 }
 
 main().catch(err => {

package/locales/en.json

@@ -7,7 +7,8 @@
   "tools_prompt": "Select tools to install (space to toggle, Enter to confirm):",
   "scope_prompt": "Installation scope:",
   "scope_global": "Global (~/.claude/skills, ~/.cursor/rules, etc.)",
-  "scope_project": "Current project folder (.cursor/rules, AGENTS.md, etc.)",
+  "scope_project": "Specific project folder",
+  "project_path_prompt": "Target project directory (Enter to use current folder)",
   "installing": "Installing...",
   "installed_ok": "✓ Installed",
   "installed_skip": "- Skipped",

package/locales/zh-TW.json

@@ -7,7 +7,8 @@
   "tools_prompt": "選擇要安裝的工具（空白鍵切換，Enter 確認）：",
   "scope_prompt": "安裝範圍：",
   "scope_global": "全域（~/.claude/skills、~/.cursor/rules 等）",
-  "scope_project": "目前專案資料夾（.cursor/rules、AGENTS.md 等）",
+  "scope_project": "指定專案資料夾",
+  "project_path_prompt": "目標專案目錄（直接 Enter 使用目前資料夾）",
   "installing": "安裝中...",
   "installed_ok": "✓ 已安裝",
   "installed_skip": "- 略過",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsic-ainode",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "TSIC AINode Skill installer — adds AINode SSH Dongle support to Claude Code, Cursor, Codex, Gemini CLI, and Antigravity",
   "bin": {
     "tsic-ainode": "bin/index.js"
@@ -20,6 +20,9 @@
     "skill",
     "mcp"
   ],
+  "dependencies": {
+    "@clack/prompts": "^0.9.0"
+  },
   "author": "TSIC",
   "license": "MIT",
   "engines": {