software-engineer 0.1.13 → 0.1.16

package/dist/claude.js

@@ -21,29 +21,15 @@ export async function runClaude(options, config) {
     }
     logInfo('Calling Claude...');
     return new Promise((resolve) => {
-        let capturedOutput = '';
         // Spawn Claude using child_process
-        // Use 'inherit' for stdin to allow interactive input
-        // Use 'pipe' for stdout/stderr to capture output while passing through
+        // Use 'inherit' for all stdio to allow Claude's interactive UI to work properly
+        // Claude CLI requires a TTY for its rich terminal features (spinners, progress, etc.)
+        // Piping stdout/stderr causes Claude to detect non-TTY and buffer/disable output
         const child = spawn('claude', args, {
             cwd: process.cwd(),
             env: process.env,
-            stdio: ['inherit', 'pipe', 'pipe'],
+            stdio: 'inherit',
         });
-        // Capture and pass through stdout
-        if (child.stdout) {
-            child.stdout.on('data', (data) => {
-                const text = data.toString();
-                process.stdout.write(text);
-                capturedOutput += text;
-            });
-        }
-        // Capture and pass through stderr
-        if (child.stderr) {
-            child.stderr.on('data', (data) => {
-                process.stderr.write(data.toString());
-            });
-        }
         // Handle process exit
         child.on('close', (exitCode) => {
             if (exitCode === EXIT_INTERRUPTED || exitCode === 2) {
@@ -52,11 +38,11 @@ export async function runClaude(options, config) {
             }
             else if (exitCode === EXIT_SUCCESS) {
                 logSuccess('Claude completed');
-                resolve({ success: true, output: capturedOutput });
+                resolve({ success: true, output: '' });
             }
             else {
                 logError(`Claude exited with code ${exitCode}`);
-                resolve({ success: false, output: capturedOutput });
+                resolve({ success: false, output: '' });
             }
         });
         // Handle spawn errors

package/dist/pipeline.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { log, logHeader, setLogFile, logInfo } from './logger.js';
-import { stepBranchManagement, stepImplement, stepSimplify, stepReview, stepSolidCleanCode, stepTest, stepCommit, stepChangelog, } from './steps/index.js';
+import { stepBranchManagement, stepUnderstandCodebase, stepImplement, stepSimplify, stepReview, stepSolidCleanCode, stepTest, stepCommit, stepChangelog, } from './steps/index.js';
 let signalHandlersRegistered = false;
 export async function runPipeline(config) {
     // Setup logging
@@ -31,13 +31,19 @@ export async function runPipeline(config) {
     // Extract adaptive analysis for step decisions
     const adaptive = branchResult.adaptiveAnalysis;
     const rec = adaptive?.stepRecommendation;
-    // Step 2: Implement
+    // Step 2: Understand Codebase
+    const understandSuccess = await stepUnderstandCodebase(config);
+    if (!understandSuccess) {
+        console.log(chalk.red('\nUnderstand codebase step failed. Exiting.'));
+        process.exit(1);
+    }
+    // Step 3: Implement
     const implSuccess = await stepImplement(config);
     if (!implSuccess) {
         console.log(chalk.red('\nImplementation step failed. Exiting.'));
         process.exit(1);
     }
-    // Step 3: Simplify (can be skipped by adaptive execution)
+    // Step 4: Simplify (can be skipped by adaptive execution)
     if (rec?.skipSimplify) {
         logInfo('Simplify step skipped (adaptive execution)');
     }
@@ -48,7 +54,7 @@ export async function runPipeline(config) {
             process.exit(1);
         }
     }
-    // Step 4: Review loop (can be skipped or adjusted by adaptive execution)
+    // Step 5: Review loop (can be skipped or adjusted by adaptive execution)
     if (rec?.skipReview) {
         logInfo('Review step skipped (adaptive execution)');
     }
@@ -67,7 +73,7 @@ export async function runPipeline(config) {
             }
         }
     }
-    // Step 5: SOLID & Clean Code (can be skipped by adaptive execution)
+    // Step 6: SOLID & Clean Code (can be skipped by adaptive execution)
     if (rec?.skipSolid) {
         logInfo('SOLID review step skipped (adaptive execution)');
     }
@@ -78,8 +84,14 @@ export async function runPipeline(config) {
             process.exit(1);
         }
     }
-    // Step 6: Test (can be skipped by adaptive execution or CLI flag)
-    const skipTestsReason = rec?.skipTests ? 'adaptive execution' : config.skipTests ? '--skip-tests' : null;
+    // Step 7: Test (can be skipped by adaptive execution or CLI flag)
+    let skipTestsReason = null;
+    if (rec?.skipTests) {
+        skipTestsReason = 'adaptive execution';
+    }
+    else if (config.skipTests) {
+        skipTestsReason = '--skip-tests';
+    }
     if (skipTestsReason) {
         logInfo(`Test step skipped (${skipTestsReason})`);
     }
@@ -90,13 +102,13 @@ export async function runPipeline(config) {
             process.exit(1);
         }
     }
-    // Step 7: Commit
+    // Step 8: Commit
     const commitSuccess = await stepCommit(config);
     if (!commitSuccess) {
         console.log(chalk.red('\nCommit step failed. Exiting.'));
         process.exit(1);
     }
-    // Step 8: Changelog (can be skipped by adaptive execution)
+    // Step 9: Changelog (can be skipped by adaptive execution)
     if (rec?.skipChangelog) {
         logInfo('Changelog step skipped (adaptive execution)');
     }

package/dist/steps/branchManagement.js

@@ -46,7 +46,7 @@ function branchMatchesRequirement(currentBranch, analysis) {
     return overlap || (prefixMatches && suggestedKeywords.length === 0);
 }
 export async function stepBranchManagement(config) {
-    logStep('1/8', 'SMART BRANCH MANAGEMENT');
+    logStep('1/9', 'SMART BRANCH MANAGEMENT');
     const adaptiveAnalysis = config.adaptiveExecution ? await performAdaptiveAnalysis(config) : null;
     if (config.skipBranchManagement) {
         logInfo('Branch management skipped (--skip-branch-management)');

package/dist/steps/changelog.js

@@ -1,7 +1,7 @@
 import { logStep } from '../logger.js';
 import { runClaude } from '../claude.js';
 export async function stepChangelog(config) {
-    logStep('8/8', 'UPDATE CHANGELOG');
+    logStep('9/9', 'UPDATE CHANGELOG');
     const prompt = `Update CHANGELOG.md:
 
 ## Format (Keep a Changelog):

package/dist/steps/commit.js

@@ -1,7 +1,7 @@
 import { logStep } from '../logger.js';
 import { runClaude } from '../claude.js';
 export async function stepCommit(config) {
-    logStep('7/8', 'COMMIT CHANGES');
+    logStep('8/9', 'COMMIT CHANGES');
     const pushInstruction = config.skipPush ? '' : 'Then push to remote.';
     const prompt = `Commit the changes:
 

package/dist/steps/implement.js

@@ -1,15 +1,14 @@
 import { logStep } from '../logger.js';
 import { runClaude } from '../claude.js';
 export async function stepImplement(config) {
-    logStep('2/8', 'IMPLEMENT REQUIREMENT');
+    logStep('3/9', 'IMPLEMENT REQUIREMENT');
     const prompt = `${config.requirement}
 
 ## Implementation Guidelines:
-- Understand the existing codebase structure first
 - Write clean, idiomatic code following project conventions
 - Handle edge cases and errors appropriately
 - Add necessary comments for complex logic
-- Keep changes focused and minimal`;
-    const result = await runClaude({ prompt }, config);
+- Keep changes focused and minimal. Once the work is completed, exit.`;
+    const result = await runClaude({ prompt, continueConversation: true }, config);
     return result.success;
 }

package/dist/steps/index.d.ts

@@ -1,4 +1,5 @@
 export { stepBranchManagement, type BranchResult } from './branchManagement.js';
+export { stepUnderstandCodebase } from './understand.js';
 export { stepImplement } from './implement.js';
 export { stepSimplify } from './simplify.js';
 export { stepReview, type ReviewResult, type ReviewDepth } from './review.js';

package/dist/steps/index.js

@@ -1,4 +1,5 @@
 export { stepBranchManagement } from './branchManagement.js';
+export { stepUnderstandCodebase } from './understand.js';
 export { stepImplement } from './implement.js';
 export { stepSimplify } from './simplify.js';
 export { stepReview } from './review.js';

package/dist/steps/review.js

@@ -60,7 +60,7 @@ function getPromptForDepth(depth) {
 }
 export async function stepReview(iteration, config, depth = 'standard') {
     const depthLabel = depth !== 'standard' ? ` [${depth}]` : '';
-    logStep('4/8', `CODE REVIEW (Round ${iteration}/${config.reviewIterations})${depthLabel}`);
+    logStep('5/9', `CODE REVIEW (Round ${iteration}/${config.reviewIterations})${depthLabel}`);
     const prompt = getPromptForDepth(depth);
     const result = await runClaude({ prompt, continueConversation: true }, config);
     const noIssuesFound = result.success && detectNoIssues(result.output);

package/dist/steps/simplify.js

@@ -1,7 +1,7 @@
 import { logStep } from '../logger.js';
 import { runClaude } from '../claude.js';
 export async function stepSimplify(config) {
-    logStep('3/8', 'CODE SIMPLIFICATION');
+    logStep('4/9', 'CODE SIMPLIFICATION');
     const prompt = `Refine the recently modified code for clarity, consistency, and maintainability while preserving all functionality.
 
 ## Core Principles:

package/dist/steps/solid.js

@@ -1,7 +1,7 @@
 import { logStep } from '../logger.js';
 import { runClaude } from '../claude.js';
 export async function stepSolidCleanCode(config) {
-    logStep('5/8', 'SOLID PRINCIPLES & CLEAN CODE');
+    logStep('6/9', 'SOLID PRINCIPLES & CLEAN CODE');
     const prompt = `Review the code for SOLID principles and Clean Code compliance:
 
 ## SOLID Principles:

package/dist/steps/test.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import { logStep } from '../logger.js';
 import { runClaude } from '../claude.js';
 export async function stepTest(config) {
-    logStep('6/8', 'TESTING');
+    logStep('7/9', 'TESTING');
     if (config.skipTests) {
         console.log(chalk.yellow('[SKIPPED]') + ' Testing step skipped via configuration');
         return true;

package/dist/steps/understand.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from '../config.js';
+export declare function stepUnderstandCodebase(config: Config): Promise<boolean>;

package/dist/steps/understand.js

@@ -0,0 +1,100 @@
+import { logStep } from '../logger.js';
+import { runClaude } from '../claude.js';
+const UNDERSTAND_CODEBASE_PROMPT = `Goal
+Build an internal map of the codebase. Do not change code. Do not refactor. Do not optimize.
+
+Operating mode
+Static analysis first. Minimal assumptions. Prefer certainty over completeness.
+
+Required steps
+
+1. Detect codebase type
+
+   * Language(s)
+   * Runtime
+   * Frameworks
+   * Monorepo or single service
+
+2. Identify execution roots
+
+   * Primary entry files
+   * CLI commands
+   * Server startup paths
+   * Test runners
+
+3. Build directory graph
+
+   * Top level folders
+   * Purpose of each folder
+   * Ownership boundaries if visible
+
+4. Dependency flow analysis
+
+   * Module import graph
+   * Direction of dependencies
+   * Shared utilities vs feature code
+
+5. Architecture inference
+
+   * Architectural style if evident
+   * Layer boundaries
+   * Cross layer violations
+
+6. State and data flow
+
+   * Where state lives
+   * How data moves between modules
+   * Persistence boundaries
+
+7. External interfaces
+
+   * APIs exposed
+   * APIs consumed
+   * Databases, queues, filesystems
+
+8. Configuration and environment
+
+   * Config files
+   * Environment variables
+   * Feature flags
+
+9. Change impact map
+
+   * High blast radius files
+   * Core abstractions
+   * Unsafe modification zones
+
+10. Gaps and unknowns
+
+* Missing docs
+* Ambiguous responsibilities
+* Implicit behavior
+
+Output format
+
+* Use structured bullet points
+* Use short phrases, not prose
+* Use file paths when referencing code
+* Flag assumptions explicitly
+* End with a one page mental model of the system
+
+Constraints
+
+* No code edits
+* No speculative refactors
+* No style commentary
+* No opinions unless clearly labeled as inference
+
+Primary objective
+Enable safe future modifications by maximizing structural understanding.`;
+export async function stepUnderstandCodebase(config) {
+    logStep('2/9', 'UNDERSTAND CODEBASE');
+    const prompt = `${UNDERSTAND_CODEBASE_PROMPT}
+
+Context: I need to understand this codebase to implement the following requirement:
+${config.requirement}
+
+Focus your analysis on areas most relevant to this requirement while still building a complete mental model.`;
+    const result = await runClaude({ prompt }, config);
+    return result.success;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "software-engineer",
-  "version": "0.1.13",
+  "version": "0.1.16",
   "description": "CLI that automates the full dev workflow with Claude AI - implement, review, test, and commit code with a single command",
   "type": "module",
   "main": "dist/index.js",