adi_dev_workflow 1.0.0

package/src/installer.js

@@ -0,0 +1,136 @@
+import { readdir, readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+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.
+ */
+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);
+    }
+  }
+}
+
+/**
+ * Check if a path exists.
+ */
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Install selected frameworks to the target directory.
+ *
+ * @param {Object} options
+ * @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
+ */
+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 summary = { commands: 0, skills: 0, templates: 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++;
+        }
+      }
+
+      // 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;
+      }
+    } 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;
+      }
+
+      // 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++;
+        }
+      }
+    }
+  }
+
+  return summary;
+}

package/src/transformer.js

@@ -0,0 +1,86 @@
+const REPLACEMENTS = [
+  // Remove Claude Code specific tool instructions
+  {
+    pattern: /- \*\*Claude Code\*\*: use a ferramenta `AskUserQuestion`[^\n]*/g,
+    replacement: '',
+  },
+  {
+    pattern: /\*\*Claude Code\*\*: use a ferramenta `AskUserQuestion`[^\n]*/g,
+    replacement: '',
+  },
+  // Replace AskUserQuestion references with generic
+  {
+    pattern: /`AskUserQuestion`/g,
+    replacement: 'perguntas interativas ao usuario',
+  },
+  {
+    pattern: /AskUserQuestion/g,
+    replacement: 'pergunte ao usuario',
+  },
+  // Replace directory references
+  {
+    pattern: /\.claude\/rules\//g,
+    replacement: '.cursor/rules/',
+  },
+  {
+    pattern: /\.claude\/templates\//g,
+    replacement: '.cursor/templates/',
+  },
+  {
+    pattern: /\.claude\/skills\//g,
+    replacement: '.cursor/skills/',
+  },
+  {
+    pattern: /\.claude\/commands\//g,
+    replacement: '.cursor/commands/',
+  },
+  // Replace .claude/agents/ references
+  {
+    pattern: /\.claude\/agents\//g,
+    replacement: '.cursor/agents/',
+  },
+  // Replace all remaining .claude/ references
+  {
+    pattern: /`\.claude\//g,
+    replacement: '`.cursor/',
+  },
+  // Replace tool/IDE name references
+  {
+    pattern: /no Claude Code/g,
+    replacement: 'no Cursor',
+  },
+  {
+    pattern: /do Claude Code/g,
+    replacement: 'do Cursor',
+  },
+  {
+    pattern: /Claude Code Review Agent/g,
+    replacement: 'Code Review Agent',
+  },
+  {
+    pattern: /\(Claude Code\)/g,
+    replacement: '(Cursor)',
+  },
+  {
+    pattern: /Claude Code/g,
+    replacement: 'Cursor',
+  },
+];
+
+/**
+ * Transform file content from Claude Code format to Cursor format.
+ * Returns unchanged content if target is 'claude'.
+ */
+export function transformContent(content, target) {
+  if (target === 'claude') return content;
+
+  let result = content;
+  for (const { pattern, replacement } of REPLACEMENTS) {
+    result = result.replace(pattern, replacement);
+  }
+
+  // Clean up empty lines left by removed lines
+  result = result.replace(/\n{3,}/g, '\n\n');
+
+  return result;
+}