software-engineer 0.1.10 → 0.1.13

package/dist/config.d.ts

@@ -7,6 +7,7 @@ export interface Config {
     skipBranchManagement: boolean;
     dangerouslySkipPermissions: boolean;
     requirement: string;
+    adaptiveExecution: boolean;
 }
 export declare function loadConfigFromEnv(): Partial<Config>;
 export declare function mergeConfig(envConfig: Partial<Config>, cliConfig: Partial<Config>): Config;

package/dist/config.js

@@ -19,6 +19,7 @@ export function loadConfigFromEnv() {
         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),
+        adaptiveExecution: parseBoolEnv(process.env.SF_ADAPTIVE_EXECUTION, false),
     };
 }
 export function mergeConfig(envConfig, cliConfig) {
@@ -31,5 +32,6 @@ export function mergeConfig(envConfig, cliConfig) {
         skipBranchManagement: cliConfig.skipBranchManagement ?? envConfig.skipBranchManagement ?? false,
         dangerouslySkipPermissions: cliConfig.dangerouslySkipPermissions ?? envConfig.dangerouslySkipPermissions ?? false,
         requirement: cliConfig.requirement ?? '',
+        adaptiveExecution: cliConfig.adaptiveExecution ?? envConfig.adaptiveExecution ?? false,
     };
 }

package/dist/index.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { loadConfigFromEnv, mergeConfig } from './config.js';
 import { runPipeline } from './pipeline.js';
+import { checkForUpdates } from './utils/updateNotifier.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
@@ -17,12 +18,15 @@ program
     .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('-a, --adaptive', 'Enable adaptive step execution (AI decides which steps to skip)')
     .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) => {
+    // Check for updates (non-blocking, fails silently)
+    await checkForUpdates(pkg.name, pkg.version).catch(() => { });
     const envConfig = loadConfigFromEnv();
     const cliConfig = {
         requirement,
@@ -33,6 +37,7 @@ program
         skipBranchManagement: options.skipBranchManagement ?? undefined,
         logFile: options.log ?? undefined,
         dangerouslySkipPermissions: options.dangerouslySkipPermissions ?? undefined,
+        adaptiveExecution: options.adaptive ?? undefined,
     };
     const config = mergeConfig(envConfig, cliConfig);
     if (!config.requirement) {

package/dist/logger.js

@@ -1,5 +1,8 @@
 import chalk from 'chalk';
 import { appendFileSync } from 'fs';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
 const BOX_WIDTH = 62;
 let logFilePath;
 export function setLogFile(path) {
@@ -40,7 +43,14 @@ 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('║'));
+    const title = `SOFTWARE FACTORY PIPELINE v${pkg.version}`;
+    const padding = Math.floor((BOX_WIDTH - title.length) / 2);
+    const titleLine = ' '.repeat(padding) + title + ' '.repeat(BOX_WIDTH - padding - title.length);
+    console.log(chalk.green('║') + titleLine + chalk.green('║'));
+    const author = 'Built by Muthukrishnan';
+    const authorPadding = Math.floor((BOX_WIDTH - author.length) / 2);
+    const authorLine = ' '.repeat(authorPadding) + author + ' '.repeat(BOX_WIDTH - authorPadding - author.length);
+    console.log(chalk.green('║') + chalk.dim(authorLine) + 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('║'));

package/dist/pipeline.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { log, logHeader, setLogFile } from './logger.js';
+import { log, logHeader, setLogFile, logInfo } from './logger.js';
 import { stepBranchManagement, stepImplement, stepSimplify, stepReview, stepSolidCleanCode, stepTest, stepCommit, stepChangelog, } from './steps/index.js';
 let signalHandlersRegistered = false;
 export async function runPipeline(config) {
@@ -22,48 +22,73 @@ export async function runPipeline(config) {
     // Display header
     logHeader(config);
     log(`Starting pipeline for: ${config.requirement}`);
-    // Step 1: Smart Branch Management
+    // Step 1: Smart Branch Management (also performs adaptive analysis if enabled)
     const branchResult = await stepBranchManagement(config);
     if (!branchResult.success) {
         console.log(chalk.red('\nBranch management step failed. Exiting.'));
         process.exit(1);
     }
+    // Extract adaptive analysis for step decisions
+    const adaptive = branchResult.adaptiveAnalysis;
+    const rec = adaptive?.stepRecommendation;
     // 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 3: Simplify (can be skipped by adaptive execution)
+    if (rec?.skipSimplify) {
+        logInfo('Simplify step skipped (adaptive execution)');
     }
-    // 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.'));
+    else {
+        const simplifySuccess = await stepSimplify(config);
+        if (!simplifySuccess) {
+            console.log(chalk.red('\nSimplification 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 4: Review loop (can be skipped or adjusted by adaptive execution)
+    if (rec?.skipReview) {
+        logInfo('Review step skipped (adaptive execution)');
+    }
+    else {
+        const reviewIterations = rec?.reviewIterations ?? config.reviewIterations;
+        for (let i = 1; i <= reviewIterations; i++) {
+            const reviewResult = await stepReview(i, config, rec?.reviewDepth);
+            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 5: SOLID & Clean Code (can be skipped by adaptive execution)
+    if (rec?.skipSolid) {
+        logInfo('SOLID review step skipped (adaptive execution)');
     }
-    // Step 6: Test
-    const testSuccess = await stepTest(config);
-    if (!testSuccess) {
-        console.log(chalk.red('\nTest step failed. Exiting.'));
-        process.exit(1);
+    else {
+        const solidSuccess = await stepSolidCleanCode(config);
+        if (!solidSuccess) {
+            console.log(chalk.red('\nSOLID review step failed. Exiting.'));
+            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;
+    if (skipTestsReason) {
+        logInfo(`Test step skipped (${skipTestsReason})`);
+    }
+    else {
+        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);
@@ -71,11 +96,16 @@ export async function runPipeline(config) {
         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);
+    // Step 8: Changelog (can be skipped by adaptive execution)
+    if (rec?.skipChangelog) {
+        logInfo('Changelog step skipped (adaptive execution)');
+    }
+    else {
+        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/steps/branchManagement.d.ts

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

package/dist/steps/branchManagement.js

@@ -1,29 +1,81 @@
 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 };
+import { analyzeSteps } from '../utils/stepAnalyzer.js';
+function createResult(branchName, analysis = null, branchCreated = false, adaptiveAnalysis = null) {
+    return { success: true, branchCreated, branchName, analysis, adaptiveAnalysis };
+}
+function logAdaptiveAnalysis(analysis) {
+    const { complexity, riskLevel, affectedAreas, stepRecommendation: rec } = analysis;
+    logInfo(`Complexity: ${complexity}, Risk: ${riskLevel}`);
+    logInfo(`Affected areas: ${affectedAreas.join(', ')}`);
+    const skipMap = [
+        [rec.skipSimplify, 'simplify'],
+        [rec.skipReview, 'review'],
+        [rec.skipSolid, 'SOLID'],
+        [rec.skipTests, 'tests'],
+        [rec.skipChangelog, 'changelog'],
+    ];
+    const skipped = skipMap.filter(([skip]) => skip).map(([, name]) => name);
+    if (skipped.length > 0) {
+        logInfo(`Steps to skip: ${skipped.join(', ')}`);
+    }
+    else {
+        logInfo('All steps will be executed');
+    }
+    const iterationLabel = rec.reviewIterations === 1 ? 'iteration' : 'iterations';
+    logInfo(`Review depth: ${rec.reviewDepth} (${rec.reviewIterations} ${iterationLabel})`);
+    logInfo(`Reasoning: ${rec.reasoning}`);
+}
+async function performAdaptiveAnalysis(config) {
+    logInfo('Adaptive execution enabled - analyzing step requirements...');
+    const analysis = await analyzeSteps(config.requirement, config);
+    logAdaptiveAnalysis(analysis);
+    return analysis;
+}
+function branchMatchesRequirement(currentBranch, analysis) {
+    const currentLower = currentBranch.toLowerCase();
+    const suggestedLower = analysis.shortDescription.toLowerCase();
+    // Extract keywords from both branches
+    const currentKeywords = currentLower.split(/[-_/]/).filter((k) => k.length > 2);
+    const suggestedKeywords = suggestedLower.split(/[-_/]/).filter((k) => k.length > 2);
+    // Check if any significant keywords overlap
+    const overlap = currentKeywords.some((ck) => suggestedKeywords.some((sk) => ck.includes(sk) || sk.includes(ck)));
+    // Also check if the branch prefix matches the change type
+    const prefixMatches = currentLower.startsWith(analysis.branchPrefix);
+    return overlap || (prefixMatches && suggestedKeywords.length === 0);
 }
 export async function stepBranchManagement(config) {
     logStep('1/8', 'SMART BRANCH MANAGEMENT');
+    const adaptiveAnalysis = config.adaptiveExecution ? await performAdaptiveAnalysis(config) : null;
     if (config.skipBranchManagement) {
         logInfo('Branch management skipped (--skip-branch-management)');
-        return createResult('');
+        return createResult('', null, false, adaptiveAnalysis);
     }
     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
+    // Always analyze the requirement first
+    logInfo('Analyzing requirement...');
     const analysis = await analyzeRequirement(config.requirement, config);
     logInfo(`Change type: ${analysis.changeType}`);
     logInfo(`Suggested branch: ${analysis.suggestedBranchName}`);
+    if (!gitState.isMainBranch) {
+        // Check if current branch matches the requirement
+        if (branchMatchesRequirement(gitState.currentBranch, analysis)) {
+            logInfo(`Current branch '${gitState.currentBranch}' matches requirement - continuing`);
+            return createResult(gitState.currentBranch, analysis, false, adaptiveAnalysis);
+        }
+        // Branch doesn't match - warn and suggest switching
+        logWarning(`Current branch '${gitState.currentBranch}' may not match this requirement`);
+        logWarning(`Suggested branch for this requirement: ${analysis.suggestedBranchName}`);
+        logWarning('Consider switching to main and re-running, or use --skip-branch-management to continue');
+        // Continue on current branch but flag the mismatch
+        return createResult(gitState.currentBranch, analysis, false, adaptiveAnalysis);
+    }
+    // On main branch
     if (analysis.isTrivial) {
         logInfo('Trivial change detected - staying on current branch');
-        return createResult(gitState.currentBranch, analysis);
+        return createResult(gitState.currentBranch, analysis, false, adaptiveAnalysis);
     }
     // Check for similar/conflicting branches
     const conflicts = findSimilarBranches(analysis.shortDescription, gitState.remoteBranches);
@@ -43,14 +95,14 @@ export async function stepBranchManagement(config) {
     }
     if (config.dryRun) {
         logDryRun(`git checkout -b ${branchName}`);
-        return createResult(branchName, analysis);
+        return createResult(branchName, analysis, false, adaptiveAnalysis);
     }
     logInfo(`Creating branch: ${branchName}`);
     const created = createBranch(branchName);
     if (created) {
         logSuccess(`Switched to new branch '${branchName}'`);
-        return createResult(branchName, analysis, true);
+        return createResult(branchName, analysis, true, adaptiveAnalysis);
     }
     logWarning(`Failed to create branch '${branchName}' - continuing on current branch`);
-    return createResult(gitState.currentBranch, analysis);
+    return createResult(gitState.currentBranch, analysis, false, adaptiveAnalysis);
 }

package/dist/steps/index.d.ts

@@ -1,7 +1,7 @@
 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 { stepReview, type ReviewResult, type ReviewDepth } from './review.js';
 export { stepSolidCleanCode } from './solid.js';
 export { stepTest } from './test.js';
 export { stepCommit } from './commit.js';

package/dist/steps/review.d.ts

@@ -3,4 +3,5 @@ export interface ReviewResult {
     success: boolean;
     noIssuesFound: boolean;
 }
-export declare function stepReview(iteration: number, config: Config): Promise<ReviewResult>;
+export type ReviewDepth = 'minimal' | 'standard' | 'thorough';
+export declare function stepReview(iteration: number, config: Config, depth?: ReviewDepth): Promise<ReviewResult>;

package/dist/steps/review.js

@@ -14,9 +14,37 @@ const NO_ISSUES_PATTERNS = [
 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:
+function getPromptForDepth(depth) {
+    switch (depth) {
+        case 'minimal':
+            return `Quick review of the changes:
+
+## Focus Areas:
+1. **Bugs**: Only obvious logic errors or crashes
+2. **Security**: Only critical vulnerabilities
+
+## Action Required:
+- FIX only critical issues
+- If code is acceptable, say "No issues found" or "LGTM"`;
+        case 'thorough':
+            return `Thorough code review of all changes:
+
+## Comprehensive Review Points:
+1. **Bugs**: Logic errors, edge cases, off-by-one, null refs, race conditions, error handling
+2. **Security**: Input validation, injection, auth issues, data exposure, OWASP top 10
+3. **Performance**: N+1 queries, unnecessary loops, memory leaks, blocking operations, caching
+4. **Maintainability**: Code clarity, naming, complexity, duplication, single responsibility
+5. **Testing**: Are edge cases testable? Missing test scenarios?
+6. **Architecture**: Does this follow project patterns? Any coupling issues?
+
+## Action Required:
+- FIX any issues found immediately
+- Be thorough and specific about what you changed and why
+- Suggest improvements even if not critical
+- If code is clean, say "No issues found" or "LGTM"`;
+        case 'standard':
+        default:
+            return `Review and improve the changes:
 
 ## Critical Review Points:
 1. **Bugs**: Logic errors, off-by-one, null refs, race conditions
@@ -28,6 +56,12 @@ export async function stepReview(iteration, config) {
 - FIX any issues found immediately
 - Be specific about what you changed and why
 - If code is clean, say "No issues found" or "LGTM"`;
+    }
+}
+export async function stepReview(iteration, config, depth = 'standard') {
+    const depthLabel = depth !== 'standard' ? ` [${depth}]` : '';
+    logStep('4/8', `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);
     return {

package/dist/utils/stepAnalyzer.d.ts

@@ -0,0 +1,21 @@
+import type { Config } from '../config.js';
+import type { ChangeType } from './branchAnalyzer.js';
+export interface StepRecommendation {
+    skipSimplify: boolean;
+    skipReview: boolean;
+    skipSolid: boolean;
+    skipTests: boolean;
+    skipChangelog: boolean;
+    reviewDepth: 'minimal' | 'standard' | 'thorough';
+    reviewIterations: number;
+    reasoning: string;
+}
+export interface AdaptiveAnalysis {
+    changeType: ChangeType;
+    isTrivial: boolean;
+    complexity: 'low' | 'medium' | 'high';
+    riskLevel: 'low' | 'medium' | 'high';
+    affectedAreas: string[];
+    stepRecommendation: StepRecommendation;
+}
+export declare function analyzeSteps(requirement: string, config: Config): Promise<AdaptiveAnalysis>;

package/dist/utils/stepAnalyzer.js

@@ -0,0 +1,141 @@
+import { spawn } from 'child_process';
+const MIN_REVIEW_ITERATIONS = 1;
+const MAX_REVIEW_ITERATIONS = 3;
+const DEFAULT_REVIEW_ITERATIONS = 2;
+const ADAPTIVE_ANALYSIS_PROMPT = `Analyze the following requirement and determine which pipeline steps should be executed.
+
+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>
+COMPLEXITY: <one of: low, medium, high>
+RISK_LEVEL: <one of: low, medium, high>
+AFFECTED_AREAS: <comma-separated list: code, tests, config, docs, build, deps>
+SKIP_SIMPLIFY: <true or false>
+SKIP_REVIEW: <true or false>
+SKIP_SOLID: <true or false>
+SKIP_TESTS: <true or false>
+SKIP_CHANGELOG: <true or false>
+REVIEW_DEPTH: <one of: minimal, standard, thorough>
+REVIEW_ITERATIONS: <1, 2, or 3>
+REASONING: <brief one-line explanation for the recommendations>
+
+Guidelines for step skipping:
+- Documentation-only changes (docs): skip tests, simplify, and SOLID review
+- Config file changes (chore for config): skip SOLID review, reduce review iterations
+- Typo fixes or trivial changes: skip most steps, minimal review
+- Refactoring with no behavior change: reduce test focus, thorough SOLID review
+- New features with business logic: all steps, thorough review
+- Bug fixes: standard review, focus on tests
+- Build/CI changes: skip SOLID, skip tests unless test config changed
+
+Risk assessment:
+- Low: docs, typos, comments, formatting
+- Medium: config changes, refactoring, minor features
+- High: new features with business logic, bug fixes, dependency changes, security-related
+
+Complexity assessment:
+- Low: single file, few lines, isolated change
+- Medium: multiple files, moderate scope
+- High: many files, architectural impact, complex logic`;
+const DEFAULT_STEP_RECOMMENDATION = {
+    skipSimplify: false,
+    skipReview: false,
+    skipSolid: false,
+    skipTests: false,
+    skipChangelog: false,
+    reviewDepth: 'standard',
+    reviewIterations: DEFAULT_REVIEW_ITERATIONS,
+    reasoning: 'Default configuration - standard pipeline execution',
+};
+const DEFAULT_ADAPTIVE_ANALYSIS = {
+    changeType: 'feature',
+    isTrivial: false,
+    complexity: 'medium',
+    riskLevel: 'medium',
+    affectedAreas: ['code'],
+    stepRecommendation: DEFAULT_STEP_RECOMMENDATION,
+};
+function extractField(output, field, pattern) {
+    const regex = new RegExp(`${field}:\\s*(${pattern})`, 'i');
+    const match = output.match(regex);
+    return match ? match[1].toLowerCase() : null;
+}
+function extractBool(output, field) {
+    const value = extractField(output, field, 'true|false');
+    return value !== null ? value === 'true' : null;
+}
+function parseAdaptiveResponse(output) {
+    const changeType = extractField(output, 'CHANGE_TYPE', 'feature|fix|refactor|docs|chore|trivial') ?? 'feature';
+    const isTrivial = extractBool(output, 'IS_TRIVIAL') ?? false;
+    const complexity = extractField(output, 'COMPLEXITY', 'low|medium|high') ?? 'medium';
+    const riskLevel = extractField(output, 'RISK_LEVEL', 'low|medium|high') ?? 'medium';
+    const areasMatch = output.match(/AFFECTED_AREAS:\s*(.+)/i);
+    const affectedAreas = areasMatch ? areasMatch[1].split(',').map((a) => a.trim().toLowerCase()) : ['code'];
+    const reviewDepth = extractField(output, 'REVIEW_DEPTH', 'minimal|standard|thorough') ?? 'standard';
+    const iterationsMatch = output.match(/REVIEW_ITERATIONS:\s*(\d+)/i);
+    const reviewIterations = iterationsMatch
+        ? Math.min(Math.max(parseInt(iterationsMatch[1], 10), MIN_REVIEW_ITERATIONS), MAX_REVIEW_ITERATIONS)
+        : DEFAULT_REVIEW_ITERATIONS;
+    const reasoningMatch = output.match(/REASONING:\s*(.+)/i);
+    const reasoning = reasoningMatch ? reasoningMatch[1].trim() : 'AI-analyzed step configuration';
+    return {
+        changeType,
+        isTrivial,
+        complexity,
+        riskLevel,
+        affectedAreas,
+        stepRecommendation: {
+            skipSimplify: extractBool(output, 'SKIP_SIMPLIFY') ?? false,
+            skipReview: extractBool(output, 'SKIP_REVIEW') ?? false,
+            skipSolid: extractBool(output, 'SKIP_SOLID') ?? false,
+            skipTests: extractBool(output, 'SKIP_TESTS') ?? false,
+            skipChangelog: extractBool(output, 'SKIP_CHANGELOG') ?? false,
+            reviewDepth,
+            reviewIterations,
+            reasoning,
+        },
+    };
+}
+export async function analyzeSteps(requirement, config) {
+    const prompt = ADAPTIVE_ANALYSIS_PROMPT.replace('{REQUIREMENT}', requirement);
+    const args = ['--print'];
+    if (config.dangerouslySkipPermissions) {
+        args.push('--dangerously-skip-permissions');
+    }
+    args.push(prompt);
+    if (config.dryRun) {
+        return {
+            ...DEFAULT_ADAPTIVE_ANALYSIS,
+            stepRecommendation: {
+                ...DEFAULT_STEP_RECOMMENDATION,
+                reasoning: 'Dry run mode - using default configuration',
+            },
+        };
+    }
+    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 && output.trim()) {
+                resolve(parseAdaptiveResponse(output));
+            }
+            else {
+                resolve(DEFAULT_ADAPTIVE_ANALYSIS);
+            }
+        });
+        child.on('error', () => {
+            resolve(DEFAULT_ADAPTIVE_ANALYSIS);
+        });
+    });
+}

package/dist/utils/updateNotifier.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Update notifier - checks for new versions and prompts users to update
+ */
+export declare class UpdateNotifier {
+    private packageName;
+    private currentVersion;
+    private checkInterval;
+    private cacheFile;
+    constructor(packageName: string, currentVersion: string, checkInterval?: number);
+    /**
+     * Check for updates and notify user if a new version is available.
+     */
+    notify(): Promise<void>;
+    /**
+     * Check if we should check for updates (based on cache and interval)
+     */
+    private shouldCheckForUpdates;
+    /**
+     * Fetch latest version from npm registry
+     */
+    private fetchLatestVersion;
+    /**
+     * Load version info from cache
+     */
+    private loadVersionInfo;
+    /**
+     * Save version info to cache
+     */
+    private saveVersionInfo;
+    /**
+     * Compare two semantic versions
+     */
+    private isNewerVersion;
+    /**
+     * Display update notification message
+     */
+    private displayUpdateMessage;
+    /**
+     * Detect package manager (npm, yarn, pnpm)
+     */
+    private detectPackageManager;
+    /**
+     * Center text within given width (accounts for ANSI codes)
+     */
+    private centerText;
+    /**
+     * Pad text to given width (accounts for ANSI codes)
+     */
+    private padText;
+    /**
+     * Strip ANSI escape codes from string
+     */
+    private stripAnsi;
+}
+/**
+ * Create and run update notifier
+ */
+export declare function checkForUpdates(packageName: string, currentVersion: string): Promise<void>;

package/dist/utils/updateNotifier.js

@@ -0,0 +1,194 @@
+/**
+ * Update notifier - checks for new versions and prompts users to update
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import chalk from 'chalk';
+export class UpdateNotifier {
+    packageName;
+    currentVersion;
+    checkInterval;
+    cacheFile;
+    constructor(packageName, currentVersion, checkInterval = 24 * 60 * 60 * 1000) {
+        this.packageName = packageName;
+        this.currentVersion = currentVersion;
+        this.checkInterval = checkInterval; // Default: 24 hours
+        this.cacheFile = path.join(os.tmpdir(), `.${packageName.replace('/', '-')}-update-check.json`);
+    }
+    /**
+     * Check for updates and notify user if a new version is available.
+     */
+    async notify() {
+        try {
+            const shouldCheck = await this.shouldCheckForUpdates();
+            if (shouldCheck) {
+                const latestVersion = await this.fetchLatestVersion();
+                if (latestVersion) {
+                    await this.saveVersionInfo(latestVersion);
+                    if (this.isNewerVersion(latestVersion, this.currentVersion)) {
+                        this.displayUpdateMessage(latestVersion);
+                    }
+                }
+            }
+            else {
+                const cachedInfo = await this.loadVersionInfo();
+                if (cachedInfo && this.isNewerVersion(cachedInfo.latest, this.currentVersion)) {
+                    this.displayUpdateMessage(cachedInfo.latest);
+                }
+            }
+        }
+        catch {
+            // Silently fail - don't disrupt user experience
+        }
+    }
+    /**
+     * Check if we should check for updates (based on cache and interval)
+     */
+    async shouldCheckForUpdates() {
+        try {
+            const versionInfo = await this.loadVersionInfo();
+            if (!versionInfo) {
+                return true;
+            }
+            const timeSinceLastCheck = Date.now() - versionInfo.lastChecked;
+            return timeSinceLastCheck >= this.checkInterval;
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Fetch latest version from npm registry
+     */
+    async fetchLatestVersion() {
+        try {
+            const registryUrl = `https://registry.npmjs.org/${this.packageName}/latest`;
+            const response = await fetch(registryUrl, {
+                headers: { 'Accept': 'application/json' },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const data = await response.json();
+            return data.version;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Load version info from cache
+     */
+    async loadVersionInfo() {
+        try {
+            const data = await fs.readFile(this.cacheFile, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Save version info to cache
+     */
+    async saveVersionInfo(latestVersion) {
+        const versionInfo = {
+            current: this.currentVersion,
+            latest: latestVersion,
+            lastChecked: Date.now(),
+        };
+        try {
+            await fs.writeFile(this.cacheFile, JSON.stringify(versionInfo, null, 2), 'utf-8');
+        }
+        catch {
+            // Ignore cache write errors
+        }
+    }
+    /**
+     * Compare two semantic versions
+     */
+    isNewerVersion(latest, current) {
+        const parseVersion = (version) => {
+            return version.replace(/^v/, '').split('.').map(Number);
+        };
+        const latestParts = parseVersion(latest);
+        const currentParts = parseVersion(current);
+        for (let i = 0; i < Math.max(latestParts.length, currentParts.length); i++) {
+            const latestPart = latestParts[i] || 0;
+            const currentPart = currentParts[i] || 0;
+            if (latestPart > currentPart) {
+                return true;
+            }
+            if (latestPart < currentPart) {
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Display update notification message
+     */
+    displayUpdateMessage(latestVersion) {
+        const boxWidth = 60;
+        const border = '═'.repeat(boxWidth);
+        const packageManager = this.detectPackageManager();
+        console.log('');
+        console.log(chalk.yellow(`╔${border}╗`));
+        console.log(chalk.yellow('║') + ' '.repeat(boxWidth) + chalk.yellow('║'));
+        console.log(chalk.yellow('║') + this.centerText(chalk.bold('Update Available!'), boxWidth) + chalk.yellow('║'));
+        console.log(chalk.yellow('║') + ' '.repeat(boxWidth) + chalk.yellow('║'));
+        console.log(chalk.yellow('║') + this.centerText(`${chalk.red(this.currentVersion)} → ${chalk.green(latestVersion)}`, boxWidth) + chalk.yellow('║'));
+        console.log(chalk.yellow('║') + ' '.repeat(boxWidth) + chalk.yellow('║'));
+        console.log(chalk.yellow('║') + this.padText('  Run to update:', boxWidth) + chalk.yellow('║'));
+        console.log(chalk.yellow('║') + this.padText(chalk.cyan(`    ${packageManager.global} ${this.packageName}`), boxWidth) + chalk.yellow('║'));
+        console.log(chalk.yellow('║') + ' '.repeat(boxWidth) + chalk.yellow('║'));
+        console.log(chalk.yellow(`╚${border}╝`));
+        console.log('');
+    }
+    /**
+     * Detect package manager (npm, yarn, pnpm)
+     */
+    detectPackageManager() {
+        const userAgent = process.env.npm_config_user_agent || '';
+        if (userAgent.includes('yarn')) {
+            return { global: 'yarn global add', local: 'yarn add' };
+        }
+        if (userAgent.includes('pnpm')) {
+            return { global: 'pnpm add -g', local: 'pnpm add' };
+        }
+        return { global: 'npm install -g', local: 'npm install' };
+    }
+    /**
+     * Center text within given width (accounts for ANSI codes)
+     */
+    centerText(text, width) {
+        const visibleLength = this.stripAnsi(text).length;
+        const padding = Math.max(0, width - visibleLength);
+        const leftPad = Math.floor(padding / 2);
+        const rightPad = padding - leftPad;
+        return ' '.repeat(leftPad) + text + ' '.repeat(rightPad);
+    }
+    /**
+     * Pad text to given width (accounts for ANSI codes)
+     */
+    padText(text, width) {
+        const visibleLength = this.stripAnsi(text).length;
+        return text + ' '.repeat(Math.max(0, width - visibleLength));
+    }
+    /**
+     * Strip ANSI escape codes from string
+     */
+    stripAnsi(str) {
+        // eslint-disable-next-line no-control-regex
+        return str.replace(/\x1b\[[0-9;]*m/g, '');
+    }
+}
+/**
+ * Create and run update notifier
+ */
+export async function checkForUpdates(packageName, currentVersion) {
+    const notifier = new UpdateNotifier(packageName, currentVersion);
+    await notifier.notify();
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "software-engineer",
-  "version": "0.1.10",
-  "description": "Software Factory Pipeline - Automate development workflow with Claude AI",
+  "version": "0.1.13",
+  "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",
   "bin": {
@@ -20,8 +20,16 @@
     "development",
     "code-review"
   ],
-  "author": "",
+  "author": "Muthu Krishnan",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/muthuspark/software-engineer.git"
+  },
+  "homepage": "https://github.com/muthuspark/software-engineer#readme",
+  "bugs": {
+    "url": "https://github.com/muthuspark/software-engineer/issues"
+  },
   "dependencies": {
     "chalk": "^5.3.0",
     "commander": "^12.1.0"