software-engineer 0.1.10

package/README.md

@@ -0,0 +1,111 @@
+# software-engineer
+
+A CLI tool that automates the software development workflow using Claude AI. It runs a 7-step pipeline to implement features, simplify code, review, ensure quality, test, commit, and update changelogs.
+
+## Installation
+
+```bash
+npm install -g software-engineer
+```
+
+## Prerequisites
+
+- Node.js >= 18.0.0
+- [Claude CLI](https://github.com/anthropics/claude-code) installed and configured
+
+## Usage
+
+```bash
+sf "<requirement>"
+```
+
+### Examples
+
+```bash
+# Basic usage
+sf "add user authentication with JWT"
+
+# Custom review iterations
+sf --reviews 3 "refactor database layer"
+
+# Dry run to preview commands
+sf --dry-run "add dark mode toggle"
+
+# Skip tests and push
+sf --skip-tests --skip-push "update README"
+
+# Log output to file
+sf --log pipeline.log "implement caching layer"
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `-d, --dry-run` | Print commands without executing |
+| `-r, --reviews <n>` | Number of review iterations (default: 2) |
+| `--skip-tests` | Skip the testing step |
+| `--skip-push` | Commit but don't push to remote |
+| `--log <file>` | Log output to file |
+| `--dangerously-skip-permissions` | Skip Claude permission prompts |
+| `-h, --help` | Display help |
+| `-V, --version` | Display version |
+
+## Environment Variables
+
+All options can be set via environment variables:
+
+| Variable | Description |
+|----------|-------------|
+| `SF_REVIEW_ITERATIONS` | Number of review iterations |
+| `SF_DRY_RUN` | `true`/`false` for dry run |
+| `SF_LOG_FILE` | Path to log file |
+| `SF_SKIP_TESTS` | `true`/`false` to skip tests |
+| `SF_SKIP_PUSH` | `true`/`false` to skip push |
+| `SF_DANGEROUSLY_SKIP_PERMISSIONS` | `true`/`false` to skip Claude permissions |
+
+Example:
+```bash
+SF_REVIEW_ITERATIONS=3 sf "add feature X"
+```
+
+## Pipeline Steps
+
+### 1. Implement
+Takes your requirement and asks Claude to implement it following project conventions.
+
+### 2. Code Simplification
+Refines the implementation for clarity, consistency, and maintainability while preserving functionality:
+- Follows project standards (ES modules, explicit types)
+- Enhances clarity by avoiding nested ternaries
+- Removes redundant abstractions
+
+### 3. Code Review (configurable iterations)
+Reviews the implementation for:
+- Bugs (logic errors, null refs, race conditions)
+- Security issues (injection, auth problems)
+- Performance (N+1 queries, memory leaks)
+- Maintainability (clarity, naming, complexity)
+
+### 4. SOLID & Clean Code
+Ensures compliance with:
+- SOLID principles (SRP, OCP, LSP, ISP, DIP)
+- Clean code practices (naming, small functions, no magic numbers)
+
+### 5. Testing
+- Runs existing tests
+- Adds new tests for changed code
+- Verifies coverage
+
+### 6. Commit
+Creates a well-formatted commit with:
+- Conventional commit format
+- Clear subject line
+- Detailed body explaining why and what
+
+### 7. Changelog
+Updates CHANGELOG.md following Keep a Changelog format.
+
+## License
+
+MIT

package/dist/claude.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from './config.js';
+export interface ClaudeOptions {
+    prompt: string;
+    continueConversation?: boolean;
+}
+export interface ClaudeResult {
+    success: boolean;
+    output: string;
+}
+export declare function runClaude(options: ClaudeOptions, config: Config): Promise<ClaudeResult>;

package/dist/claude.js

@@ -0,0 +1,68 @@
+import { spawn } from 'child_process';
+import { logInfo, logSuccess, logError, logDryRun } from './logger.js';
+// Exit codes
+const EXIT_SUCCESS = 0;
+const EXIT_INTERRUPTED = 130;
+export async function runClaude(options, config) {
+    // Build the full prompt with exit instruction (like Python version)
+    const fullPrompt = `${options.prompt}. Once the work is completed, exit.`;
+    const args = [];
+    if (config.dangerouslySkipPermissions) {
+        args.push('--dangerously-skip-permissions');
+    }
+    if (options.continueConversation) {
+        args.push('-c');
+    }
+    // Pass prompt directly like Python version (not with -p flag)
+    args.push(fullPrompt);
+    if (config.dryRun) {
+        logDryRun(`claude ${args.join(' ')}`);
+        return { success: true, output: '' };
+    }
+    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
+        const child = spawn('claude', args, {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        // 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) {
+                logError('Claude interrupted');
+                process.exit(EXIT_INTERRUPTED);
+            }
+            else if (exitCode === EXIT_SUCCESS) {
+                logSuccess('Claude completed');
+                resolve({ success: true, output: capturedOutput });
+            }
+            else {
+                logError(`Claude exited with code ${exitCode}`);
+                resolve({ success: false, output: capturedOutput });
+            }
+        });
+        // Handle spawn errors
+        child.on('error', (err) => {
+            logError(`Failed to start Claude: ${err.message}`);
+            resolve({ success: false, output: '' });
+        });
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+export interface Config {
+    reviewIterations: number;
+    dryRun: boolean;
+    logFile?: string;
+    skipTests: boolean;
+    skipPush: boolean;
+    skipBranchManagement: boolean;
+    dangerouslySkipPermissions: boolean;
+    requirement: string;
+}
+export declare function loadConfigFromEnv(): Partial<Config>;
+export declare function mergeConfig(envConfig: Partial<Config>, cliConfig: Partial<Config>): Config;

package/dist/config.js

@@ -0,0 +1,35 @@
+const DEFAULT_REVIEW_ITERATIONS = 2;
+function parseBoolEnv(value, defaultValue) {
+    if (value === undefined)
+        return defaultValue;
+    return value.toLowerCase() === 'true';
+}
+function parseIntEnv(value, defaultValue) {
+    if (value === undefined)
+        return defaultValue;
+    const parsed = parseInt(value, 10);
+    return isNaN(parsed) ? defaultValue : parsed;
+}
+export function loadConfigFromEnv() {
+    return {
+        reviewIterations: parseIntEnv(process.env.SF_REVIEW_ITERATIONS, DEFAULT_REVIEW_ITERATIONS),
+        dryRun: parseBoolEnv(process.env.SF_DRY_RUN, false),
+        logFile: process.env.SF_LOG_FILE || undefined,
+        skipTests: parseBoolEnv(process.env.SF_SKIP_TESTS, false),
+        skipPush: parseBoolEnv(process.env.SF_SKIP_PUSH, false),
+        skipBranchManagement: parseBoolEnv(process.env.SF_SKIP_BRANCH_MANAGEMENT, false),
+        dangerouslySkipPermissions: parseBoolEnv(process.env.SF_DANGEROUSLY_SKIP_PERMISSIONS, false),
+    };
+}
+export function mergeConfig(envConfig, cliConfig) {
+    return {
+        reviewIterations: cliConfig.reviewIterations ?? envConfig.reviewIterations ?? DEFAULT_REVIEW_ITERATIONS,
+        dryRun: cliConfig.dryRun ?? envConfig.dryRun ?? false,
+        logFile: cliConfig.logFile ?? envConfig.logFile,
+        skipTests: cliConfig.skipTests ?? envConfig.skipTests ?? false,
+        skipPush: cliConfig.skipPush ?? envConfig.skipPush ?? false,
+        skipBranchManagement: cliConfig.skipBranchManagement ?? envConfig.skipBranchManagement ?? false,
+        dangerouslySkipPermissions: cliConfig.dangerouslySkipPermissions ?? envConfig.dangerouslySkipPermissions ?? false,
+        requirement: cliConfig.requirement ?? '',
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { loadConfigFromEnv, mergeConfig } from './config.js';
+import { runPipeline } from './pipeline.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+const program = new Command();
+program
+    .name('sf')
+    .description('Software Factory Pipeline - Automate development workflow with Claude AI')
+    .version(pkg.version)
+    .argument('<requirement>', 'The requirement or task to implement')
+    .option('-d, --dry-run', 'Print commands without executing')
+    .option('-r, --reviews <n>', 'Number of review iterations', '2')
+    .option('--skip-tests', 'Skip the testing step')
+    .option('--skip-push', 'Commit but do not push')
+    .option('--skip-branch-management', 'Skip smart branch management')
+    .option('--log <file>', 'Log output to file')
+    .option('--dangerously-skip-permissions', 'Pass flag to claude to skip permission prompts')
+    .action(async (requirement, options) => {
+    const envConfig = loadConfigFromEnv();
+    const cliConfig = {
+        requirement,
+        dryRun: options.dryRun ?? undefined,
+        reviewIterations: options.reviews ? parseInt(options.reviews, 10) : undefined,
+        skipTests: options.skipTests ?? undefined,
+        skipPush: options.skipPush ?? undefined,
+        skipBranchManagement: options.skipBranchManagement ?? undefined,
+        logFile: options.log ?? undefined,
+        dangerouslySkipPermissions: options.dangerouslySkipPermissions ?? undefined,
+    };
+    const config = mergeConfig(envConfig, cliConfig);
+    if (!config.requirement) {
+        console.error(chalk.red('Error:') + ' No requirement provided');
+        program.help();
+        return; // Ensure we don't continue if help() doesn't exit
+    }
+    try {
+        await runPipeline(config);
+    }
+    catch (error) {
+        console.error(chalk.red('Pipeline failed:'), error);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/logger.d.ts

@@ -0,0 +1,14 @@
+export declare function setLogFile(path: string | undefined): void;
+export declare function log(message: string): void;
+export declare function logRaw(message: string): void;
+export declare function logStep(stepNum: string, title: string): void;
+export declare function logHeader(config: {
+    reviewIterations: number;
+    dryRun: boolean;
+    dangerouslySkipPermissions: boolean;
+}): void;
+export declare function logSuccess(message: string): void;
+export declare function logError(message: string): void;
+export declare function logWarning(message: string): void;
+export declare function logInfo(message: string): void;
+export declare function logDryRun(command: string): void;

package/dist/logger.js

@@ -0,0 +1,72 @@
+import chalk from 'chalk';
+import { appendFileSync } from 'fs';
+const BOX_WIDTH = 62;
+let logFilePath;
+export function setLogFile(path) {
+    logFilePath = path;
+}
+function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function getTimestamp() {
+    return new Date().toISOString().replace('T', ' ').substring(0, 19);
+}
+export function log(message) {
+    const timestamped = `[${getTimestamp()}] ${message}`;
+    console.log(timestamped);
+    if (logFilePath) {
+        appendFileSync(logFilePath, stripAnsi(timestamped) + '\n');
+    }
+}
+export function logRaw(message) {
+    console.log(message);
+    if (logFilePath) {
+        appendFileSync(logFilePath, stripAnsi(message) + '\n');
+    }
+}
+export function logStep(stepNum, title) {
+    const line = '─'.repeat(BOX_WIDTH);
+    console.log();
+    console.log(chalk.cyan(`┌${line}┐`));
+    console.log(chalk.cyan('│') + ' ' + chalk.green(`STEP ${stepNum}:`) + ' ' + title);
+    console.log(chalk.cyan(`└${line}┘`));
+    console.log();
+    if (logFilePath) {
+        appendFileSync(logFilePath, `\n┌${line}┐\n│ STEP ${stepNum}: ${title}\n└${line}┘\n\n`);
+    }
+}
+export function logHeader(config) {
+    const line = '═'.repeat(BOX_WIDTH);
+    console.log();
+    console.log(chalk.green(`╔${line}╗`));
+    console.log(chalk.green('║') + '           SOFTWARE FACTORY PIPELINE v2.0                     ' + chalk.green('║'));
+    console.log(chalk.green(`╠${line}╣`));
+    const configLine = ` Reviews: ${config.reviewIterations} | Dry-run: ${config.dryRun}`;
+    console.log(chalk.green('║') + configLine.padEnd(BOX_WIDTH) + chalk.green('║'));
+    if (config.dangerouslySkipPermissions) {
+        const permLine = ' ' + chalk.yellow('⚠ Skip permissions: enabled');
+        console.log(chalk.green('║') + permLine + ' '.repeat(BOX_WIDTH - stripAnsi(permLine).length) + chalk.green('║'));
+    }
+    console.log(chalk.green(`╚${line}╝`));
+    console.log();
+}
+export function logSuccess(message) {
+    log(chalk.green(`✓ ${message}`));
+}
+export function logError(message) {
+    log(chalk.red(`✗ ${message}`));
+}
+export function logWarning(message) {
+    log(chalk.yellow(`⚠ ${message}`));
+}
+export function logInfo(message) {
+    log(chalk.blue(`▶ ${message}`));
+}
+export function logDryRun(command) {
+    const message = '[DRY-RUN] ' + command;
+    console.log(chalk.yellow('[DRY-RUN]') + ' ' + command);
+    if (logFilePath) {
+        appendFileSync(logFilePath, message + '\n');
+    }
+}

package/dist/pipeline.d.ts

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

package/dist/pipeline.js

@@ -0,0 +1,81 @@
+import chalk from 'chalk';
+import { log, logHeader, setLogFile } from './logger.js';
+import { stepBranchManagement, stepImplement, stepSimplify, stepReview, stepSolidCleanCode, stepTest, stepCommit, stepChangelog, } from './steps/index.js';
+let signalHandlersRegistered = false;
+export async function runPipeline(config) {
+    // Setup logging
+    if (config.logFile) {
+        setLogFile(config.logFile);
+    }
+    // Setup interrupt handler (only once to prevent duplicate registrations)
+    if (!signalHandlersRegistered) {
+        process.on('SIGINT', () => {
+            console.log(chalk.red('\n\nPipeline interrupted'));
+            process.exit(130);
+        });
+        process.on('SIGTERM', () => {
+            console.log(chalk.red('\n\nPipeline terminated'));
+            process.exit(130);
+        });
+        signalHandlersRegistered = true;
+    }
+    // Display header
+    logHeader(config);
+    log(`Starting pipeline for: ${config.requirement}`);
+    // Step 1: Smart Branch Management
+    const branchResult = await stepBranchManagement(config);
+    if (!branchResult.success) {
+        console.log(chalk.red('\nBranch management step failed. Exiting.'));
+        process.exit(1);
+    }
+    // Step 2: Implement
+    const implSuccess = await stepImplement(config);
+    if (!implSuccess) {
+        console.log(chalk.red('\nImplementation step failed. Exiting.'));
+        process.exit(1);
+    }
+    // Step 3: Simplify
+    const simplifySuccess = await stepSimplify(config);
+    if (!simplifySuccess) {
+        console.log(chalk.red('\nSimplification step failed. Exiting.'));
+        process.exit(1);
+    }
+    // Step 4: Review loop
+    for (let i = 1; i <= config.reviewIterations; i++) {
+        const reviewResult = await stepReview(i, config);
+        if (!reviewResult.success) {
+            console.log(chalk.red('\nReview step failed. Exiting.'));
+            process.exit(1);
+        }
+        // Skip remaining reviews if no issues were found
+        if (reviewResult.noIssuesFound) {
+            console.log(chalk.green('\n✓ Code review passed - no issues found, skipping remaining reviews'));
+            break;
+        }
+    }
+    // Step 5: SOLID & Clean Code
+    const solidSuccess = await stepSolidCleanCode(config);
+    if (!solidSuccess) {
+        console.log(chalk.red('\nSOLID review step failed. Exiting.'));
+        process.exit(1);
+    }
+    // Step 6: Test
+    const testSuccess = await stepTest(config);
+    if (!testSuccess) {
+        console.log(chalk.red('\nTest step failed. Exiting.'));
+        process.exit(1);
+    }
+    // Step 7: Commit
+    const commitSuccess = await stepCommit(config);
+    if (!commitSuccess) {
+        console.log(chalk.red('\nCommit step failed. Exiting.'));
+        process.exit(1);
+    }
+    // Step 8: Changelog
+    const changelogSuccess = await stepChangelog(config);
+    if (!changelogSuccess) {
+        console.log(chalk.red('\nChangelog step failed. Exiting.'));
+        process.exit(1);
+    }
+    console.log(chalk.green('\n✓ Pipeline completed successfully\n'));
+}

package/dist/prompts.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from './config.js';
+export declare enum ConfirmResult {
+    Continue = "continue",
+    Skip = "skip",
+    Quit = "quit"
+}
+export declare function confirm(config: Config): Promise<ConfirmResult>;
+export declare function handleConfirm(config: Config): Promise<boolean>;

package/dist/prompts.js

@@ -0,0 +1,36 @@
+import inquirer from 'inquirer';
+export var ConfirmResult;
+(function (ConfirmResult) {
+    ConfirmResult["Continue"] = "continue";
+    ConfirmResult["Skip"] = "skip";
+    ConfirmResult["Quit"] = "quit";
+})(ConfirmResult || (ConfirmResult = {}));
+export async function confirm(config) {
+    if (config.autoMode) {
+        return ConfirmResult.Continue;
+    }
+    const { action } = await inquirer.prompt([
+        {
+            type: 'expand',
+            name: 'action',
+            message: 'Continue?',
+            default: 'y',
+            choices: [
+                { key: 'y', name: 'Yes - continue', value: 'continue' },
+                { key: 'n', name: 'No - exit', value: 'quit' },
+                { key: 's', name: 'Skip - skip this step', value: 'skip' },
+                { key: 'q', name: 'Quit - exit pipeline', value: 'quit' },
+            ],
+        },
+    ]);
+    return action;
+}
+export async function handleConfirm(config) {
+    const result = await confirm(config);
+    if (result === ConfirmResult.Quit) {
+        console.log('\nPipeline cancelled by user.');
+        process.exit(0);
+    }
+    // Continue or Skip both mean proceed
+    return true;
+}

package/dist/steps/branchManagement.d.ts

@@ -0,0 +1,9 @@
+import { type BranchAnalysis } from '../utils/branchAnalyzer.js';
+import type { Config } from '../config.js';
+export interface BranchResult {
+    success: boolean;
+    branchCreated: boolean;
+    branchName: string;
+    analysis: BranchAnalysis | null;
+}
+export declare function stepBranchManagement(config: Config): Promise<BranchResult>;

package/dist/steps/branchManagement.js

@@ -0,0 +1,56 @@
+import { logStep, logInfo, logSuccess, logWarning, logDryRun } from '../logger.js';
+import { getGitState, branchExists, createBranch, findSimilarBranches } from '../utils/git.js';
+import { analyzeRequirement } from '../utils/branchAnalyzer.js';
+function createResult(branchName, analysis = null, branchCreated = false) {
+    return { success: true, branchCreated, branchName, analysis };
+}
+export async function stepBranchManagement(config) {
+    logStep('1/8', 'SMART BRANCH MANAGEMENT');
+    if (config.skipBranchManagement) {
+        logInfo('Branch management skipped (--skip-branch-management)');
+        return createResult('');
+    }
+    const gitState = getGitState();
+    logInfo(`Current branch: ${gitState.currentBranch}`);
+    if (!gitState.isMainBranch) {
+        logInfo(`Already on branch '${gitState.currentBranch}' - skipping branch creation`);
+        return createResult(gitState.currentBranch);
+    }
+    logInfo('On main branch - analyzing requirement...');
+    // Analyze requirement to determine change type
+    const analysis = await analyzeRequirement(config.requirement, config);
+    logInfo(`Change type: ${analysis.changeType}`);
+    logInfo(`Suggested branch: ${analysis.suggestedBranchName}`);
+    if (analysis.isTrivial) {
+        logInfo('Trivial change detected - staying on current branch');
+        return createResult(gitState.currentBranch, analysis);
+    }
+    // Check for similar/conflicting branches
+    const conflicts = findSimilarBranches(analysis.shortDescription, gitState.remoteBranches);
+    if (conflicts.length > 0) {
+        logWarning('Potential conflicting branches detected:');
+        for (const conflict of conflicts) {
+            logWarning(`  - ${conflict.branchName} (${conflict.similarity})`);
+        }
+        logWarning('Consider checking these branches before proceeding');
+    }
+    // Generate unique branch name
+    let branchName = analysis.suggestedBranchName;
+    let counter = 1;
+    while (branchExists(branchName)) {
+        branchName = `${analysis.branchPrefix}/${analysis.shortDescription}-${counter}`;
+        counter++;
+    }
+    if (config.dryRun) {
+        logDryRun(`git checkout -b ${branchName}`);
+        return createResult(branchName, analysis);
+    }
+    logInfo(`Creating branch: ${branchName}`);
+    const created = createBranch(branchName);
+    if (created) {
+        logSuccess(`Switched to new branch '${branchName}'`);
+        return createResult(branchName, analysis, true);
+    }
+    logWarning(`Failed to create branch '${branchName}' - continuing on current branch`);
+    return createResult(gitState.currentBranch, analysis);
+}

package/dist/steps/changelog.d.ts

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

package/dist/steps/changelog.js

@@ -0,0 +1,26 @@
+import { logStep } from '../logger.js';
+import { runClaude } from '../claude.js';
+export async function stepChangelog(config) {
+    logStep('8/8', 'UPDATE CHANGELOG');
+    const prompt = `Update CHANGELOG.md:
+
+## Format (Keep a Changelog):
+\`\`\`markdown
+## [Unreleased]
+
+### Added
+- New features
+
+### Changed
+- Changes in existing functionality
+
+### Fixed
+- Bug fixes
+\`\`\`
+
+1. Add entry for this change under appropriate category
+2. Be concise but descriptive
+3. Commit the CHANGELOG update`;
+    const result = await runClaude({ prompt, continueConversation: true }, config);
+    return result.success;
+}

package/dist/steps/commit.d.ts

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

package/dist/steps/commit.js

@@ -0,0 +1,36 @@
+import { logStep } from '../logger.js';
+import { runClaude } from '../claude.js';
+export async function stepCommit(config) {
+    logStep('7/8', 'COMMIT CHANGES');
+    const pushInstruction = config.skipPush ? '' : 'Then push to remote.';
+    const prompt = `Commit the changes:
+
+## Commit Message Requirements (Target: 10/10):
+
+**Subject Line (max 3 pts):**
+- Imperative mood ('Add' not 'Added')
+- ≤50 characters, no trailing period
+- Format: type(scope): description
+
+**Body - WHY (max 3 pts):**
+- What problem does this solve?
+- Why was this approach chosen?
+
+**Body - WHAT (max 2 pts):**
+- Key technical changes
+- Files/components affected
+
+**Structure (max 2 pts):**
+- Blank line after subject
+- Body wrapped at 72 chars
+
+## Tasks:
+1. Stage relevant files (git add)
+2. Commit with excellent message
+
+Do not add any attribution or co author by.
+
+${pushInstruction}`;
+    const result = await runClaude({ prompt, continueConversation: true }, config);
+    return result.success;
+}

package/dist/steps/implement.d.ts

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

package/dist/steps/implement.js

@@ -0,0 +1,15 @@
+import { logStep } from '../logger.js';
+import { runClaude } from '../claude.js';
+export async function stepImplement(config) {
+    logStep('2/8', '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);
+    return result.success;
+}

package/dist/steps/index.d.ts

@@ -0,0 +1,8 @@
+export { stepBranchManagement, type BranchResult } from './branchManagement.js';
+export { stepImplement } from './implement.js';
+export { stepSimplify } from './simplify.js';
+export { stepReview, type ReviewResult } from './review.js';
+export { stepSolidCleanCode } from './solid.js';
+export { stepTest } from './test.js';
+export { stepCommit } from './commit.js';
+export { stepChangelog } from './changelog.js';

package/dist/steps/index.js

@@ -0,0 +1,8 @@
+export { stepBranchManagement } from './branchManagement.js';
+export { stepImplement } from './implement.js';
+export { stepSimplify } from './simplify.js';
+export { stepReview } from './review.js';
+export { stepSolidCleanCode } from './solid.js';
+export { stepTest } from './test.js';
+export { stepCommit } from './commit.js';
+export { stepChangelog } from './changelog.js';

package/dist/steps/review.d.ts

@@ -0,0 +1,6 @@
+import type { Config } from '../config.js';
+export interface ReviewResult {
+    success: boolean;
+    noIssuesFound: boolean;
+}
+export declare function stepReview(iteration: number, config: Config): Promise<ReviewResult>;

package/dist/steps/review.js

@@ -0,0 +1,37 @@
+import { logStep } from '../logger.js';
+import { runClaude } from '../claude.js';
+// Patterns that indicate no issues were found during review
+const NO_ISSUES_PATTERNS = [
+    /no\s+issues?\s+(found|detected|identified)/i,
+    /code\s+(is\s+)?clean/i,
+    /lgtm/i,
+    /looks\s+good(\s+to\s+me)?/i,
+    /no\s+(changes|modifications)\s+(needed|required|necessary)/i,
+    /nothing\s+to\s+(fix|change|improve)/i,
+    /all\s+(checks\s+)?pass(ed)?/i,
+    /code\s+quality\s+(is\s+)?(good|excellent|solid)/i,
+];
+function detectNoIssues(output) {
+    return NO_ISSUES_PATTERNS.some((pattern) => pattern.test(output));
+}
+export async function stepReview(iteration, config) {
+    logStep('4/8', `CODE REVIEW (Round ${iteration}/${config.reviewIterations})`);
+    const prompt = `Review and improve the changes:
+
+## Critical Review Points:
+1. **Bugs**: Logic errors, off-by-one, null refs, race conditions
+2. **Security**: Input validation, injection, auth issues
+3. **Performance**: N+1 queries, unnecessary loops, memory leaks
+4. **Maintainability**: Code clarity, naming, complexity
+
+## Action Required:
+- FIX any issues found immediately
+- Be specific about what you changed and why
+- If code is clean, say "No issues found" or "LGTM"`;
+    const result = await runClaude({ prompt, continueConversation: true }, config);
+    const noIssuesFound = result.success && detectNoIssues(result.output);
+    return {
+        success: result.success,
+        noIssuesFound,
+    };
+}

package/dist/steps/simplify.d.ts

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

package/dist/steps/simplify.js

@@ -0,0 +1,47 @@
+import { logStep } from '../logger.js';
+import { runClaude } from '../claude.js';
+export async function stepSimplify(config) {
+    logStep('3/8', 'CODE SIMPLIFICATION');
+    const prompt = `Refine the recently modified code for clarity, consistency, and maintainability while preserving all functionality.
+
+## Core Principles:
+
+### 1. Functionality Preservation
+- Never change what the code does - only how it does it
+- All original features, outputs, and behaviors must remain intact
+
+### 2. Project Standards Alignment
+- Follow ES modules and project conventions
+- Prefer \`function\` declarations over arrow functions for top-level functions
+- Use explicit return type annotations
+- Maintain established naming conventions
+
+### 3. Clarity Enhancement
+- Reducing unnecessary complexity and nesting
+- Eliminating redundant code and abstractions
+- Improving readability through clear variable and function names
+- Consolidating related logic
+- Removing unnecessary comments that describe obvious code
+- IMPORTANT: Avoid nested ternary operators - prefer switch statements or if/else chains for multiple conditions
+- Choose clarity over brevity - explicit code is often better than overly compact code
+
+### 4. Balanced Approach
+- Avoid over-simplification that could reduce maintainability
+- Don't create overly clever solutions
+- Don't combine too many concerns into single functions
+
+### 5. Scoped Focus
+- Target the recently modified code sections
+- Don't refactor unrelated code unless explicitly requested
+
+## Actions:
+1. IDENTIFY opportunities for simplification in recently modified code
+2. APPLY refinements that improve readability without changing behavior
+3. VERIFY all functionality is preserved
+4. EXPLAIN significant changes made
+
+You operate autonomously and proactively, refining code immediately after it's written or modified without requiring explicit requests. Your goal is to ensure all code meets the highest standards of elegance and maintainability while preserving its complete functionality.
+`;
+    const result = await runClaude({ prompt, continueConversation: true }, config);
+    return result.success;
+}

package/dist/steps/solid.d.ts

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

package/dist/steps/solid.js

@@ -0,0 +1,53 @@
+import { logStep } from '../logger.js';
+import { runClaude } from '../claude.js';
+export async function stepSolidCleanCode(config) {
+    logStep('5/8', 'SOLID PRINCIPLES & CLEAN CODE');
+    const prompt = `Review the code for SOLID principles and Clean Code compliance:
+
+## SOLID Principles:
+
+### S - Single Responsibility
+- Each class/function has ONE reason to change
+- Split classes doing multiple things
+
+### O - Open/Closed
+- Open for extension, closed for modification
+- Replace switch/if-else chains with polymorphism
+
+### L - Liskov Substitution
+- Subtypes must be substitutable for base types
+- Prefer composition over inheritance when appropriate
+
+### I - Interface Segregation
+- Small, focused interfaces
+- Clients should not depend on unused methods
+
+### D - Dependency Inversion
+- Depend on abstractions, not concretions
+- Inject dependencies, dont hard-code them
+
+## Clean Code Checklist:
+
+**Naming:**
+- [ ] Intention-revealing names
+- [ ] Pronounceable, searchable names
+- [ ] Class=nouns, Methods=verbs, Booleans=questions
+
+**Functions:**
+- [ ] Small (<20 lines), single purpose
+- [ ] Max 3 params (wrap in object if more)
+- [ ] No side effects, no null returns
+
+**Code Smells to Fix:**
+- [ ] Magic numbers → named constants
+- [ ] Deep nesting → early returns/extraction
+- [ ] Duplicate code → DRY refactor
+- [ ] Long methods → extract smaller functions
+
+## Actions:
+1. IDENTIFY all violations
+2. REFACTOR to fix each issue
+3. EXPLAIN your changes`;
+    const result = await runClaude({ prompt, continueConversation: true }, config);
+    return result.success;
+}

package/dist/steps/test.d.ts

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

package/dist/steps/test.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { logStep } from '../logger.js';
+import { runClaude } from '../claude.js';
+export async function stepTest(config) {
+    logStep('6/8', 'TESTING');
+    if (config.skipTests) {
+        console.log(chalk.yellow('[SKIPPED]') + ' Testing step skipped via configuration');
+        return true;
+    }
+    const prompt = `Testing phase:
+
+1. **Run existing tests** - Fix any failures
+2. **Add new tests** for changed code:
+   - Happy path tests
+   - Edge cases
+   - Error conditions
+3. **Verify coverage** - Ensure critical paths are tested
+4. **Final test run** - All tests must pass
+
+Report: tests run, passed, failed, new tests added`;
+    const result = await runClaude({ prompt, continueConversation: true }, config);
+    return result.success;
+}

package/dist/utils/branchAnalyzer.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '../config.js';
+export type ChangeType = 'feature' | 'fix' | 'refactor' | 'docs' | 'chore' | 'trivial';
+export interface BranchAnalysis {
+    changeType: ChangeType;
+    isTrivial: boolean;
+    suggestedBranchName: string;
+    branchPrefix: string;
+    shortDescription: string;
+}
+export declare function analyzeRequirement(requirement: string, config: Config): Promise<BranchAnalysis>;

package/dist/utils/branchAnalyzer.js

@@ -0,0 +1,105 @@
+import { spawn } from 'child_process';
+const MAX_DESCRIPTION_LENGTH = 40;
+function sanitizeDescription(input) {
+    return input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .substring(0, MAX_DESCRIPTION_LENGTH);
+}
+const ANALYSIS_PROMPT = `Analyze the following requirement and determine the type of change it represents.
+
+Requirement: "{REQUIREMENT}"
+
+Respond in EXACTLY this format (no markdown, no extra text):
+CHANGE_TYPE: <one of: feature, fix, refactor, docs, chore, trivial>
+IS_TRIVIAL: <true or false>
+SHORT_DESC: <2-4 word kebab-case description for branch name>
+
+Guidelines:
+- feature = new functionality being added
+- fix = bug fix or error correction
+- refactor = code restructuring without changing behavior
+- docs = documentation changes only
+- chore = maintenance tasks (deps, config, build)
+- trivial = tiny changes like typo fixes, single-line changes
+
+IS_TRIVIAL should be true only for very minor changes that don't need a branch.
+SHORT_DESC should be suitable for a branch name like "feature/SHORT_DESC"`;
+const DEFAULT_ANALYSIS = {
+    changeType: 'feature',
+    isTrivial: false,
+    suggestedBranchName: 'feature/changes',
+    branchPrefix: 'feature',
+    shortDescription: 'changes',
+};
+function parseAnalysisResponse(output) {
+    const lines = output.split('\n').filter((line) => line.trim());
+    let changeType = 'feature';
+    let isTrivial = false;
+    let shortDescription = 'changes';
+    for (const line of lines) {
+        const changeMatch = line.match(/CHANGE_TYPE:\s*(feature|fix|refactor|docs|chore|trivial)/i);
+        if (changeMatch) {
+            changeType = changeMatch[1].toLowerCase();
+        }
+        const trivialMatch = line.match(/IS_TRIVIAL:\s*(true|false)/i);
+        if (trivialMatch) {
+            isTrivial = trivialMatch[1].toLowerCase() === 'true';
+        }
+        const descMatch = line.match(/SHORT_DESC:\s*(.+)/i);
+        if (descMatch) {
+            shortDescription = sanitizeDescription(descMatch[1]);
+        }
+    }
+    const branchPrefix = changeType === 'trivial' ? 'chore' : changeType;
+    return {
+        changeType,
+        isTrivial,
+        suggestedBranchName: `${branchPrefix}/${shortDescription}`,
+        branchPrefix,
+        shortDescription,
+    };
+}
+export async function analyzeRequirement(requirement, config) {
+    const prompt = ANALYSIS_PROMPT.replace('{REQUIREMENT}', requirement);
+    const args = ['--print'];
+    if (config.dangerouslySkipPermissions) {
+        args.push('--dangerously-skip-permissions');
+    }
+    args.push(prompt);
+    if (config.dryRun) {
+        return {
+            ...DEFAULT_ANALYSIS,
+            suggestedBranchName: 'feature/dry-run-changes',
+            shortDescription: 'dry-run-changes',
+        };
+    }
+    return new Promise((resolve) => {
+        let output = '';
+        const child = spawn('claude', args, {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        if (child.stdout) {
+            child.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+        }
+        child.on('close', (exitCode) => {
+            if (exitCode === 0) {
+                const analysis = parseAnalysisResponse(output);
+                if (analysis) {
+                    resolve(analysis);
+                    return;
+                }
+            }
+            resolve(DEFAULT_ANALYSIS);
+        });
+        child.on('error', () => {
+            resolve(DEFAULT_ANALYSIS);
+        });
+    });
+}

package/dist/utils/git.d.ts

@@ -0,0 +1,19 @@
+export interface GitState {
+    currentBranch: string;
+    isMainBranch: boolean;
+    hasUncommittedChanges: boolean;
+    remoteBranches: string[];
+}
+export interface BranchConflict {
+    branchName: string;
+    similarity: string;
+}
+export declare function getCurrentBranch(): string;
+export declare function isMainBranch(branchName: string): boolean;
+export declare function hasUncommittedChanges(): boolean;
+export declare function getRemoteBranches(): string[];
+export declare function getGitState(): GitState;
+export declare function branchExists(branchName: string): boolean;
+export declare function createBranch(branchName: string): boolean;
+export declare function findSimilarBranches(keyword: string, remoteBranches: string[]): BranchConflict[];
+export declare function generateBranchName(prefix: string, description: string): string;

package/dist/utils/git.js

@@ -0,0 +1,86 @@
+import { execSync } from 'child_process';
+const MAX_BRANCH_NAME_LENGTH = 40;
+const MAIN_BRANCH_NAMES = ['main', 'master', 'develop', 'dev'];
+function execGit(command) {
+    try {
+        return execSync(`git ${command}`, { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+export function getCurrentBranch() {
+    return execGit('symbolic-ref --short HEAD') || execGit('rev-parse --short HEAD');
+}
+export function isMainBranch(branchName) {
+    return MAIN_BRANCH_NAMES.includes(branchName.toLowerCase());
+}
+export function hasUncommittedChanges() {
+    const status = execGit('status --porcelain');
+    return status.length > 0;
+}
+export function getRemoteBranches() {
+    const output = execGit('branch -r');
+    if (!output)
+        return [];
+    return output
+        .split('\n')
+        .map((b) => b.trim().replace(/^origin\//, ''))
+        .filter((b) => b && !b.includes('HEAD'));
+}
+export function getGitState() {
+    const currentBranch = getCurrentBranch();
+    return {
+        currentBranch,
+        isMainBranch: isMainBranch(currentBranch),
+        hasUncommittedChanges: hasUncommittedChanges(),
+        remoteBranches: getRemoteBranches(),
+    };
+}
+export function branchExists(branchName) {
+    const localBranches = execGit('branch --list');
+    const remoteBranches = getRemoteBranches();
+    const localList = localBranches.split('\n').map((b) => b.trim().replace(/^\*\s*/, ''));
+    return localList.includes(branchName) || remoteBranches.includes(branchName);
+}
+export function createBranch(branchName) {
+    // Validate branch name to prevent command injection
+    if (!/^[a-zA-Z0-9/_-]+$/.test(branchName)) {
+        return false;
+    }
+    try {
+        execSync(`git checkout -b ${branchName}`, { encoding: 'utf-8' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function findSimilarBranches(keyword, remoteBranches) {
+    const normalizedKeyword = keyword.toLowerCase();
+    if (!normalizedKeyword) {
+        return [];
+    }
+    const conflicts = [];
+    for (const branch of remoteBranches) {
+        const normalizedBranch = branch.toLowerCase();
+        const branchSuffix = normalizedBranch.split('/').pop() || '';
+        if (normalizedBranch.includes(normalizedKeyword) || (branchSuffix && normalizedKeyword.includes(branchSuffix))) {
+            conflicts.push({
+                branchName: branch,
+                similarity: 'keyword match',
+            });
+        }
+    }
+    return conflicts;
+}
+export function generateBranchName(prefix, description) {
+    const kebab = description
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, MAX_BRANCH_NAME_LENGTH);
+    return `${prefix}/${kebab}`;
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "software-engineer",
+  "version": "0.1.10",
+  "description": "Software Factory Pipeline - Automate development workflow with Claude AI",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "sf": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "claude",
+    "ai",
+    "pipeline",
+    "automation",
+    "development",
+    "code-review"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ]
+}