@evolve.labs/devflow 0.8.0

package/lib/autopilotConstants.js

@@ -0,0 +1,213 @@
+/**
+ * Shared autopilot constants for CLI usage.
+ * Mirrors web/lib/autopilotConstants.ts for Node.js CLI.
+ */
+
+const VALID_AGENTS = [
+  'strategist', 'architect', 'system-designer', 'builder', 'guardian', 'chronicler',
+];
+
+const AGENT_SKILLS = {
+  strategist: '/agents:strategist',
+  architect: '/agents:architect',
+  'system-designer': '/agents:system-designer',
+  builder: '/agents:builder',
+  guardian: '/agents:guardian',
+  chronicler: '/agents:chronicler',
+};
+
+const AGENT_PROMPTS = {
+  strategist: `Analise a spec e refine os requisitos:
+{spec_content}
+
+1. Identificar requisitos implícitos
+2. Listar acceptance criteria
+3. Dependências e riscos
+4. Estimar complexidade`,
+
+  architect: `Defina a arquitetura com base na spec:
+{spec_content}
+
+Contexto anterior: {previous_output}
+
+1. Arquitetura da solução
+2. Padrões e tecnologias
+3. Componentes necessários
+4. Decisões importantes`,
+
+  'system-designer': `Projete o system design com base na spec:
+{spec_content}
+
+Contexto anterior: {previous_output}
+
+1. Back-of-the-envelope estimation
+2. High-level design
+3. Data model e storage
+4. Scalability e reliability`,
+
+  builder: `Implemente a solução conforme spec e design:
+{spec_content}
+
+Contexto anterior: {previous_output}
+
+1. Criar/modificar arquivos necessários
+2. Implementar lógica principal
+3. Tratamento de erros`,
+
+  guardian: `Revise o código implementado:
+{spec_content}
+
+Implementação: {previous_output}
+
+1. Segurança
+2. Performance
+3. Edge cases
+4. Melhorias necessárias`,
+
+  chronicler: `Documente as mudanças realizadas:
+{spec_content}
+
+Implementação: {previous_output}
+
+1. Resumir o que foi implementado
+2. Arquivos criados/modificados
+3. Atualizar tasks na spec`,
+};
+
+const AGENT_TIMEOUTS = {
+  strategist: 300,
+  architect: 600,
+  'system-designer': 600,
+  builder: 1200,
+  guardian: 600,
+  chronicler: 300,
+};
+
+const DEFAULT_PHASES = [
+  { id: 'strategist', name: 'Planning' },
+  { id: 'architect', name: 'Design' },
+  { id: 'system-designer', name: 'System Design' },
+  { id: 'builder', name: 'Implementation' },
+  { id: 'guardian', name: 'Validation' },
+  { id: 'chronicler', name: 'Documentation' },
+];
+
+const TASK_TRACKING_AGENTS = ['builder', 'guardian', 'chronicler'];
+
+/**
+ * Load the full agent definition from .claude/commands/agents/{agent}.md
+ * Returns the file content or null if not found.
+ */
+function loadAgentDefinitionSync(projectPath, agent) {
+  const path = require('node:path');
+  const fs = require('node:fs');
+  const filePath = path.join(projectPath, '.claude', 'commands', 'agents', `${agent}.md`);
+  try {
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build the full prompt for a given agent phase.
+ * If agentDefinition is provided, uses it as context instead of the slash command.
+ */
+function buildPrompt(agent, specContent, previousOutputs, agentDefinition) {
+  const prompt = AGENT_PROMPTS[agent]
+    .replace('{spec_content}', specContent)
+    .replace('{previous_output}', (previousOutputs || []).join('\n---\n') || 'N/A');
+
+  // Use full agent definition if available, otherwise fallback to skill command
+  const agentContext = agentDefinition || AGENT_SKILLS[agent];
+
+  return `${agentContext}\n\n---\n\n${prompt}`;
+}
+
+/**
+ * Extract unchecked task titles from markdown content.
+ */
+function extractUncheckedTasks(content) {
+  const tasks = [];
+  const regex = /^\s*[-*]\s*\[ \]\s*(?:\[[^\]]+\]\s*)?(.+)$/gm;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    tasks.push(match[1].trim());
+  }
+  return tasks;
+}
+
+/**
+ * Check if the agent output mentions a task as completed.
+ */
+function isTaskMentionedAsCompleted(taskTitle, output) {
+  const lower = output.toLowerCase();
+  const taskLower = taskTitle.toLowerCase();
+
+  if (!lower.includes(taskLower)) return false;
+
+  if (taskLower.length < 10) {
+    const completionKeywords = [
+      'completed', 'done', 'implemented', 'finished', 'created',
+      'added', 'fixed', 'resolved', 'built', 'configured',
+      '✅', '✓', '[x]', 'complete',
+    ];
+    const idx = lower.indexOf(taskLower);
+    const context = lower.slice(Math.max(0, idx - 200), idx + taskLower.length + 200);
+    return completionKeywords.some(kw => context.includes(kw));
+  }
+
+  return true;
+}
+
+/**
+ * Auto-detect completed tasks and update the spec file.
+ */
+async function autoUpdateSpecTasks(specFilePath, agentOutput) {
+  const fs = require('node:fs').promises;
+  const completedTasks = [];
+
+  try {
+    const content = await fs.readFile(specFilePath, 'utf-8');
+    const uncheckedTasks = extractUncheckedTasks(content);
+
+    if (uncheckedTasks.length === 0) return [];
+
+    let updatedContent = content;
+    for (const taskTitle of uncheckedTasks) {
+      if (isTaskMentionedAsCompleted(taskTitle, agentOutput)) {
+        const escapedTitle = taskTitle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const taskRegex = new RegExp(
+          `^(\\s*[-*]\\s*)\\[ \\](\\s*(?:\\[[^\\]]+\\]\\s*)?)${escapedTitle}`,
+          'gm'
+        );
+        updatedContent = updatedContent.replace(taskRegex, (match, prefix, middle) => {
+          completedTasks.push(taskTitle);
+          return `${prefix}[x]${middle}${taskTitle}`;
+        });
+      }
+    }
+
+    if (completedTasks.length > 0) {
+      await fs.writeFile(specFilePath, updatedContent, 'utf-8');
+    }
+  } catch (error) {
+    console.error('Error auto-updating spec tasks:', error.message);
+  }
+
+  return completedTasks;
+}
+
+module.exports = {
+  VALID_AGENTS,
+  AGENT_SKILLS,
+  AGENT_PROMPTS,
+  AGENT_TIMEOUTS,
+  DEFAULT_PHASES,
+  TASK_TRACKING_AGENTS,
+  loadAgentDefinitionSync,
+  buildPrompt,
+  extractUncheckedTasks,
+  isTaskMentionedAsCompleted,
+  autoUpdateSpecTasks,
+};

package/lib/constants.js

@@ -0,0 +1,95 @@
+const path = require('node:path');
+
+const VERSION = '0.8.0';
+
+// Root of the installed npm package (where source files live)
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+// Directories to create in all install modes
+const BASE_DIRS = [
+  '.claude/commands',
+  '.devflow/agents',
+  '.devflow/memory',
+  '.devflow/sessions',
+  'docs/snapshots',
+  'docs/system-design/sdd',
+  'docs/system-design/rfc',
+  'docs/system-design/capacity',
+  'docs/system-design/trade-offs',
+];
+
+// Additional directories for default/full modes
+const DOCS_DIRS = [
+  'docs/planning/stories',
+  'docs/architecture/diagrams',
+  'docs/decisions',
+  'docs/security',
+  'docs/performance',
+  'docs/api',
+  'docs/migration',
+];
+
+// Directories that should have .gitkeep files
+const GITKEEP_DIRS = [
+  'docs/planning',
+  'docs/planning/stories',
+  'docs/architecture',
+  'docs/architecture/diagrams',
+  'docs/decisions',
+  'docs/security',
+  'docs/performance',
+  'docs/api',
+  'docs/migration',
+  'docs/snapshots',
+  'docs/system-design/sdd',
+  'docs/system-design/rfc',
+  'docs/system-design/capacity',
+  'docs/system-design/trade-offs',
+  '.devflow/sessions',
+];
+
+// Files and directories to copy during init
+const AGENTS_COPY = [
+  { src: '.claude/commands/agents',          dest: '.claude/commands/agents',          type: 'dir' },
+  { src: '.claude/commands/quick',           dest: '.claude/commands/quick',           type: 'dir' },
+  { src: '.claude/commands/devflow-help.md', dest: '.claude/commands/devflow-help.md', type: 'file' },
+  { src: '.claude/commands/devflow-status.md', dest: '.claude/commands/devflow-status.md', type: 'file' },
+  { src: '.claude_project',                  dest: '.claude_project',                  type: 'file' },
+  { src: '.devflow/project.yaml',            dest: '.devflow/project.yaml',            type: 'file' },
+  { src: '.devflow/agents',                  dest: '.devflow/agents',                  type: 'dir' },
+];
+
+// Doc files to copy in default/full modes
+const DOC_FILES = [
+  'docs/decisions/000-template.md',
+];
+
+// Web IDE source directories to copy (excludes node_modules, .next, etc.)
+const WEB_COPY_DIRS = [
+  'web/app',
+  'web/components',
+  'web/hooks',
+  'web/lib',
+];
+
+const WEB_COPY_FILES = [
+  'web/package.json',
+  'web/next.config.js',
+  'web/tsconfig.json',
+  'web/tailwind.config.ts',
+  'web/postcss.config.js',
+  'web/README.md',
+  'web/CHANGELOG.md',
+];
+
+module.exports = {
+  VERSION,
+  PACKAGE_ROOT,
+  BASE_DIRS,
+  DOCS_DIRS,
+  GITKEEP_DIRS,
+  AGENTS_COPY,
+  DOC_FILES,
+  WEB_COPY_DIRS,
+  WEB_COPY_FILES,
+};

package/lib/init.js

@@ -0,0 +1,200 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  VERSION,
+  PACKAGE_ROOT,
+  BASE_DIRS,
+  DOCS_DIRS,
+  GITKEEP_DIRS,
+  AGENTS_COPY,
+  DOC_FILES,
+  WEB_COPY_DIRS,
+  WEB_COPY_FILES,
+} = require('./constants');
+const {
+  printHeader,
+  success,
+  error,
+  warn,
+  info,
+  printSuccess,
+  confirm,
+  checkDependencies,
+  copyDir,
+  copyFile,
+  ensureDirs,
+  createGitkeep,
+  pathExists,
+  resolveTarget,
+} = require('./utils');
+
+async function initCommand(targetArg, options) {
+  printHeader(VERSION);
+
+  const targetDir = resolveTarget(targetArg);
+
+  // 1. Check dependencies
+  if (!options.skipDeps) {
+    checkDependencies();
+  }
+
+  // 2. Validate/create target directory
+  if (!(await pathExists(targetDir))) {
+    info(`Directory does not exist: ${targetDir}`);
+    const shouldCreate = options.force || await confirm('Create this directory?');
+    if (!shouldCreate) {
+      error('Installation cancelled.');
+      process.exit(1);
+    }
+    await fs.promises.mkdir(targetDir, { recursive: true });
+    success(`Directory created: ${targetDir}`);
+  }
+
+  info(`Installing DevFlow in: ${targetDir}`);
+  console.log();
+
+  // 3. Check for existing installation
+  if (await pathExists(path.join(targetDir, '.devflow'))) {
+    warn('.devflow/ already exists in target directory!');
+    if (!options.force) {
+      const shouldOverwrite = await confirm('Overwrite existing installation?');
+      if (!shouldOverwrite) {
+        error('Installation cancelled.');
+        process.exit(1);
+      }
+    }
+    console.log();
+  }
+
+  // 4. Determine install mode
+  let mode = 'default';
+  if (options.agentsOnly) mode = 'agents-only';
+  if (options.full) mode = 'full';
+
+  const modeLabels = {
+    'agents-only': 'Agents only (minimal)',
+    'default': 'Agents + documentation structure',
+    'full': 'Full installation',
+  };
+  info(`Install mode: ${modeLabels[mode]}`);
+  console.log();
+
+  // 5. Create base directory structure
+  await ensureDirs(targetDir, BASE_DIRS);
+
+  // 6. Copy agent files and core config
+  for (const item of AGENTS_COPY) {
+    const src = path.join(PACKAGE_ROOT, item.src);
+    const dest = path.join(targetDir, item.dest);
+    try {
+      if (item.type === 'dir') {
+        await copyDir(src, dest);
+      } else {
+        await copyFile(src, dest);
+      }
+    } catch (err) {
+      warn(`Could not copy ${item.src}: ${err.message}`);
+    }
+  }
+
+  success('Agents installed (.claude/commands/agents/)');
+  success('Quick commands installed (.claude/commands/quick/)');
+  success('.claude_project orchestration rules installed');
+  success('.devflow/ structure created');
+
+  // 7. Default/full: create docs structure with gitkeep files
+  if (mode === 'default' || mode === 'full') {
+    await ensureDirs(targetDir, DOCS_DIRS);
+    await createGitkeep(targetDir, GITKEEP_DIRS);
+
+    // Copy doc template files
+    for (const file of DOC_FILES) {
+      const src = path.join(PACKAGE_ROOT, file);
+      const dest = path.join(targetDir, file);
+      try {
+        if (!(await pathExists(dest))) {
+          await copyFile(src, dest);
+        }
+      } catch { /* skip if source missing */ }
+    }
+
+    success('Documentation structure created (docs/)');
+  }
+
+  // 8. Full: copy .gitignore
+  if (mode === 'full') {
+    const gitignoreSrc = path.join(PACKAGE_ROOT, '.gitignore-template');
+    const gitignoreDest = path.join(targetDir, '.gitignore');
+
+    if (await pathExists(gitignoreSrc)) {
+      if (await pathExists(gitignoreDest)) {
+        warn('.gitignore already exists - appending DevFlow entries');
+        const existing = await fs.promises.readFile(gitignoreDest, 'utf8');
+        if (!existing.includes('# DevFlow')) {
+          const devflowIgnore = await fs.promises.readFile(gitignoreSrc, 'utf8');
+          await fs.promises.appendFile(
+            gitignoreDest,
+            `\n\n# --- DevFlow entries ---\n${devflowIgnore}`
+          );
+        }
+        success('.gitignore updated with DevFlow entries');
+      } else {
+        await copyFile(gitignoreSrc, gitignoreDest);
+        success('.gitignore created');
+      }
+    }
+  }
+
+  // 9. Optional: copy Web IDE
+  if (options.web) {
+    info('Installing Web IDE source files...');
+
+    // Copy web directories
+    for (const dir of WEB_COPY_DIRS) {
+      const src = path.join(PACKAGE_ROOT, dir);
+      const dest = path.join(targetDir, dir);
+      try {
+        await copyDir(src, dest);
+      } catch (err) {
+        warn(`Could not copy ${dir}: ${err.message}`);
+      }
+    }
+
+    // Copy web files
+    for (const file of WEB_COPY_FILES) {
+      const src = path.join(PACKAGE_ROOT, file);
+      const dest = path.join(targetDir, file);
+      try {
+        await copyFile(src, dest);
+      } catch { /* skip if source missing */ }
+    }
+
+    success('Web IDE source files installed (web/)');
+  }
+
+  // 10. Success output
+  printSuccess(VERSION);
+  info('Next steps:');
+  console.log();
+  console.log('1. Open the project in Claude Code:');
+  console.log(`   cd ${targetDir}`);
+  console.log('   claude');
+  console.log();
+  console.log('2. In Claude Code, test an agent:');
+  console.log('   /agents:strategist Hello! Introduce yourself');
+  console.log();
+  console.log('3. Create your first feature:');
+  console.log('   /agents:strategist I want to create [your feature]');
+
+  if (options.web) {
+    console.log();
+    console.log('4. Start the Web IDE:');
+    console.log(`   cd ${path.join(targetDir, 'web')}`);
+    console.log('   npm install');
+    console.log('   npm run dev');
+    console.log('   # Open http://localhost:3000');
+  }
+  console.log();
+}
+
+module.exports = { initCommand };

package/lib/update.js

@@ -0,0 +1,181 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  VERSION,
+  PACKAGE_ROOT,
+  BASE_DIRS,
+  DOCS_DIRS,
+  GITKEEP_DIRS,
+} = require('./constants');
+const {
+  printHeader,
+  success,
+  error,
+  warn,
+  info,
+  printUpdateSuccess,
+  confirm,
+  copyDir,
+  copyFile,
+  ensureDirs,
+  createGitkeep,
+  pathExists,
+  resolveTarget,
+} = require('./utils');
+
+async function updateCommand(targetArg, options) {
+  printHeader(VERSION);
+
+  const targetDir = resolveTarget(targetArg);
+
+  // 1. Verify DevFlow is installed
+  const hasAgents = await pathExists(path.join(targetDir, '.claude', 'commands', 'agents'));
+  const hasDevflow = await pathExists(path.join(targetDir, '.devflow'));
+
+  if (!hasAgents && !hasDevflow) {
+    error(`DevFlow not found in: ${targetDir}`);
+    info('Use "devflow init" to install for the first time.');
+    process.exit(1);
+  }
+
+  // 2. Read installed version
+  let installedVersion = 'unknown';
+  const projectYamlPath = path.join(targetDir, '.devflow', 'project.yaml');
+  try {
+    const content = await fs.promises.readFile(projectYamlPath, 'utf8');
+    const match = content.match(/^\s*version:\s*"?([^"\s]+)"?/m);
+    if (match) installedVersion = match[1];
+  } catch { /* file may not exist */ }
+
+  info(`Project: ${targetDir}`);
+  info(`Installed version: ${installedVersion}`);
+  info(`New version: ${VERSION}`);
+  console.log();
+
+  // 3. Check if already up to date
+  if (installedVersion === VERSION) {
+    success('DevFlow is already up to date!');
+    return;
+  }
+
+  // 4. Confirm update
+  if (!options.force) {
+    warn('The update will overwrite agent files.');
+    warn('Customizations in .claude/commands/agents/ will be lost.');
+    console.log();
+    const shouldContinue = await confirm('Continue with update?');
+    if (!shouldContinue) {
+      warn('Update cancelled.');
+      return;
+    }
+  }
+
+  console.log();
+  info('Updating DevFlow...');
+  console.log();
+
+  // 5. Backup existing agents
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const backupDir = path.join(targetDir, '.devflow', `backup-${timestamp}`);
+  await fs.promises.mkdir(backupDir, { recursive: true });
+
+  try {
+    await fs.promises.cp(
+      path.join(targetDir, '.claude', 'commands', 'agents'),
+      path.join(backupDir, 'agents'),
+      { recursive: true }
+    );
+  } catch { /* may not exist */ }
+
+  try {
+    await fs.promises.copyFile(
+      projectYamlPath,
+      path.join(backupDir, 'project.yaml')
+    );
+  } catch { /* may not exist */ }
+
+  success(`Backup created: .devflow/${path.basename(backupDir)}/`);
+
+  // 6. Update agents
+  console.log('  \u2192 Updating agents...');
+  await copyDir(
+    path.join(PACKAGE_ROOT, '.claude', 'commands', 'agents'),
+    path.join(targetDir, '.claude', 'commands', 'agents')
+  );
+  success('Agents updated (.claude/commands/agents/)');
+
+  // 7. Update quick commands
+  console.log('  \u2192 Updating quick commands...');
+  await copyDir(
+    path.join(PACKAGE_ROOT, '.claude', 'commands', 'quick'),
+    path.join(targetDir, '.claude', 'commands', 'quick')
+  );
+  success('Quick commands updated');
+
+  // 8. Update help & status commands
+  console.log('  \u2192 Updating help & status commands...');
+  for (const file of ['devflow-help.md', 'devflow-status.md']) {
+    try {
+      await copyFile(
+        path.join(PACKAGE_ROOT, '.claude', 'commands', file),
+        path.join(targetDir, '.claude', 'commands', file)
+      );
+    } catch { /* skip if missing */ }
+  }
+
+  // 9. Update .claude_project
+  console.log('  \u2192 Updating .claude_project...');
+  await copyFile(
+    path.join(PACKAGE_ROOT, '.claude_project'),
+    path.join(targetDir, '.claude_project')
+  );
+  success('.claude_project updated');
+
+  // 10. Update .devflow/agents/ meta.yaml files
+  console.log('  \u2192 Updating .devflow/agents/ meta.yaml files...');
+  await copyDir(
+    path.join(PACKAGE_ROOT, '.devflow', 'agents'),
+    path.join(targetDir, '.devflow', 'agents')
+  );
+  success('.devflow/agents/ updated');
+
+  // 11. Update project.yaml version
+  console.log('  \u2192 Updating project.yaml version...');
+  try {
+    let content = await fs.promises.readFile(projectYamlPath, 'utf8');
+    content = content.replace(
+      /version:\s*"?[^"\s]+"?/,
+      `version: "${VERSION}"`
+    );
+    await fs.promises.writeFile(projectYamlPath, content, 'utf8');
+    success(`project.yaml version updated to ${VERSION}`);
+  } catch {
+    await copyFile(
+      path.join(PACKAGE_ROOT, '.devflow', 'project.yaml'),
+      projectYamlPath
+    );
+    success('project.yaml created');
+  }
+
+  // 12. Ensure directory structure is complete
+  console.log('  \u2192 Verifying directory structure...');
+  await ensureDirs(targetDir, [...BASE_DIRS, ...DOCS_DIRS]);
+  await createGitkeep(targetDir, GITKEEP_DIRS);
+  success('Directory structure verified');
+
+  // 13. Success output
+  printUpdateSuccess(VERSION);
+  info('What was updated:');
+  console.log('  \u2022 Agents in .claude/commands/agents/');
+  console.log('  \u2022 Quick commands in .claude/commands/quick/');
+  console.log('  \u2022 .claude_project orchestration rules');
+  console.log('  \u2022 .devflow/agents/ meta.yaml files');
+  console.log('  \u2022 Directory structure');
+  console.log();
+  info(`Backup saved in: .devflow/${path.basename(backupDir)}/`);
+  console.log();
+  info('Tip: Use /agents:strategist to start a new feature');
+  console.log();
+}
+
+module.exports = { updateCommand };