@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.d0ad4ae

package/analyzer-template/project/start.ts

@@ -5,7 +5,8 @@ import {
   loadBackgroundJob,
   loadProject,
   updateBackgroundJobProgress,
-} from '~codeyam/supabase';
+  updateCommitMetadata,
+} from '~codeyam/database';
 import { Commit, ProjectFramework, ServerCommand } from '~codeyam/types';
 import runCaptureOrchestration from './orchestrateCapture';
 import AwsCaptureTaskRunner from './orchestrateCapture/AwsCaptureTaskRunner';
@@ -22,7 +23,7 @@ import {
   syncHeadBranches,
   syncPrimaryBranch,
 } from '~codeyam/github';
-import { installSignalHandlers } from '../process';
+import { installSignalHandlers } from '~codeyam/process';
 
 // Set process title for Activity Monitor visibility
 if (process.env.CODEYAM_PROCESS_NAME) {
@@ -172,6 +173,24 @@ async function main({
         awsLog(
           'CodeYam Capture: analysis completed, signaling orchestration to begin draining...',
         );
+
+        // Update commit metadata to mark analysis as complete
+        // This allows the UI to show the "Capturing..." state
+        // With orchestration, the same process handles both phases,
+        // so we clear analyzerPid and set capturePid for a clean state transition
+        if (sharedContext.commit?.sha) {
+          await updateCommitMetadata({
+            commitSha: sharedContext.commit.sha,
+            runStatusUpdate: {
+              analysisCompletedAt: new Date().toISOString(),
+              analyzerPid: undefined,
+              capturePid: process.pid,
+            },
+          }).catch((error) => {
+            awsLog(`Warning: Failed to update commit metadata: ${error}`);
+          });
+        }
+
         if (sendControlMessage) {
           sendControlMessage('drain');
         } else {
@@ -213,12 +232,8 @@ async function main({
               absoluteTempPath,
               startArgs: {
                 packageManager,
-                absoluteProjectRootPath,
-                absoluteTempPath,
                 framework,
-                noServer: false,
                 steps,
-                fast,
               },
               // Pass universal mocks so they're applied to the capturer's project directory
               universalMocks: sharedContext.project.metadata?.universalMocks,
@@ -245,15 +260,27 @@ async function main({
             }
           },
           project: sharedContext.project,
-          // In local-sequential mode, don't filter by commit since each analysis run
-          // creates a new fake commit. We want to capture all ready analyses for the project.
+          // In local-sequential mode, don't filter by commit (full=true handles that).
+          // For AWS mode, filter by the specific commit being analyzed.
           commit:
             orchestrateCapture === 'local-sequential'
               ? null
               : (sharedContext.commit ?? sharedContext.branchCommit),
-          analysisIds: envConfig.analysisIds,
-          entityShas: envConfig.entityShas,
+          // In local-sequential mode, don't filter by analysisIds/entityShas since
+          // analysis may create new entities with different SHAs than the input filters.
+          // We want to capture all ready analyses for the project.
+          analysisIds:
+            orchestrateCapture === 'local-sequential'
+              ? undefined
+              : envConfig.analysisIds,
+          entityShas:
+            orchestrateCapture === 'local-sequential'
+              ? undefined
+              : envConfig.entityShas,
+          full: orchestrateCapture === 'local-sequential',
           taskRunner,
+          // Always track capture progress on the commit, even when not filtering by it.
+          metadataCommit: sharedContext.commit ?? sharedContext.branchCommit,
         });
         awsLog('CodeYam Capture: runCaptureOrchestration() completed');
       };
@@ -415,6 +442,16 @@ async function main({
         `CodeYam: Exiting start.js process with ${hadError ? 'ERROR' : 'SUCCESS'}`,
       );
       process.exit(hadError ? 1 : 0);
+    } else if (process.env.CAPTURE_ONLY === 'true') {
+      awsLog(
+        'CodeYam: CAPTURE_ONLY mode - keeping files and exiting cleanly',
+        `Preserved ${generatedFiles.length} files`,
+      );
+      // Don't cleanup files in capture-only mode to preserve manual edits
+      awsLog(
+        `CodeYam: Exiting start.js process with ${hadError ? 'ERROR' : 'SUCCESS'}`,
+      );
+      process.exit(hadError ? 1 : 0);
     } else {
       awsLog(`CodeYam: Removing ${generatedFiles.length} generated files...`);
       removeScenario(generatedFiles);

package/analyzer-template/project/startScenarioCapture.ts

@@ -13,7 +13,7 @@ import {
 import removeScenario from './removeScenario';
 import { recordErrorMessageForScenario } from './utils/errorHandling';
 import { Controller } from './controller/startController';
-import { loadFile, updateFreshAnalysisStatus } from '~codeyam/supabase';
+import { loadFile, updateFreshAnalysisStatus } from '~codeyam/database';
 import {
   awsLog,
   awsLogDebugLevel,
@@ -36,6 +36,7 @@ import {
 } from './utils/webappMapping';
 import mergeEnvVarsIntoStartCommand from './utils/mergeEnvVarsIntoStartCommand';
 import { LazyFileStore } from './LazyFileStore';
+import { DEFAULT_SCENARIO_NAME } from '../common/constants';
 
 export interface StartScenarioCaptureArgs {
   readyToBeCaptured: Analysis[];
@@ -85,8 +86,9 @@ export async function startScenarioCapture({
   }
 
   // Clean up any leftover generated files from previous debug sessions
+  // Skip in CAPTURE_ONLY mode - we want to preserve the files that were edited
   const previouslyTracked = readTrackingFile();
-  if (previouslyTracked) {
+  if (previouslyTracked && process.env.CAPTURE_ONLY !== 'true') {
     awsLog('CodeYam: Cleaning up files from previous session', {
       generatedCount: previouslyTracked.generatedFiles.length,
       backupCount: previouslyTracked.backupFiles.length,
@@ -97,6 +99,13 @@ export async function startScenarioCapture({
       restoreFromBackup(backupPath);
     }
     clearTrackingFile();
+  } else if (previouslyTracked && process.env.CAPTURE_ONLY === 'true') {
+    awsLog(
+      'CodeYam: CAPTURE_ONLY mode - preserving files from previous session',
+      {
+        generatedCount: previouslyTracked.generatedFiles.length,
+      },
+    );
   }
 
   const sortedReadyToBeCaptured = readyToBeCaptured.sort((a, b) => {
@@ -218,6 +227,11 @@ export async function startScenarioCapture({
     }
 
     const sortedScenarios = (analysis.scenarios ?? []).sort((a, b) => {
+      // Default Scenario always goes first
+      if (a.name === DEFAULT_SCENARIO_NAME) return -1;
+      if (b.name === DEFAULT_SCENARIO_NAME) return 1;
+
+      // Then prioritize new or revised scenarios
       const newOrRevisedA =
         !a.previousVersionId || a.metadata?.revisedFromPreviousVersion;
       const newOrRevisedB =
@@ -352,7 +366,12 @@ export async function startScenarioCapture({
     const mocksDir = `${appPath}/${CODEYAM_MOCKS_DIRNAME}/`;
 
     for (const scenario of sortedScenarios) {
-      if (scenarioIds && !scenarioIds.includes(scenario.id)) {
+      // Check both id and name since scenarioIds may contain either (recapture uses names)
+      if (
+        scenarioIds &&
+        !scenarioIds.includes(scenario.id) &&
+        !scenarioIds.includes(scenario.name)
+      ) {
         awsLog('CodeYam: Skipping scenario', {
           thisScenarioId: scenario.id,
           thisScenarioName: scenario.name,
@@ -379,6 +398,7 @@ export async function startScenarioCapture({
       if (
         !process.env['CODEYAM_LOCAL_PROJECT_PATH'] &&
         !scenarioIds?.includes(scenario.id) &&
+        !scenarioIds?.includes(scenario.name) &&
         !analysisIds?.includes(analysis.id) &&
         (scenarioStatus?.finishedAt ||
           scenarioStatus?.error ||
@@ -389,40 +409,50 @@ export async function startScenarioCapture({
 
       awsLogDebugLevel(1, `Preparing ${analysis.entityName}: ${scenario.name}`);
 
-      // Write scenario files upfront
-      const scenarioGeneratedFiles = await writeScenario({
-        analysis,
-        scenario,
-        context,
-        projectAnalyzer,
-        framework,
-        fileStore,
-      });
-
-      // For non-routes: write root.tsx now (all scenarios can share it)
-      // For routes: defer writeSimpleRoot to per-scenario execution (each needs different mocks)
-      // EXCEPTION: In PREP_ONLY mode (debug), routes also need root.tsx written here since we exit early
-      if (!isRoute || process.env.PREP_ONLY === 'true') {
-        const simpleRootResult = await writeSimpleRoot(
-          project,
-          framework,
+      // In CAPTURE_ONLY mode, skip file generation and use existing files
+      // This preserves manual fixes made during debugging
+      let scenarioGeneratedFiles: string[] = [];
+      if (process.env.CAPTURE_ONLY !== 'true') {
+        // Write scenario files upfront
+        scenarioGeneratedFiles = await writeScenario({
+          analysis,
           scenario,
-          analysis.filePath,
-          {
-            file: analysis.file,
-            entity: analysis.entity,
-            routeAnalysis: analysis,
-            mocksDir,
-            scenarioComponentPaths: scenarioGeneratedFiles,
-          },
-        );
-        if (simpleRootResult.filePath) {
-          if (simpleRootResult.backupPath) {
-            backupFiles.push(simpleRootResult.backupPath);
-          } else {
-            scenarioGeneratedFiles.push(simpleRootResult.filePath);
+          context,
+          projectAnalyzer,
+          framework,
+          fileStore,
+        });
+
+        // For non-routes: write root.tsx now (all scenarios can share it)
+        // For routes: defer writeSimpleRoot to per-scenario execution (each needs different mocks)
+        // EXCEPTION: In PREP_ONLY mode (debug), routes also need root.tsx written here since we exit early
+        if (!isRoute || process.env.PREP_ONLY === 'true') {
+          const simpleRootResult = await writeSimpleRoot(
+            project,
+            framework,
+            scenario,
+            analysis.filePath,
+            {
+              file: analysis.file,
+              entity: analysis.entity,
+              routeAnalysis: analysis,
+              mocksDir,
+              scenarioComponentPaths: scenarioGeneratedFiles,
+            },
+          );
+          if (simpleRootResult.filePath) {
+            if (simpleRootResult.backupPath) {
+              backupFiles.push(simpleRootResult.backupPath);
+            } else {
+              scenarioGeneratedFiles.push(simpleRootResult.filePath);
+            }
           }
         }
+      } else {
+        awsLogDebugLevel(
+          1,
+          `CAPTURE_ONLY mode: skipping file generation for ${scenario.name}`,
+        );
       }
 
       // Mark scenario as initializing
@@ -678,14 +708,22 @@ export async function startScenarioCapture({
         allGeneratedFiles,
       );
 
-      // Clean up all generated files
-      console.log(
-        'CodeYam: Removing all scenario files for analysis',
-        analysis.id,
-        analysis.entityName,
-      );
-      cleanupFiles(allGeneratedFiles, backupFiles);
-      backupFiles = [];
+      // Clean up all generated files (skip in CAPTURE_ONLY mode to preserve edits)
+      if (process.env.CAPTURE_ONLY !== 'true') {
+        console.log(
+          'CodeYam: Removing all scenario files for analysis',
+          analysis.id,
+          analysis.entityName,
+        );
+        cleanupFiles(allGeneratedFiles, backupFiles);
+        backupFiles = [];
+      } else {
+        console.log(
+          'CodeYam: CAPTURE_ONLY mode - preserving scenario files for analysis',
+          analysis.id,
+          analysis.entityName,
+        );
+      }
 
       forceStop = result.forceStop;
     }

package/analyzer-template/project/updateCommitBackgroundJob.ts

@@ -1,4 +1,4 @@
-import { updateBackgroundJobProgress } from '~codeyam/supabase';
+import { updateBackgroundJobProgress } from '~codeyam/database';
 import { BackgroundJob } from '~codeyam/types';
 export default async function updateCommitBackgroundJob(
   backgroundJob: BackgroundJob,

package/analyzer-template/project/utils/errorHandling.ts

@@ -1,6 +1,6 @@
 import { Analysis, Scenario } from '~codeyam/types';
 import emailErrorReport from '../emailErrorReport';
-import { updateFreshAnalysisStatus } from '~codeyam/supabase';
+import { updateFreshAnalysisStatus } from '~codeyam/database';
 
 export async function recordErrorMessageForScenario(
   analysis: Analysis,