software-engineer 0.1.23 → 0.1.24

package/README.md

@@ -4,6 +4,11 @@ A CLI tool that automates the software development workflow using Claude AI. It
 
 By default, Claude is automatically granted permission to **Edit, Read, and Bash** tools, allowing seamless autonomous operation without constant permission prompts.
 
+
+## The Brain
+
+![](docs/architecture-diagram.png)
+
 ## Installation
 
 ```bash
@@ -104,6 +109,39 @@ sf --dangerously-skip-permissions "implement feature"
 
 **Note**: When `--dangerously-skip-permissions` is used, the `allowedTools` setting is ignored.
 
+## Run Individual Stages
+
+You can run specific pipeline stages directly without executing the full pipeline. This is useful for running a quick review or cleanup on code you've already written.
+
+```bash
+# Run only the code simplification step
+sf --simplify
+
+# Run only the code review step
+sf --review
+
+# Run only the SOLID & clean code check
+sf --clean-code
+
+# Run only the testing step
+sf --test
+
+# Run only the commit step
+sf --commit
+
+# Run only the implementation step (requires a requirement)
+sf --implement "add error handling to the API"
+
+# Combine multiple stages (executed in pipeline order)
+sf --simplify --review --clean-code
+
+# Works with other options
+sf --review -r 3         # 3 review iterations
+sf --review --dry-run    # Preview without executing
+```
+
+**Note**: All stages except `--implement` work without a requirement — they operate on the current state of your code. You can combine multiple stage flags and they will run in pipeline order.
+
 ## Options
 
 | Option | Description |
@@ -114,6 +152,14 @@ sf --dangerously-skip-permissions "implement feature"
 | `--skip-tests` | Skip the testing step |
 | `--skip-push` | Commit but don't push to remote |
 | `--skip-branch-management` | Skip smart branch management |
+| `--implementation-only` | Run only: Implement → Review → SOLID |
+| `--implement` | Run only the implementation step |
+| `--simplify` | Run only the code simplification step |
+| `--review` | Run only the code review step |
+| `--clean-code` | Run only the SOLID & clean code step |
+| `--test` | Run only the testing step |
+| `--commit` | Run only the commit step |
+| `--changelog` | Run only the changelog step |
 | `--log <file>` | Log output to file |
 | `--allowedTools <tools>` | Comma-separated list of allowed tools (default: "Edit,Read,Bash") |
 | `--dangerously-skip-permissions` | Skip Claude permission prompts (overrides allowedTools) |

package/dist/config.d.ts

@@ -1,3 +1,5 @@
+export declare const VALID_STAGES: readonly ["implement", "simplify", "review", "clean-code", "test", "commit", "changelog"];
+export type StageName = typeof VALID_STAGES[number];
 export interface Config {
     reviewIterations: number;
     dryRun: boolean;
@@ -10,6 +12,7 @@ export interface Config {
     requirement: string;
     adaptiveExecution: boolean;
     implementationOnly: boolean;
+    runStages?: StageName[];
 }
 export declare function loadConfigFromEnv(): Partial<Config>;
 export declare function mergeConfig(envConfig: Partial<Config>, cliConfig: Partial<Config>): Config;

package/dist/config.js

@@ -1,4 +1,13 @@
 const DEFAULT_REVIEW_ITERATIONS = 2;
+export const VALID_STAGES = [
+    'implement',
+    'simplify',
+    'review',
+    'clean-code',
+    'test',
+    'commit',
+    'changelog',
+];
 function parseBoolEnv(value, defaultValue) {
     if (value === undefined)
         return defaultValue;
@@ -42,5 +51,6 @@ export function mergeConfig(envConfig, cliConfig) {
         requirement: cliConfig.requirement ?? '',
         adaptiveExecution: cliConfig.adaptiveExecution ?? envConfig.adaptiveExecution ?? false,
         implementationOnly: cliConfig.implementationOnly ?? envConfig.implementationOnly ?? false,
+        runStages: cliConfig.runStages,
     };
 }

package/dist/index.js

@@ -5,7 +5,7 @@ import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { createInterface } from 'readline';
-import { loadConfigFromEnv, mergeConfig } from './config.js';
+import { loadConfigFromEnv, mergeConfig, VALID_STAGES } from './config.js';
 import { runPipeline } from './pipeline.js';
 import { checkForUpdates } from './utils/updateNotifier.js';
 async function promptForRequirement() {
@@ -48,15 +48,28 @@ program
     .option('--skip-push', 'Commit but do not push')
     .option('--skip-branch-management', 'Skip smart branch management')
     .option('--implementation-only', 'Run only: Implement → Review → SOLID (skips branch, tests, commit)')
+    .option('--implement', 'Run only the implementation step')
+    .option('--simplify', 'Run only the code simplification step')
+    .option('--review', 'Run only the code review step')
+    .option('--clean-code', 'Run only the SOLID & clean code step')
+    .option('--test', 'Run only the testing step')
+    .option('--commit', 'Run only the commit step')
+    .option('--changelog', 'Run only the changelog step')
     .option('--log <file>', 'Log output to file')
     .option('--dangerously-skip-permissions', 'Pass flag to claude to skip permission prompts')
     .option('--allowedTools <tools>', 'Comma-separated list of allowed tools (default: "Edit,Read,Bash")')
     .action(async (requirement, options) => {
     // Check for updates (non-blocking, fails silently)
     await checkForUpdates(pkg.name, pkg.version).catch(() => { });
-    // Prompt for requirement if not provided
+    // Collect stage flags
+    const selectedStages = VALID_STAGES.filter((stage) => {
+        const camelCase = stage.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        return !!options[camelCase];
+    });
+    // Prompt for requirement if not provided (skip for stages that don't need one)
+    const stageNeedsRequirement = selectedStages.length === 0 || selectedStages.includes('implement');
     let finalRequirement = requirement;
-    if (!finalRequirement) {
+    if (!finalRequirement && stageNeedsRequirement) {
         finalRequirement = await promptForRequirement();
     }
     const envConfig = loadConfigFromEnv();
@@ -72,10 +85,15 @@ program
         allowedTools: options.allowedTools ?? undefined,
         adaptiveExecution: options.adaptive ?? undefined,
         implementationOnly: options.implementationOnly ?? undefined,
+        runStages: selectedStages.length > 0 ? selectedStages : undefined,
     };
     const config = mergeConfig(envConfig, cliConfig);
     // Handle implementation-only mode
     if (config.implementationOnly) {
+        if (config.runStages) {
+            console.error(chalk.red('Error:') + ' Cannot use --implementation-only with individual stage flags');
+            process.exit(1);
+        }
         // Implementation-only mode automatically skips branch management and tests
         config.skipBranchManagement = true;
         config.skipTests = true;
@@ -86,7 +104,9 @@ program
         }
         config.adaptiveExecution = false;
     }
-    if (!config.requirement) {
+    // Require a requirement for full pipeline or implement stage; optional for other stages
+    const needsRequirement = !config.runStages || config.runStages.includes('implement');
+    if (!config.requirement && needsRequirement) {
         console.error(chalk.red('Error:') + ' No requirement provided');
         program.help();
         return; // Ensure we don't continue if help() doesn't exit

package/dist/pipeline.js

@@ -34,6 +34,74 @@ function displayCompletionMessage(implementationOnly) {
         console.log(chalk.green('\n✓ Pipeline completed successfully\n'));
     }
 }
+const STAGE_LABELS = {
+    'implement': 'Implement',
+    'simplify': 'Simplify',
+    'review': 'Code Review',
+    'clean-code': 'SOLID & Clean Code',
+    'test': 'Testing',
+    'commit': 'Commit',
+    'changelog': 'Changelog',
+};
+async function runSelectedStages(config) {
+    const stages = config.runStages;
+    const stageLabels = stages.map((s) => STAGE_LABELS[s]).join(' → ');
+    console.log(chalk.cyan(`▶ Running selected stage(s): ${stageLabels}\n`));
+    for (const stage of stages) {
+        switch (stage) {
+            case 'implement': {
+                const success = await stepImplement(config);
+                if (!success)
+                    exitWithError('Implementation step failed. Exiting.');
+                break;
+            }
+            case 'simplify': {
+                const success = await stepSimplify(config);
+                if (!success)
+                    exitWithError('Simplification step failed. Exiting.');
+                break;
+            }
+            case 'review': {
+                const reviewIterations = config.reviewIterations;
+                for (let i = 1; i <= reviewIterations; i++) {
+                    const reviewResult = await stepReview(i, config);
+                    if (!reviewResult.success)
+                        exitWithError('Review step failed. Exiting.');
+                    if (reviewResult.noIssuesFound) {
+                        console.log(chalk.green('\n✓ Code review passed - no issues found, skipping remaining reviews'));
+                        break;
+                    }
+                }
+                break;
+            }
+            case 'clean-code': {
+                const success = await stepSolidCleanCode(config);
+                if (!success)
+                    exitWithError('SOLID review step failed. Exiting.');
+                break;
+            }
+            case 'test': {
+                const success = await stepTest(config);
+                if (!success)
+                    exitWithError('Test step failed. Exiting.');
+                break;
+            }
+            case 'commit': {
+                const success = await stepCommit(config);
+                if (!success)
+                    exitWithError('Commit step failed. Exiting.');
+                break;
+            }
+            case 'changelog': {
+                const success = await stepChangelog(config);
+                if (!success)
+                    exitWithError('Changelog step failed. Exiting.');
+                break;
+            }
+        }
+    }
+    console.log(chalk.green('\n✓ Selected stage(s) completed successfully\n'));
+}
 export async function runPipeline(config) {
     // Setup logging
     if (config.logFile) {
@@ -53,6 +121,10 @@ export async function runPipeline(config) {
     }
     // Display header
     logHeader(config);
+    // Run specific stages if requested
+    if (config.runStages && config.runStages.length > 0) {
+        return runSelectedStages(config);
+    }
     if (config.implementationOnly) {
         displayImplementationOnlyBanner();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "software-engineer",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "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",