symfonia-ai-tools 1.0.0

package/lib/installer.mjs

@@ -0,0 +1,495 @@
+import { readdir, readFile, writeFile, mkdir, access, stat } from 'node:fs/promises';
+import { join, resolve, relative } from 'node:path';
+import { execSync } from 'node:child_process';
+import {
+  section, success, error, warn, info, file, fileSkip, fileMirror,
+  step, bold, boldGreen, boldCyan, boldYellow, cyan, green, yellow, red,
+  dim, gray, box,
+} from './ui.mjs';
+
+const DETECT_FILES = ['.ai/guidelines.md', 'CLAUDE.md', '.github/copilot-instructions.md'];
+
+const TOOL_DIR_MAP = {
+  '_claude': 'toolClaude',
+  '_github': 'toolCopilot',
+  '_cursor': 'toolCursor',
+  '_gemini': 'toolGemini',
+  '_junie': 'toolJunie',
+};
+
+const TOOL_FILE_MAP = {
+  'CLAUDE.md': 'toolClaude',
+};
+
+// ─── Pack loading ───
+
+export async function loadPacks(packsDir) {
+  const packs = {};
+  let entries;
+  try {
+    entries = await readdir(packsDir, { withFileTypes: true });
+  } catch {
+    return packs;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const packDir = join(packsDir, entry.name);
+    try {
+      const raw = await readFile(join(packDir, 'pack.json'), 'utf-8');
+      const pack = JSON.parse(raw);
+      pack._dir = packDir;
+      pack._id = entry.name;
+
+      // Count instructions and skills
+      pack._instrCount = await countFiles(join(packDir, '_ai', 'instructions'));
+      pack._skillCount = await countDirs(join(packDir, '_ai', 'skills'));
+
+      packs[entry.name] = pack;
+    } catch { /* skip dirs without pack.json */ }
+  }
+  return packs;
+}
+
+export async function loadBaseSkills(skillsDir) {
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    return entries
+      .filter(e => e.isDirectory() && e.name !== 'README.md')
+      .map(e => e.name)
+      .sort();
+  } catch { return []; }
+}
+
+export async function loadPackSkills(selectedPacks, allPacks) {
+  const skills = [];
+  for (const packId of (selectedPacks || [])) {
+    const pack = allPacks[packId];
+    if (!pack) continue;
+    const skillsDir = join(pack._dir, '_ai', 'skills');
+    try {
+      const entries = await readdir(skillsDir, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.isDirectory()) {
+          skills.push({ skill: e.name, packId, packName: pack.name });
+        }
+      }
+    } catch { /* no skills */ }
+  }
+  return skills;
+}
+
+async function countFiles(dir) {
+  try {
+    const entries = await readdir(dir);
+    return entries.filter(e => e.endsWith('.md')).length;
+  } catch { return 0; }
+}
+
+async function countDirs(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.filter(e => e.isDirectory()).length;
+  } catch { return 0; }
+}
+
+// ─── Detection ───
+
+export async function detectExisting(targetDir) {
+  const dir = resolve(targetDir);
+  const found = [];
+  for (const f of DETECT_FILES) {
+    try {
+      await access(join(dir, f));
+      found.push(f);
+    } catch { /* not found */ }
+  }
+  return found;
+}
+
+// ─── Install ───
+
+export async function install(packageRoot, answers) {
+  const targetDir = resolve(answers.targetDir);
+  const templatesDir = join(packageRoot, 'templates');
+  const mode = answers.installMode || 'fresh';
+
+  const modeLabel = mode === 'fresh' ? boldGreen('nowy projekt')
+    : mode === 'overwrite' ? boldYellow('nadpisz wszystko')
+    : mode === 'skip-existing' ? boldCyan('tylko nowe pliki')
+    : boldCyan('tylko MCP');
+
+  section('Instalacja');
+  console.log(info(`Katalog: ${bold(targetDir)}`));
+  console.log(info(`Tryb: ${modeLabel}`));
+  console.log('');
+
+  const selectedPacks = answers.packs || [];
+  const totalSteps = mode === 'mcp-only' ? 2 : 5 + selectedPacks.length;
+  let currentStep = 0;
+
+  if (mode !== 'mcp-only') {
+    // 1. Copy base templates
+    step(++currentStep, totalSteps, 'Szablony bazowe');
+    const baseDir = join(templatesDir, 'base');
+    await copyTemplateDir(baseDir, targetDir, answers, mode);
+
+    // 2. Copy selected packs
+    const allPacks = await loadPacks(join(templatesDir, 'packs'));
+    for (const packId of selectedPacks) {
+      const pack = allPacks[packId];
+      if (!pack) continue;
+      step(++currentStep, totalSteps, `Pakiet ${cyan(pack.name)}`);
+      await copyTemplateDir(pack._dir, targetDir, answers, mode);
+    }
+
+    // 3. Assemble guidelines from header + pack sections
+    step(++currentStep, totalSteps, `Skladanie ${cyan('guidelines.md')}`);
+    await assembleGuidelines(templatesDir, targetDir, answers, selectedPacks, allPacks, mode);
+
+    // 4. Mirror .ai/ → .github/
+    if (answers.toolCopilot) {
+      step(++currentStep, totalSteps, `Mirror ${cyan('.ai/')} → ${cyan('.github/')}`);
+      await mirrorAiToGithub(targetDir, 'instructions', mode);
+      await mirrorAiToGithub(targetDir, 'prompts', mode);
+      await mirrorAiToGithub(targetDir, 'skills', mode);
+    } else {
+      ++currentStep;
+    }
+  }
+
+  // 5. MCP
+  step(++currentStep, totalSteps, 'Konfiguracja MCP');
+  await generateMcpConfig(targetDir, answers);
+
+  // 6. CLI
+  step(++currentStep, totalSteps, 'Instalacja CLI');
+  await installCliTools(answers);
+
+  printNextSteps(answers, mode);
+
+  if (mode !== 'mcp-only' && answers.toolClaude) {
+    await bootstrapGsd(targetDir, answers);
+  }
+}
+
+// ─── Guidelines assembly ───
+
+async function assembleGuidelines(templatesDir, targetDir, answers, selectedPacks, allPacks, mode) {
+  const headerPath = join(templatesDir, 'base', '_ai', '_guidelines_header.md');
+  let content;
+  try {
+    content = await readFile(headerPath, 'utf-8');
+  } catch {
+    content = `# ${answers.projectName} - Guidelines\n`;
+  }
+
+  // Append guidelines sections from selected packs
+  for (const packId of selectedPacks) {
+    const pack = allPacks[packId];
+    if (!pack) continue;
+    const sectionPath = join(pack._dir, '_guidelines.md');
+    try {
+      const section = await readFile(sectionPath, 'utf-8');
+      content += '\n' + section;
+    } catch { /* pack has no guidelines section */ }
+  }
+
+  content = replacePlaceholders(content, answers);
+
+  const destPath = join(targetDir, '.ai', 'guidelines.md');
+  if (mode === 'skip-existing') {
+    try {
+      await access(destPath);
+      console.log(fileSkip('.ai/guidelines.md'));
+      return;
+    } catch { /* proceed */ }
+  }
+
+  await mkdir(join(targetDir, '.ai'), { recursive: true });
+  await writeFile(destPath, content, 'utf-8');
+  console.log(file('.ai/guidelines.md'));
+}
+
+// ─── Template copying ───
+
+async function copyTemplateDir(srcDir, destDir, answers, mode) {
+  let entries;
+  try {
+    entries = await readdir(srcDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+
+    // Skip pack metadata and guidelines sections
+    if (entry.name === 'pack.json' || entry.name === '_guidelines.md') continue;
+    // Skip the guidelines header (assembled separately)
+    if (entry.name === '_guidelines_header.md') continue;
+
+    const destName = entry.name.startsWith('_') && !entry.name.startsWith('__')
+      ? '.' + entry.name.slice(1)
+      : entry.name;
+    const destPath = join(destDir, destName);
+
+    if (entry.isDirectory()) {
+      const requiredTool = TOOL_DIR_MAP[entry.name];
+      if (requiredTool && !answers[requiredTool]) continue;
+
+      // Filter skills by selection
+      const isInsideSkillsDir = srcDir.endsWith('/skills') || srcDir.endsWith('\\skills');
+      if (isInsideSkillsDir && answers.selectedSkills && !answers.selectedSkills.includes(entry.name)) continue;
+
+      await mkdir(destPath, { recursive: true });
+      await copyTemplateDir(srcPath, destPath, answers, mode);
+    } else if (entry.isFile()) {
+      const requiredTool = TOOL_FILE_MAP[entry.name];
+      if (requiredTool && !answers[requiredTool]) continue;
+
+      // Skip old guidelines files (we assemble guidelines separately)
+      if (entry.name === 'guidelines.md' && srcPath.includes('_ai')) continue;
+
+      const rel = relative(resolve(answers.targetDir), destPath);
+
+      if (mode === 'skip-existing') {
+        try {
+          await access(destPath);
+          console.log(fileSkip(rel));
+          continue;
+        } catch { /* proceed */ }
+      }
+
+      let content = await readFile(srcPath, 'utf-8');
+      content = replacePlaceholders(content, answers);
+      await mkdir(join(destPath, '..'), { recursive: true });
+      await writeFile(destPath, content, 'utf-8');
+      console.log(file(rel));
+    }
+  }
+}
+
+// ─── Mirror ───
+
+async function mirrorDir(srcDir, destDir, targetDir, mode) {
+  let entries;
+  try {
+    entries = await readdir(srcDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    const destPath = join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await mkdir(destPath, { recursive: true });
+      await mirrorDir(srcPath, destPath, targetDir, mode);
+    } else if (entry.isFile()) {
+      const rel = relative(targetDir, destPath);
+      if (mode === 'skip-existing') {
+        try {
+          await access(destPath);
+          console.log(fileSkip(rel));
+          continue;
+        } catch { /* proceed */ }
+      }
+      const content = await readFile(srcPath, 'utf-8');
+      await mkdir(join(destPath, '..'), { recursive: true });
+      await writeFile(destPath, content, 'utf-8');
+      console.log(fileMirror(rel));
+    }
+  }
+}
+
+async function mirrorAiToGithub(targetDir, subdir, mode) {
+  await mirrorDir(
+    join(targetDir, '.ai', subdir),
+    join(targetDir, '.github', subdir),
+    targetDir,
+    mode,
+  );
+}
+
+// ─── Placeholders ───
+
+function replacePlaceholders(content, a) {
+  return content
+    .replace(/\{\{PROJECT_NAME\}\}/g, a.projectName || '')
+    .replace(/\{\{PROJECT_DESCRIPTION\}\}/g, a.projectDescription || '')
+    .replace(/\{\{TECH_STACK\}\}/g, a.techStack || '')
+    .replace(/\{\{CI_COMMAND\}\}/g, a.ciCommand || '')
+    .replace(/\{\{MODULE_PATH\}\}/g, a.modulePath || '')
+    .replace(/\{\{COMPONENT_LIB_PATH\}\}/g, a.componentLibPath || '')
+    .replace(/\{\{COMPONENT_LIB_IMPORT\}\}/g, a.componentLibImport || '')
+    .replace(/\{\{API_BASE_URL\}\}/g, a.apiBaseUrl || '')
+    .replace(/\{\{TEST_COMMAND\}\}/g, a.testCommand || '')
+    .replace(/\{\{BUILD_COMMAND\}\}/g, a.buildCommand || '')
+    .replace(/\{\{LINT_COMMAND\}\}/g, a.lintCommand || '')
+    .replace(/\{\{DOCKER_CONTAINER\}\}/g, a.dockerContainer || '')
+    .replace(/\{\{JIRA_PREFIX\}\}/g, a.jiraPrefix || '')
+    .replace(/\{\{PLAYWRIGHT_DIR\}\}/g, a.playwrightDir || '')
+    .replace(/\{\{BASE_URL\}\}/g, a.baseUrl || '')
+    .replace(/\{\{CURRENT_BRANCH\}\}/g, '$(git branch --show-current)')
+    .replace(/\{\{BASE_BRANCH\}\}/g, 'develop');
+}
+
+// ─── MCP ───
+
+async function generateMcpConfig(targetDir, answers) {
+  const servers = {};
+  if (answers.mcpJira) {
+    servers.jira = { command: 'npx', args: ['mcp-jira-cloud'], env: { JIRA_BASE_URL: answers.jiraUrl, JIRA_EMAIL: answers.jiraEmail, JIRA_API_TOKEN: answers.jiraToken } };
+  }
+  if (answers.mcpBitbucket) {
+    servers.bitbucket = { command: 'npx', args: ['-y', '@aashari/mcp-server-atlassian-bitbucket'], env: { ATLASSIAN_USER_EMAIL: answers.bitbucketEmail, ATLASSIAN_API_TOKEN: answers.bitbucketToken } };
+  }
+  if (answers.mcpFigma) {
+    servers.figma = { command: 'npx', args: ['@anthropic-ai/mcp-server-figma'], env: { FIGMA_ACCESS_TOKEN: answers.figmaToken } };
+  }
+  if (answers.mcpContext7) {
+    servers.context7 = { command: 'npx', args: ['-y', '@upstash/context7-mcp'], env: {} };
+  }
+
+  if (Object.keys(servers).length === 0) {
+    console.log(`  ${dim('Brak serwerow MCP do skonfigurowania')}`);
+    return;
+  }
+
+  if (answers.toolClaude) {
+    const settingsPath = join(targetDir, '.claude', 'settings.local.json');
+    let settings = {};
+    try { settings = JSON.parse(await readFile(settingsPath, 'utf-8')); } catch {}
+    settings.mcpServers = { ...settings.mcpServers, ...servers };
+    await mkdir(join(targetDir, '.claude'), { recursive: true });
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    console.log(file('.claude/settings.local.json'));
+    await registerClaudeMcp(servers, targetDir);
+  }
+
+  if (answers.toolCursor) {
+    const cursorMcpPath = join(targetDir, '.cursor', 'mcp.json');
+    let cursorMcp = {};
+    try { cursorMcp = JSON.parse(await readFile(cursorMcpPath, 'utf-8')); } catch {}
+    cursorMcp.mcpServers = { ...cursorMcp.mcpServers, ...servers };
+    await mkdir(join(targetDir, '.cursor'), { recursive: true });
+    await writeFile(cursorMcpPath, JSON.stringify(cursorMcp, null, 2) + '\n', 'utf-8');
+    console.log(file('.cursor/mcp.json'));
+  }
+}
+
+async function registerClaudeMcp(servers, targetDir) {
+  if (!hasClaudeCli()) {
+    console.log(warn('Claude CLI nie znaleziony — MCP zapisany w pliku'));
+    return;
+  }
+  for (const [name, config] of Object.entries(servers)) {
+    try {
+      try { execSync(`claude mcp remove ${name} -s project`, { stdio: 'pipe', cwd: targetDir }); } catch {}
+      const envFlags = Object.entries(config.env || {}).filter(([, v]) => v).map(([k, v]) => `-e ${k}=${v}`).join(' ');
+      const cmd = `claude mcp add -s project ${envFlags ? envFlags + ' ' : ''}${name} -- ${config.command} ${config.args.join(' ')}`;
+      execSync(cmd, { stdio: 'pipe', cwd: targetDir });
+      console.log(success(`MCP ${bold(name)} zarejestrowany`));
+    } catch {
+      console.log(warn(`MCP ${name} — rejestracja nie powiodla sie`));
+    }
+  }
+}
+
+// ─── CLI install ───
+
+async function installCliTools(answers) {
+  if (!answers.installClaudeCli && !answers.installGsd) {
+    console.log(`  ${dim('Pominieto instalacje CLI')}`);
+    return;
+  }
+  if (answers.installClaudeCli) {
+    try {
+      console.log(info('Instaluje Claude Code CLI...'));
+      execSync('npm install -g @anthropic-ai/claude-code', { stdio: 'pipe' });
+      console.log(success('Claude Code CLI zainstalowany'));
+    } catch {
+      console.log(error('Blad instalacji Claude Code CLI'));
+      console.log(`    ${dim('Sprobuj recznie:')} npm install -g @anthropic-ai/claude-code`);
+    }
+  }
+  if (answers.installGsd) {
+    try {
+      console.log(info('Instaluje GSD (Get Shit Done)...'));
+      execSync('npx get-shit-done-cc@latest --version', { stdio: 'pipe' });
+      console.log(success('GSD zainstalowany'));
+    } catch {
+      console.log(error('Blad instalacji GSD'));
+      console.log(`    ${dim('Sprobuj recznie:')} npx get-shit-done-cc@latest`);
+    }
+  }
+}
+
+// ─── Next steps ───
+
+function printNextSteps(answers, mode) {
+  console.log('');
+  box([
+    mode === 'mcp-only' ? boldGreen('  Konfiguracja MCP zakonczona!') : boldGreen('  Instalacja zakonczona!'),
+  ], boldGreen);
+  console.log('');
+
+  if (mode === 'mcp-only') {
+    if (answers.toolClaude) console.log(info(`Sprawdz MCP: ${cyan('claude mcp list')}`));
+    return;
+  }
+
+  const steps = [];
+  let n = 1;
+  if (!answers.installGsd) {
+    steps.push(`  ${boldCyan(`${n++}.`)} Zainstaluj GSD ${dim('(wymagane)')}\n     ${gray('npx get-shit-done-cc@latest')}`);
+  }
+  steps.push(`  ${boldCyan(`${n++}.`)} Przejrzyj ${cyan('.ai/guidelines.md')} i dostosuj do projektu`);
+  if (answers.toolClaude && (answers.mcpJira || answers.mcpBitbucket || answers.mcpFigma || answers.mcpContext7)) {
+    steps.push(`  ${boldCyan(`${n++}.`)} Sprawdz MCP\n     ${gray('claude mcp list')}`);
+  }
+  if (!answers.toolClaude) {
+    steps.push(`  ${boldCyan(`${n++}.`)} Rozpocznij prace z GSD\n     ${gray('/gsd:new-project')}`);
+  }
+  console.log(`  ${bold('Nastepne kroki:')}\n`);
+  console.log(steps.join('\n\n'));
+  console.log('');
+}
+
+// ─── GSD bootstrap ───
+
+function hasClaudeCli() {
+  try { execSync('which claude', { stdio: 'pipe' }); return true; } catch { return false; }
+}
+
+async function bootstrapGsd(targetDir, answers) {
+  if (!hasClaudeCli()) {
+    console.log(warn('Claude CLI nie znaleziony — uruchom recznie po instalacji:'));
+    if (answers.projectType === 'existing') console.log(`    ${gray('claude /gsd:map-codebase')}`);
+    console.log(`    ${gray('claude /gsd:new-project')}`);
+    console.log('');
+    return;
+  }
+
+  if (answers.projectType === 'existing') {
+    section('GSD: Mapowanie codebase');
+    try {
+      execSync('claude /gsd:map-codebase', { stdio: 'inherit', cwd: targetDir });
+      console.log(success('map-codebase zakonczone'));
+    } catch {
+      console.log(error('map-codebase nie powiodl sie'));
+      console.log(`    ${dim('Sprobuj recznie:')} ${gray('claude /gsd:map-codebase')}`);
+    }
+  }
+
+  section('GSD: Inicjalizacja projektu');
+  try {
+    execSync('claude /gsd:new-project', { stdio: 'inherit', cwd: targetDir });
+    console.log(success('new-project zakonczone'));
+  } catch {
+    console.log(error('new-project nie powiodl sie'));
+    console.log(`    ${dim('Sprobuj recznie:')} ${gray('claude /gsd:new-project')}`);
+  }
+}