adi_dev_workflow 1.2.0 → 1.3.1

package/src/installer.js

@@ -6,64 +6,176 @@ import { transformContent } from './transformer.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const FRAMEWORKS_DIR = join(__dirname, '..', 'frameworks');
 
-const FRAMEWORK_MAP = {
-  sdd: {
-    commands: 'sdd',
-    skills: ['sdd-prd-expert', 'sdd-spec-tech-expert', 'sdd-task-plan-expert', 'sdd-qa-expert'],
-  },
-  ministack: {
-    commands: 'ministack',
-    skills: ['ministack-intent-expert', 'ministack-scope-expert', 'ministack-expert', 'ministack-qa-expert'],
-  },
-  taskcard: {
-    commands: 'taskcard',
-    skills: ['taskcard-expert', 'taskcard-qa-expert'],
-  },
-  shared: {
-    commands: null, // root-level commands
-    skills: [],
-  },
-};
-
 const IDE_DIRS = {
   claude: '.claude',
   cursor: '.cursor',
 };
 
-/**
- * Copy a directory recursively, applying transformation.
- */
+// Prefixos usados para rotear skills e commands ao framework correto.
+// Qualquer skill sem prefixo conhecido vai para 'shared'.
+const FRAMEWORK_PREFIXES = {
+  sdd: 'sdd',
+  ministack: 'ministack',
+  taskcard: 'taskcard',
+};
+
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listDirs(dir) {
+  if (!(await exists(dir))) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}
+
+async function listFiles(dir) {
+  if (!(await exists(dir))) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile()).map((e) => e.name);
+}
+
+function skillFramework(skillName) {
+  for (const [fw, prefix] of Object.entries(FRAMEWORK_PREFIXES)) {
+    if (skillName === prefix || skillName.startsWith(prefix + '-')) return fw;
+  }
+  return 'shared';
+}
+
+async function copyFile(src, dest, target) {
+  await mkdir(dirname(dest), { recursive: true });
+  if (src.endsWith('.md')) {
+    const content = await readFile(src, 'utf-8');
+    const transformed = transformContent(content, target);
+    await writeFile(dest, transformed, 'utf-8');
+  } else {
+    const content = await readFile(src);
+    await writeFile(dest, content);
+  }
+}
+
 async function copyDir(src, dest, target) {
   await mkdir(dest, { recursive: true });
   const entries = await readdir(src, { withFileTypes: true });
-
   for (const entry of entries) {
     const srcPath = join(src, entry.name);
     const destPath = join(dest, entry.name);
-
     if (entry.isDirectory()) {
       await copyDir(srcPath, destPath, target);
-    } else if (entry.name.endsWith('.md')) {
-      const content = await readFile(srcPath, 'utf-8');
-      const transformed = transformContent(content, target);
-      await writeFile(destPath, transformed, 'utf-8');
     } else {
-      const content = await readFile(srcPath);
-      await writeFile(destPath, content);
+      await copyFile(srcPath, destPath, target);
     }
   }
 }
 
+async function countMarkdownRecursive(dir) {
+  let count = 0;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) count += await countMarkdownRecursive(full);
+    else if (entry.name.endsWith('.md')) count++;
+  }
+  return count;
+}
+
 /**
- * Check if a path exists.
+ * Constroi o plano de instalacao varrendo frameworks/ e mapeando cada item
+ * (skill, command, agent, template, config) para seu destino no IDE.
+ * Cada item e marcado com `overwrite: true` se o destino ja existir.
  */
-async function exists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
+async function buildPlan({ cwd, target, frameworks }) {
+  const ideDir = join(cwd, IDE_DIRS[target]);
+  const selected = new Set(frameworks);
+  const items = [];
+
+  // Skills: detectadas automaticamente por prefixo
+  const skillNames = await listDirs(join(FRAMEWORKS_DIR, 'skills'));
+  for (const name of skillNames) {
+    const fw = skillFramework(name);
+    if (!selected.has(fw)) continue;
+    items.push({
+      category: 'skills',
+      kind: 'dir',
+      src: join(FRAMEWORKS_DIR, 'skills', name),
+      dest: join(ideDir, 'skills', name),
+      label: `skills/${name}`,
+    });
+  }
+
+  // Commands: subdir por framework + arquivos root-level para 'shared'
+  const commandDirs = await listDirs(join(FRAMEWORKS_DIR, 'commands'));
+  for (const name of commandDirs) {
+    if (!FRAMEWORK_PREFIXES[name] || !selected.has(name)) continue;
+    items.push({
+      category: 'commands',
+      kind: 'dir',
+      src: join(FRAMEWORKS_DIR, 'commands', name),
+      dest: join(ideDir, 'commands', name),
+      label: `commands/${name}/`,
+    });
+  }
+  if (selected.has('shared')) {
+    const rootCmds = await listFiles(join(FRAMEWORKS_DIR, 'commands'));
+    for (const name of rootCmds) {
+      if (!name.endsWith('.md')) continue;
+      items.push({
+        category: 'commands',
+        kind: 'file',
+        src: join(FRAMEWORKS_DIR, 'commands', name),
+        dest: join(ideDir, 'commands', name),
+        label: `commands/${name}`,
+      });
+    }
+  }
+
+  // Agents, templates, config: pertencem a 'shared'
+  if (selected.has('shared')) {
+    for (const name of await listFiles(join(FRAMEWORKS_DIR, 'agents'))) {
+      if (!name.endsWith('.md')) continue;
+      items.push({
+        category: 'agents',
+        kind: 'file',
+        src: join(FRAMEWORKS_DIR, 'agents', name),
+        dest: join(ideDir, 'agents', name),
+        label: `agents/${name}`,
+      });
+    }
+    for (const name of await listFiles(join(FRAMEWORKS_DIR, 'templates'))) {
+      if (!name.endsWith('.md')) continue;
+      items.push({
+        category: 'templates',
+        kind: 'file',
+        src: join(FRAMEWORKS_DIR, 'templates', name),
+        dest: join(ideDir, 'templates', name),
+        label: `templates/${name}`,
+      });
+    }
+    for (const name of await listFiles(join(FRAMEWORKS_DIR, 'config'))) {
+      items.push({
+        category: 'config',
+        kind: 'file',
+        src: join(FRAMEWORKS_DIR, 'config', name),
+        dest: join(ideDir, 'config', name),
+        label: `config/${name}`,
+      });
+    }
+  }
+
+  for (const item of items) {
+    item.overwrite = await exists(item.dest);
   }
+
+  return { ideDir, items };
+}
+
+export async function planInstall(options) {
+  return buildPlan(options);
 }
 
 /**
@@ -73,81 +185,48 @@ async function exists(path) {
  * @param {string} options.cwd - Current working directory
  * @param {'claude'|'cursor'} options.target - Target IDE
  * @param {string[]} options.frameworks - Frameworks to install ('sdd', 'ministack', 'taskcard', 'shared')
- * @returns {Object} Summary of installed items
+ * @param {(labels: string[]) => Promise<boolean>} [options.confirmOverwrite] - Called when items will be overwritten
+ * @returns {Object} Summary of installed items (or { cancelled: true })
  */
-export async function install({ cwd, target, frameworks }) {
-  const ideDir = join(cwd, IDE_DIRS[target]);
-  const commandsDir = join(ideDir, 'commands');
-  const skillsDir = join(ideDir, 'skills');
-  const templatesDir = join(ideDir, 'templates');
-  const agentsDir = join(ideDir, 'agents');
-
-  const summary = { commands: 0, skills: 0, templates: 0, agents: 0, config: 0 };
-
-  for (const fw of frameworks) {
-    const config = FRAMEWORK_MAP[fw];
-    if (!config) continue;
-
-    // Copy commands
-    if (fw === 'shared') {
-      // Root-level commands (generate-prompt.md, sync-tasks-to-linear.md)
-      await mkdir(commandsDir, { recursive: true });
-      const srcCmds = join(FRAMEWORKS_DIR, 'commands');
-      const entries = await readdir(srcCmds, { withFileTypes: true });
-
-      for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith('.md')) {
-          const content = await readFile(join(srcCmds, entry.name), 'utf-8');
-          const transformed = transformContent(content, target);
-          await writeFile(join(commandsDir, entry.name), transformed, 'utf-8');
-          summary.commands++;
-        }
-      }
+export async function install({ cwd, target, frameworks, confirmOverwrite }) {
+  const plan = await buildPlan({ cwd, target, frameworks });
+  const overwrites = plan.items.filter((i) => i.overwrite);
 
-      // Shared templates
-      const srcTemplates = join(FRAMEWORKS_DIR, 'templates');
-      if (await exists(srcTemplates)) {
-        await copyDir(srcTemplates, templatesDir, target);
-        const tplEntries = await readdir(srcTemplates);
-        summary.templates += tplEntries.filter((f) => f.endsWith('.md')).length;
-      }
-
-      // Shared agents
-      const srcAgents = join(FRAMEWORKS_DIR, 'agents');
-      if (await exists(srcAgents)) {
-        await copyDir(srcAgents, agentsDir, target);
-        const agentEntries = await readdir(srcAgents);
-        summary.agents += agentEntries.filter((f) => f.endsWith('.md')).length;
-      }
+  if (overwrites.length > 0 && typeof confirmOverwrite === 'function') {
+    const ok = await confirmOverwrite(overwrites.map((i) => i.label));
+    if (!ok) return { cancelled: true };
+  }
 
-      // Config file
-      const srcConfig = join(FRAMEWORKS_DIR, 'config', 'ai-framework-config.yaml');
-      if (await exists(srcConfig)) {
-        const configDestDir = join(ideDir, 'config');
-        await mkdir(configDestDir, { recursive: true });
-        const content = await readFile(srcConfig);
-        await writeFile(join(configDestDir, 'ai-framework-config.yaml'), content);
-        summary.config = 1;
-      }
+  const summary = {
+    skills: 0,
+    commands: 0,
+    templates: 0,
+    agents: 0,
+    config: 0,
+    overwritten: overwrites.length,
+  };
+
+  for (const item of plan.items) {
+    if (item.kind === 'dir') {
+      await copyDir(item.src, item.dest, target);
     } else {
-      // Framework-specific commands
-      if (config.commands) {
-        const srcCmdDir = join(FRAMEWORKS_DIR, 'commands', config.commands);
-        const destCmdDir = join(commandsDir, config.commands);
-        await copyDir(srcCmdDir, destCmdDir, target);
-        const entries = await readdir(srcCmdDir);
-        summary.commands += entries.filter((f) => f.endsWith('.md')).length;
-      }
+      await copyFile(item.src, item.dest, target);
+    }
 
-      // Framework-specific skills
-      for (const skillName of config.skills) {
-        const srcSkillDir = join(FRAMEWORKS_DIR, 'skills', skillName);
-        const destSkillDir = join(skillsDir, skillName);
-        if (await exists(srcSkillDir)) {
-          await copyDir(srcSkillDir, destSkillDir, target);
-          summary.skills++;
-        }
+    if (item.category === 'skills') {
+      summary.skills++;
+    } else if (item.category === 'commands') {
+      if (item.kind === 'dir') {
+        summary.commands += await countMarkdownRecursive(item.src);
+      } else {
+        summary.commands++;
       }
+    } else if (item.category === 'agents') {
+      summary.agents++;
+    } else if (item.category === 'templates') {
+      summary.templates++;
+    } else if (item.category === 'config') {
+      summary.config++;
     }
   }