@mthanhlm/autodev 0.1.1 → 0.2.0

package/autodev/bin/autodev-tools.cjs

@@ -4,8 +4,13 @@ const fs = require('fs');
 const path = require('path');
 
 const DEFAULT_CONFIG = {
+  project: {
+    type: null
+  },
   workflow: {
-    research: false
+    research: false,
+    review_after_execute: true,
+    codebase_parallel_agents: 4
   },
   execution: {
     parallel: false
@@ -24,10 +29,26 @@ const DEFAULT_CONFIG = {
   }
 };
 
+const CODEBASE_FILES = ['structure.md', 'domain.md', 'runtime.md', 'quality.md', 'summary.md'];
+
 function autodevDir(cwd) {
   return path.join(cwd, '.autodev');
 }
 
+function rootPaths(cwd) {
+  const root = autodevDir(cwd);
+  return {
+    root,
+    config: path.join(root, 'config.json'),
+    project: path.join(root, 'PROJECT.md'),
+    state: path.join(root, 'STATE.md'),
+    activeTrack: path.join(root, 'ACTIVE_TRACK'),
+    codebaseDir: path.join(root, 'codebase'),
+    codebaseSummary: path.join(root, 'codebase', 'summary.md'),
+    tracksDir: path.join(root, 'tracks')
+  };
+}
+
 function readText(filePath) {
   try {
     return fs.readFileSync(filePath, 'utf8');
@@ -44,98 +65,226 @@ function readJson(filePath, fallback = null) {
   }
 }
 
+function fileExists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
 function slugify(value) {
   return String(value)
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')
     .replace(/^-+|-+$/g, '')
-    .replace(/-+/g, '-') || 'phase';
+    .replace(/-+/g, '-') || 'track';
 }
 
 function padPhase(number) {
   return String(number).padStart(2, '0');
 }
 
+function detectExistingCodebase(cwd) {
+  const knownFiles = [
+    'package.json',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'tsconfig.json',
+    'jsconfig.json',
+    'pyproject.toml',
+    'requirements.txt',
+    'Pipfile',
+    'Cargo.toml',
+    'go.mod',
+    'pom.xml',
+    'build.gradle',
+    'Dockerfile'
+  ];
+  const knownDirs = [
+    'src',
+    'app',
+    'lib',
+    'server',
+    'client',
+    'backend',
+    'frontend',
+    'components',
+    'pages',
+    'api',
+    'tests',
+    '__tests__'
+  ];
+
+  if (knownFiles.some(name => fileExists(path.join(cwd, name)))) {
+    return true;
+  }
+
+  if (knownDirs.some(name => fileExists(path.join(cwd, name)))) {
+    return true;
+  }
+
+  try {
+    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+    return entries.some(entry => {
+      if (entry.name === '.autodev' || entry.name === '.claude' || entry.name.startsWith('.')) {
+        return false;
+      }
+      return entry.isDirectory() || /\.(js|ts|tsx|jsx|py|go|rs|java|rb|php|cs|cpp|c|swift|kt|sql|json|yaml|yml|md)$/.test(entry.name);
+    });
+  } catch {
+    return false;
+  }
+}
+
+function mergeSection(defaultValue, actualValue) {
+  if (defaultValue && typeof defaultValue === 'object' && !Array.isArray(defaultValue)) {
+    return {
+      ...defaultValue,
+      ...((actualValue && typeof actualValue === 'object' && !Array.isArray(actualValue)) ? actualValue : {})
+    };
+  }
+  return actualValue !== undefined ? actualValue : defaultValue;
+}
+
+function loadConfig(cwd) {
+  const config = readJson(rootPaths(cwd).config, {}) || {};
+  return {
+    project: mergeSection(DEFAULT_CONFIG.project, config.project),
+    workflow: mergeSection(DEFAULT_CONFIG.workflow, config.workflow),
+    execution: mergeSection(DEFAULT_CONFIG.execution, config.execution),
+    git: mergeSection(DEFAULT_CONFIG.git, config.git),
+    hooks: mergeSection(DEFAULT_CONFIG.hooks, config.hooks)
+  };
+}
+
+function readActiveTrack(cwd) {
+  const value = readText(rootPaths(cwd).activeTrack);
+  return value ? value.trim() || null : null;
+}
+
+function trackDir(cwd, slug) {
+  return path.join(rootPaths(cwd).tracksDir, slug);
+}
+
+function trackPaths(cwd, slug = readActiveTrack(cwd)) {
+  if (!slug) {
+    return null;
+  }
+
+  const dir = trackDir(cwd, slug);
+  return {
+    slug,
+    dir,
+    track: path.join(dir, 'TRACK.md'),
+    requirements: path.join(dir, 'REQUIREMENTS.md'),
+    roadmap: path.join(dir, 'ROADMAP.md'),
+    state: path.join(dir, 'STATE.md'),
+    phasesDir: path.join(dir, 'phases')
+  };
+}
+
+function listTracks(cwd) {
+  const tracksDir = rootPaths(cwd).tracksDir;
+  if (!fileExists(tracksDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(tracksDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => {
+      const paths = trackPaths(cwd, entry.name);
+      const trackName = (() => {
+        const content = readText(paths.track);
+        const match = content && content.match(/^#\s+Track:\s*(.+)$/m);
+        return match ? match[1].trim() : entry.name;
+      })();
+
+      return {
+        slug: entry.name,
+        name: trackName,
+        paths,
+        active: readActiveTrack(cwd) === entry.name
+      };
+    })
+    .sort((left, right) => left.slug.localeCompare(right.slug));
+}
+
 function parseRoadmap(content) {
   const phases = [];
   if (!content) {
     return phases;
   }
 
-  const matcher = /^##\s+Phase\s+(\d+)\s*:\s*(.+)$/gm;
+  const matcher = /^##\s+Phase\s+(\d+)(?:\s+\[([a-z-]+)\])?\s*:\s*(.+)$/gm;
   let match;
   while ((match = matcher.exec(content)) !== null) {
     phases.push({
       number: Number(match[1]),
-      name: match[2].trim()
+      type: match[2] || 'feature',
+      name: match[3].trim()
     });
   }
   return phases;
 }
 
-function phasePaths(cwd, phase) {
-  const dirName = `${padPhase(phase.number)}-${slugify(phase.name)}`;
-  const dir = path.join(autodevDir(cwd), 'phases', dirName);
+function phasePaths(cwd, slug, phase) {
+  const track = trackPaths(cwd, slug);
+  if (!track) {
+    return null;
+  }
+
   const prefix = padPhase(phase.number);
+  const dirName = `${prefix}-${phase.type}-${slugify(phase.name)}`;
+  const dir = path.join(track.phasesDir, dirName);
   return {
     ...phase,
     padded: prefix,
     dir,
     planPath: path.join(dir, `${prefix}-PLAN.md`),
     summaryPath: path.join(dir, `${prefix}-SUMMARY.md`),
+    reviewPath: path.join(dir, `${prefix}-REVIEW.md`),
     uatPath: path.join(dir, `${prefix}-UAT.md`)
   };
 }
 
-function loadConfig(cwd) {
-  const config = readJson(path.join(autodevDir(cwd), 'config.json'), {});
-  return {
-    workflow: {
-      ...DEFAULT_CONFIG.workflow,
-      ...(config.workflow || {})
-    },
-    execution: {
-      ...DEFAULT_CONFIG.execution,
-      ...(config.execution || {})
-    },
-    git: {
-      ...DEFAULT_CONFIG.git,
-      ...(config.git || {})
-    },
-    hooks: {
-      ...DEFAULT_CONFIG.hooks,
-      ...(config.hooks || {})
-    }
-  };
-}
+function listPhases(cwd, slug = readActiveTrack(cwd)) {
+  const track = trackPaths(cwd, slug);
+  if (!track || !fileExists(track.roadmap)) {
+    return [];
+  }
 
-function listPhases(cwd) {
-  const roadmap = readText(path.join(autodevDir(cwd), 'ROADMAP.md'));
-  return parseRoadmap(roadmap).map(phase => {
-    const details = phasePaths(cwd, phase);
-    const planExists = fs.existsSync(details.planPath);
-    const summaryExists = fs.existsSync(details.summaryPath);
-    const uatExists = fs.existsSync(details.uatPath);
+  return parseRoadmap(readText(track.roadmap)).map(phase => {
+    const details = phasePaths(cwd, slug, phase);
+    const planExists = fileExists(details.planPath);
+    const summaryExists = fileExists(details.summaryPath);
+    const reviewExists = fileExists(details.reviewPath);
+    const uatExists = fileExists(details.uatPath);
     const status = uatExists
       ? 'verified'
-      : summaryExists
-        ? 'executed'
-        : planExists
-          ? 'planned'
-          : 'pending';
+      : reviewExists
+        ? 'reviewed'
+        : summaryExists
+          ? 'executed'
+          : planExists
+            ? 'planned'
+            : 'pending';
 
     return {
       ...details,
+      trackSlug: slug,
       planExists,
       summaryExists,
+      reviewExists,
       uatExists,
       status
     };
   });
 }
 
-function resolvePhase(cwd, requestedPhase, mode) {
-  const phases = listPhases(cwd);
+function resolvePhase(cwd, slug, requestedPhase, mode) {
+  const phases = listPhases(cwd, slug);
   if (phases.length === 0) {
     return null;
   }
@@ -153,93 +302,204 @@ function resolvePhase(cwd, requestedPhase, mode) {
     return phases.find(phase => phase.planExists && !phase.summaryExists) || null;
   }
 
+  if (mode === 'review') {
+    return phases.find(phase => phase.summaryExists && !phase.reviewExists) || null;
+  }
+
   if (mode === 'verify') {
-    return phases.find(phase => phase.summaryExists && !phase.uatExists)
-      || [...phases].reverse().find(phase => phase.summaryExists)
+    return phases.find(phase => phase.reviewExists && !phase.uatExists)
+      || [...phases].reverse().find(phase => phase.reviewExists)
       || null;
   }
 
   return phases[0];
 }
 
-function nextCommand(progress) {
-  if (!progress.initialized) {
-    return '/autodev-new-project';
+function buildRoute(cwd) {
+  const paths = rootPaths(cwd);
+  const config = loadConfig(cwd);
+  const existingCodebase = detectExistingCodebase(cwd);
+  const projectType = config.project.type || (existingCodebase ? 'brownfield' : 'greenfield');
+  const projectExists = fileExists(paths.project);
+  const codebaseMapExists = fileExists(paths.codebaseSummary);
+  const activeTrack = readActiveTrack(cwd);
+  const tracks = listTracks(cwd);
+
+  if (!projectExists) {
+    return {
+      kind: 'init_project',
+      command: '/autodev-new-project',
+      reason: existingCodebase ? 'existing_code_detected_without_project_state' : 'project_state_missing',
+      projectType
+    };
+  }
+
+  if (projectType === 'brownfield' && !codebaseMapExists) {
+    return {
+      kind: 'explore_codebase',
+      command: '/autodev-explore-codebase',
+      reason: 'brownfield_project_needs_codebase_map',
+      projectType
+    };
+  }
+
+  if (!activeTrack) {
+    return {
+      kind: 'track_select',
+      command: '/autodev',
+      reason: tracks.length > 0 ? 'no_active_track_selected' : 'no_tracks_created',
+      projectType
+    };
+  }
+
+  const track = trackPaths(cwd, activeTrack);
+  if (!track || !fileExists(track.track) || !fileExists(track.roadmap) || !fileExists(track.state)) {
+    return {
+      kind: 'track_setup',
+      command: '/autodev',
+      reason: 'active_track_missing_required_artifacts',
+      projectType,
+      trackSlug: activeTrack
+    };
+  }
+
+  const phases = listPhases(cwd, activeTrack);
+  if (phases.length === 0) {
+    return {
+      kind: 'track_setup',
+      command: '/autodev',
+      reason: 'active_track_has_no_phases',
+      projectType,
+      trackSlug: activeTrack
+    };
+  }
+
+  const nextReview = phases.find(phase => phase.summaryExists && !phase.reviewExists);
+  if (nextReview && config.workflow.review_after_execute !== false) {
+    return {
+      kind: 'review_phase',
+      command: `/autodev-review-phase ${nextReview.number}`,
+      reason: 'phase_executed_but_not_reviewed',
+      projectType,
+      trackSlug: activeTrack,
+      phaseNumber: nextReview.number
+    };
   }
 
-  const nextVerify = progress.phases.find(phase => phase.summaryExists && !phase.uatExists);
+  const nextVerify = phases.find(phase => phase.reviewExists && !phase.uatExists);
   if (nextVerify) {
-    return `/autodev-verify-work ${nextVerify.number}`;
+    return {
+      kind: 'verify_phase',
+      command: `/autodev-verify-work ${nextVerify.number}`,
+      reason: 'phase_reviewed_but_not_verified',
+      projectType,
+      trackSlug: activeTrack,
+      phaseNumber: nextVerify.number
+    };
   }
 
-  const nextExecute = progress.phases.find(phase => phase.planExists && !phase.summaryExists);
+  const nextExecute = phases.find(phase => phase.planExists && !phase.summaryExists);
   if (nextExecute) {
-    return `/autodev-execute-phase ${nextExecute.number}`;
+    return {
+      kind: 'execute_phase',
+      command: `/autodev-execute-phase ${nextExecute.number}`,
+      reason: 'phase_planned_but_not_executed',
+      projectType,
+      trackSlug: activeTrack,
+      phaseNumber: nextExecute.number
+    };
   }
 
-  const nextPlan = progress.phases.find(phase => !phase.planExists);
+  const nextPlan = phases.find(phase => !phase.planExists);
   if (nextPlan) {
-    return `/autodev-plan-phase ${nextPlan.number}`;
+    return {
+      kind: 'plan_phase',
+      command: `/autodev-plan-phase ${nextPlan.number}`,
+      reason: 'phase_not_planned',
+      projectType,
+      trackSlug: activeTrack,
+      phaseNumber: nextPlan.number
+    };
   }
 
-  return '/autodev-progress';
+  return {
+    kind: 'track_complete',
+    command: '/autodev-cleanup',
+    reason: 'active_track_fully_verified',
+    projectType,
+    trackSlug: activeTrack
+  };
 }
 
 function buildProgress(cwd) {
-  const root = autodevDir(cwd);
-  const initialized = fs.existsSync(root);
-  if (!initialized) {
-    return {
-      initialized: false,
-      phases: [],
-      counts: {
-        total: 0,
-        planned: 0,
-        executed: 0,
-        verified: 0
-      },
-      nextCommand: '/autodev-new-project'
-    };
-  }
+  const paths = rootPaths(cwd);
+  const initialized = fileExists(paths.project);
+  const existingCodebase = detectExistingCodebase(cwd);
+  const config = loadConfig(cwd);
+  const projectType = config.project.type || (existingCodebase ? 'brownfield' : 'greenfield');
+  const activeTrack = readActiveTrack(cwd);
+  const tracks = listTracks(cwd);
+  const phases = activeTrack ? listPhases(cwd, activeTrack) : [];
+  const codebaseMapExists = fileExists(paths.codebaseSummary);
+  const route = buildRoute(cwd);
 
-  const phases = listPhases(cwd);
   return {
-    initialized: true,
+    initialized,
+    projectType,
+    existingCodebase,
+    codebaseMapExists,
+    activeTrack,
+    tracks,
     phases,
     counts: {
+      trackCount: tracks.length,
       total: phases.length,
       planned: phases.filter(phase => phase.planExists).length,
       executed: phases.filter(phase => phase.summaryExists).length,
+      reviewed: phases.filter(phase => phase.reviewExists).length,
       verified: phases.filter(phase => phase.uatExists).length
     },
-    nextCommand: nextCommand({ initialized: true, phases })
+    route,
+    nextCommand: route.command
   };
 }
 
 function renderProgressTable(progress) {
   if (!progress.initialized) {
-    return 'No .autodev project found.\nNext: /autodev-new-project';
+    return 'No .autodev project found.\nNext: /autodev';
   }
 
   const lines = [
     'Autodev Progress',
     '',
+    `Project Type: ${progress.projectType}`,
+    `Codebase Map: ${progress.codebaseMapExists ? 'ready' : 'missing'}`,
+    `Tracks: ${progress.counts.trackCount}`,
+    `Active Track: ${progress.activeTrack || 'none'}`,
     `Phases: ${progress.counts.total}`,
     `Planned: ${progress.counts.planned}`,
     `Executed: ${progress.counts.executed}`,
+    `Reviewed: ${progress.counts.reviewed}`,
     `Verified: ${progress.counts.verified}`,
-    `Next: ${progress.nextCommand}`,
+    `Next: ${progress.route.command}`,
     '',
-    '| Phase | Name | Plan | Summary | UAT | Status |',
-    '| --- | --- | --- | --- | --- | --- |'
+    '| Phase | Type | Name | Plan | Summary | Review | UAT | Status |',
+    '| --- | --- | --- | --- | --- | --- | --- | --- |'
   ];
 
   for (const phase of progress.phases) {
     lines.push(
-      `| ${phase.number} | ${phase.name} | ${phase.planExists ? 'yes' : 'no'} | ${phase.summaryExists ? 'yes' : 'no'} | ${phase.uatExists ? 'yes' : 'no'} | ${phase.status} |`
+      `| ${phase.number} | ${phase.type} | ${phase.name} | ${phase.planExists ? 'yes' : 'no'} | ${phase.summaryExists ? 'yes' : 'no'} | ${phase.reviewExists ? 'yes' : 'no'} | ${phase.uatExists ? 'yes' : 'no'} | ${phase.status} |`
     );
   }
 
+  if (progress.tracks.length > 0) {
+    lines.push('', '| Track | Active | Name |', '| --- | --- | --- |');
+    for (const track of progress.tracks) {
+      lines.push(`| ${track.slug} | ${track.active ? 'yes' : 'no'} | ${track.name} |`);
+    }
+  }
+
   return lines.join('\n');
 }
 
@@ -249,30 +509,67 @@ function dotGet(object, key) {
   ), object);
 }
 
+function codebasePaths(cwd) {
+  const codebaseDir = rootPaths(cwd).codebaseDir;
+  return Object.fromEntries(CODEBASE_FILES.map(name => [name.replace(/\.md$/, ''), path.join(codebaseDir, name)]));
+}
+
 function initPayload(cwd, mode, requestedPhase) {
-  const root = autodevDir(cwd);
+  const paths = rootPaths(cwd);
   const config = loadConfig(cwd);
-  const phase = mode === 'new-project' ? null : resolvePhase(cwd, requestedPhase, mode);
+  const route = buildRoute(cwd);
+  const existingCodebase = detectExistingCodebase(cwd);
+  const projectType = config.project.type || (existingCodebase ? 'brownfield' : 'greenfield');
+  const activeTrack = readActiveTrack(cwd);
+  const tracks = listTracks(cwd);
+  const track = trackPaths(cwd, activeTrack);
+  const phaseMode = mode === 'review-phase' ? 'review' : mode === 'verify-work' ? 'verify' : mode === 'execute-phase' ? 'execute' : mode === 'plan-phase' ? 'plan' : null;
+  const phase = phaseMode && activeTrack ? resolvePhase(cwd, activeTrack, requestedPhase, phaseMode) : null;
+  const codebase = codebasePaths(cwd);
+
   return {
     cwd,
-    autodev_exists: fs.existsSync(root),
-    config_path: path.join(root, 'config.json'),
-    project_path: path.join(root, 'PROJECT.md'),
-    requirements_path: path.join(root, 'REQUIREMENTS.md'),
-    roadmap_path: path.join(root, 'ROADMAP.md'),
-    state_path: path.join(root, 'STATE.md'),
-    research_enabled: config.workflow.research,
-    git_mode: config.git.mode,
+    autodev_exists: fileExists(paths.root),
+    project_exists: fileExists(paths.project),
+    existing_code_detected: existingCodebase,
+    project_type: projectType,
+    config_path: paths.config,
+    project_path: paths.project,
+    project_state_path: paths.state,
+    active_track_path: paths.activeTrack,
+    active_track: activeTrack,
+    track_count: tracks.length,
+    tracks: tracks.map(trackItem => ({
+      slug: trackItem.slug,
+      name: trackItem.name,
+      active: trackItem.active,
+      path: trackItem.paths.dir
+    })),
+    codebase_dir: paths.codebaseDir,
+    codebase_map_exists: fileExists(paths.codebaseSummary),
+    codebase_paths: codebase,
+    track_path: track ? track.dir : null,
+    track_doc_path: track ? track.track : null,
+    requirements_path: track ? track.requirements : null,
+    roadmap_path: track ? track.roadmap : null,
+    track_state_path: track ? track.state : null,
+    phases_dir: track ? track.phasesDir : null,
+    route,
     phase_found: Boolean(phase),
     phase_number: phase ? phase.number : null,
+    phase_type: phase ? phase.type : null,
     phase_name: phase ? phase.name : null,
     phase_dir: phase ? phase.dir : null,
     plan_path: phase ? phase.planPath : null,
     summary_path: phase ? phase.summaryPath : null,
+    review_path: phase ? phase.reviewPath : null,
     uat_path: phase ? phase.uatPath : null,
     plan_exists: phase ? phase.planExists : false,
     summary_exists: phase ? phase.summaryExists : false,
-    uat_exists: phase ? phase.uatExists : false
+    review_exists: phase ? phase.reviewExists : false,
+    uat_exists: phase ? phase.uatExists : false,
+    workflow: config.workflow,
+    git_mode: config.git.mode
   };
 }
 
@@ -309,7 +606,7 @@ function main() {
       process.exit(1);
     }
     const value = dotGet(loadConfig(cwd), key);
-    if (typeof value === 'object') {
+    if (typeof value === 'object' && value !== null) {
       printJson(value);
     } else if (value !== undefined) {
       process.stdout.write(`${String(value)}\n`);
@@ -317,6 +614,17 @@ function main() {
     return;
   }
 
+  if (command === 'route') {
+    const mode = rest[0] || 'json';
+    const route = buildRoute(cwd);
+    if (mode === 'json') {
+      printJson(route);
+      return;
+    }
+    process.stdout.write(`${route.command}\n`);
+    return;
+  }
+
   if (command === 'init') {
     const mode = rest[0];
     const phase = rest[1];
@@ -339,8 +647,16 @@ if (require.main === module) {
 module.exports = {
   autodevDir,
   buildProgress,
+  buildRoute,
+  detectExistingCodebase,
+  initPayload,
+  listPhases,
+  listTracks,
   loadConfig,
   parseRoadmap,
+  readActiveTrack,
   renderProgressTable,
-  resolvePhase
+  resolvePhase,
+  rootPaths,
+  trackPaths
 };

package/autodev/templates/codebase/domain.md

@@ -0,0 +1,13 @@
+# Codebase Domain
+
+## Main Product Areas
+- [Domain area]
+
+## Key User Or System Flows
+- [Flow]
+
+## Data And State Boundaries
+- [Where important state lives]
+
+## Active Track Impact
+- [How the current track intersects the domain]

package/autodev/templates/codebase/quality.md

@@ -0,0 +1,13 @@
+# Codebase Quality
+
+## Tests
+- [Existing test setup and obvious gaps]
+
+## Conventions
+- [Naming, file organization, style patterns]
+
+## Risks
+- [Security, stability, or maintainability concerns]
+
+## Tech Debt
+- [Important debt likely to affect the active track]