@ginkoai/cli 1.0.0

package/dist/commands/magic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"magic.js","sourceRoot":"","sources":["../../src/commands/magic.ts"],"names":[],"mappings":"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"}

package/dist/commands/plan/plan-reflection-pipeline.d.ts

@@ -0,0 +1,126 @@
+/**
+ * @fileType: command
+ * @status: current
+ * @updated: 2025-10-01
+ * @tags: [plan, reflection, pipeline, builder, sprint]
+ * @related: [../../core/simple-pipeline-base.ts, ../handoff/handoff-reflection-pipeline.ts]
+ * @priority: high
+ * @complexity: medium
+ * @dependencies: [simple-pipeline-base, simple-git, fs-extra]
+ */
+import { SimplePipelineBase } from '../../core/simple-pipeline-base.js';
+/**
+ * Plan Quality Definition
+ */
+export interface PlanQualityTemplate {
+    requiredSections: string[];
+    contextToConsider: string[];
+    rulesAndConstraints: string[];
+}
+/**
+ * Plan Context
+ */
+export interface PlanContext {
+    feature: string;
+    sprintDays: number;
+    adrReference?: string;
+    planId: string;
+    timestamp: string;
+    phases: Array<{
+        name: string;
+        duration: string;
+    }>;
+    recentCommits?: any[];
+    currentBranch?: string;
+    adrContent?: string;
+}
+/**
+ * Plan pipeline using Simple Builder Pattern
+ * Refactored from plan.ts standalone command to use SimplePipelineBase
+ * Implements ADR-013 for consistent pipeline architecture
+ */
+export declare class PlanReflectionPipeline extends SimplePipelineBase {
+    private git;
+    private ginkoDir;
+    private projectRoot;
+    private feature;
+    private options;
+    constructor(feature: string, options?: any);
+    /**
+     * Initialize pipeline dependencies
+     */
+    initialize(): Promise<this>;
+    /**
+     * Load plan-specific quality template
+     */
+    loadTemplate(): this;
+    /**
+     * Gather comprehensive context for planning
+     */
+    gatherContext(): Promise<this>;
+    /**
+     * Generate the planning prompt for AI
+     */
+    generatePrompt(): this;
+    /**
+     * Build the plan framework content
+     */
+    private buildPlanFramework;
+    /**
+     * Build the planning instructions for AI
+     */
+    private buildPlanInstructions;
+    /**
+     * Validate the generated output
+     */
+    validateOutput(): this;
+    /**
+     * Display the plan output
+     */
+    display(): Promise<this>;
+    /**
+     * Custom validation for plan pipeline
+     */
+    protected customValidate(): void;
+    /**
+     * Custom recovery logic
+     */
+    protected customRecover(): void;
+    /**
+     * Custom execution logic
+     */
+    protected customExecute(): Promise<void>;
+    /**
+     * Generate phases based on sprint duration
+     */
+    private generatePhases;
+    /**
+     * Find ADR reference from feature description
+     */
+    private findADRReference;
+    /**
+     * Get ADR content for context
+     */
+    private getADRContent;
+    /**
+     * Main build method using fluent interface
+     */
+    build(): Promise<string>;
+}
+/**
+ * Store sprint plan to filesystem
+ */
+export declare function storeSprintPlan(planId: string, content: string, verbose?: boolean): Promise<void>;
+/**
+ * Adapter for CLI command usage
+ * Maintains backward compatibility with existing command structure
+ */
+export declare class PlanReflectionCommand {
+    private pipeline;
+    /**
+     * Execute the plan command
+     */
+    execute(feature: string | undefined, options?: any): Promise<void>;
+}
+export default PlanReflectionCommand;
+//# sourceMappingURL=plan-reflection-pipeline.d.ts.map

package/dist/commands/plan/plan-reflection-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-reflection-pipeline.d.ts","sourceRoot":"","sources":["../../../src/commands/plan/plan-reflection-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,kBAAkB,EAAmB,MAAM,oCAAoC,CAAC;AAOzF;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClD,aAAa,CAAC,EAAE,GAAG,EAAE,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,OAAO,CAAW;gBAEd,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ;IAO9C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAWjC;;OAEG;IACH,YAAY,IAAI,IAAI;IAwCpB;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAsDpC;;OAEG;IACH,cAAc,IAAI,IAAI;IAuBtB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA8E1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA6B7B;;OAEG;IACH,cAAc,IAAI,IAAI;IA+CtB;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB9B;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;IAkBhC;;OAEG;IACH,SAAS,CAAC,aAAa,IAAI,IAAI;IAkB/B;;OAEG;cACa,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9C;;OAEG;IACH,OAAO,CAAC,cAAc;IAuBtB;;OAEG;YACW,gBAAgB;IAgC9B;;OAEG;YACW,aAAa;IAa3B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;CAiC/B;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAoD9G;AAED;;;GAGG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAuC;IAEvD;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,GAAE,GAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CA4B7E;AAGD,eAAe,qBAAqB,CAAC"}

package/dist/commands/plan/plan-reflection-pipeline.js

@@ -0,0 +1,554 @@
+/**
+ * @fileType: command
+ * @status: current
+ * @updated: 2025-10-01
+ * @tags: [plan, reflection, pipeline, builder, sprint]
+ * @related: [../../core/simple-pipeline-base.ts, ../handoff/handoff-reflection-pipeline.ts]
+ * @priority: high
+ * @complexity: medium
+ * @dependencies: [simple-pipeline-base, simple-git, fs-extra]
+ */
+import { SimplePipelineBase } from '../../core/simple-pipeline-base.js';
+import simpleGit from 'simple-git';
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import { getGinkoDir } from '../../utils/helpers.js';
+/**
+ * Plan pipeline using Simple Builder Pattern
+ * Refactored from plan.ts standalone command to use SimplePipelineBase
+ * Implements ADR-013 for consistent pipeline architecture
+ */
+export class PlanReflectionPipeline extends SimplePipelineBase {
+    git;
+    ginkoDir = '';
+    projectRoot = '';
+    feature = '';
+    options = {};
+    constructor(feature, options = {}) {
+        super(`Generate sprint plan for: ${feature}`);
+        this.feature = feature;
+        this.options = options;
+        this.withDomain('plan');
+    }
+    /**
+     * Initialize pipeline dependencies
+     */
+    async initialize() {
+        this.git = simpleGit();
+        this.ginkoDir = await getGinkoDir();
+        this.projectRoot = path.dirname(this.ginkoDir);
+        if (this.options.verbose) {
+            console.log(chalk.cyan('📋 Initializing plan pipeline...'));
+        }
+        return this;
+    }
+    /**
+     * Load plan-specific quality template
+     */
+    loadTemplate() {
+        const template = {
+            requiredSections: [
+                'overview',
+                'success_criteria',
+                'implementation_phases',
+                'dependencies',
+                'testing_strategy',
+                'rollback_plan',
+                'daily_standup_topics'
+            ],
+            contextToConsider: [
+                'feature_description',
+                'adr_reference',
+                'sprint_duration',
+                'git_history',
+                'existing_architecture',
+                'team_velocity',
+                'technical_constraints'
+            ],
+            rulesAndConstraints: [
+                'Break work into clear, measurable phases',
+                'Each task should be 0.5-4 hours (larger = break down further)',
+                'Include specific acceptance criteria',
+                'Consider team capacity and dependencies',
+                'Build in time for code review and testing (~20% overhead)',
+                'Front-load risky or blocking work',
+                'Back-load polish and nice-to-haves',
+                'Reference ADRs for architectural alignment',
+                'Include daily checkpoints for progress assessment'
+            ]
+        };
+        this.withTemplate(template);
+        if (this.options.verbose) {
+            console.log(chalk.gray('  ✓ Template loaded'));
+        }
+        return this;
+    }
+    /**
+     * Gather comprehensive context for planning
+     */
+    async gatherContext() {
+        if (this.options.verbose) {
+            console.log(chalk.cyan('🔍 Gathering context...'));
+        }
+        const planId = `plan-${Date.now()}`;
+        const sprintDays = this.options.days || 5;
+        // Try to detect if this references an ADR
+        const adrReference = await this.findADRReference(this.feature);
+        // Get ADR content if reference found
+        let adrContent;
+        if (adrReference) {
+            adrContent = await this.getADRContent(adrReference);
+        }
+        // Get git state for context
+        const recentCommits = await this.git.log({ maxCount: 10 }).catch(() => ({ all: [] }));
+        const branch = await this.git.branchLocal().catch(() => ({ current: 'main' }));
+        // Generate phases based on sprint duration
+        const phases = this.generatePhases(sprintDays);
+        const context = {
+            feature: this.feature,
+            sprintDays,
+            adrReference,
+            planId,
+            timestamp: new Date().toISOString(),
+            phases,
+            recentCommits: recentCommits.all,
+            currentBranch: branch.current,
+            adrContent
+        };
+        // Store temp context for phase 2
+        const tempPath = path.join(this.ginkoDir, '.temp', `${planId}.json`);
+        await fs.ensureDir(path.dirname(tempPath));
+        await fs.writeJson(tempPath, {
+            feature: this.feature,
+            sprintDays,
+            adrReference,
+            planId,
+            timestamp: new Date().toISOString()
+        });
+        this.withContext(context);
+        if (this.options.verbose) {
+            console.log(chalk.gray('  ✓ Context gathered'));
+        }
+        return this;
+    }
+    /**
+     * Generate the planning prompt for AI
+     */
+    generatePrompt() {
+        if (this.options.verbose) {
+            console.log(chalk.cyan('📝 Generating planning prompt...'));
+        }
+        const context = this.ctx.context;
+        const date = new Date().toISOString().split('T')[0];
+        // Build the plan framework
+        const framework = this.buildPlanFramework(context, date);
+        // Build the instructions for AI
+        const instructions = this.buildPlanInstructions(context);
+        this.ctx.content = framework + '\n' + instructions;
+        this.adjustConfidence(0.9); // High confidence after successful generation
+        if (this.options.verbose) {
+            console.log(chalk.gray('  ✓ Prompt generated'));
+        }
+        return this;
+    }
+    /**
+     * Build the plan framework content
+     */
+    buildPlanFramework(context, date) {
+        const sections = [];
+        sections.push(`# Sprint Plan: ${context.feature}`);
+        sections.push('');
+        sections.push(`## Overview`);
+        sections.push(`**Start Date**: ${date}`);
+        sections.push(`**Duration**: ${context.sprintDays} days`);
+        sections.push(`**ADR Reference**: ${context.adrReference || chalk.yellow('[AI: Link to relevant ADR if applicable]')}`);
+        if (context.adrContent) {
+            sections.push('');
+            sections.push(`### ADR Context`);
+            sections.push(chalk.dim('```'));
+            sections.push(chalk.dim(context.adrContent.substring(0, 500) + '...'));
+            sections.push(chalk.dim('```'));
+        }
+        sections.push('');
+        sections.push(`## Success Criteria`);
+        sections.push(chalk.yellow('[AI: What specific, measurable outcomes define success?]'));
+        sections.push(`- [ ] ${chalk.yellow('[AI: Acceptance criterion 1]')}`);
+        sections.push(`- [ ] ${chalk.yellow('[AI: Acceptance criterion 2]')}`);
+        sections.push(`- [ ] ${chalk.yellow('[AI: Acceptance criterion 3]')}`);
+        sections.push('');
+        sections.push(`## Implementation Phases`);
+        sections.push('');
+        context.phases.forEach((phase, i) => {
+            sections.push(`### ${phase.name}`);
+            sections.push(`**Duration**: ${phase.duration}`);
+            sections.push(`**Goal**: ${chalk.yellow(`[AI: What will be accomplished in ${phase.name}?]`)}`);
+            sections.push('');
+            sections.push(`**Tasks**:`);
+            sections.push(chalk.yellow('[AI: List specific, actionable tasks]'));
+            sections.push(`- [ ] ${chalk.yellow('[AI: Task with ~time estimate]')}`);
+            sections.push(`- [ ] ${chalk.yellow('[AI: Task with ~time estimate]')}`);
+            sections.push(`- [ ] ${chalk.yellow('[AI: Task with ~time estimate]')}`);
+            sections.push('');
+            sections.push(`**Deliverables**:`);
+            sections.push(chalk.yellow('[AI: What tangible outputs will exist after this phase?]'));
+            sections.push('');
+            sections.push(`**Risk Factors**:`);
+            sections.push(chalk.yellow('[AI: What could block or delay this phase?]'));
+            sections.push('');
+        });
+        sections.push(`## Dependencies`);
+        sections.push(chalk.yellow('[AI: What needs to be in place before starting?]'));
+        sections.push(`- ${chalk.yellow('[AI: External dependencies]')}`);
+        sections.push(`- ${chalk.yellow('[AI: Team dependencies]')}`);
+        sections.push(`- ${chalk.yellow('[AI: Technical prerequisites]')}`);
+        sections.push('');
+        sections.push(`## Testing Strategy`);
+        sections.push(chalk.yellow('[AI: How will we verify each phase?]'));
+        sections.push(`- **Unit Tests**: ${chalk.yellow('[AI: What will be unit tested?]')}`);
+        sections.push(`- **Integration Tests**: ${chalk.yellow('[AI: What integration points need testing?]')}`);
+        sections.push(`- **Manual Testing**: ${chalk.yellow('[AI: What requires manual verification?]')}`);
+        sections.push('');
+        sections.push(`## Rollback Plan`);
+        sections.push(chalk.yellow('[AI: If something goes wrong, how do we revert?]'));
+        sections.push('');
+        sections.push(`## Daily Standup Topics`);
+        Array.from({ length: context.sprintDays }, (_, i) => {
+            sections.push('');
+            sections.push(`**Day ${i + 1}**:`);
+            sections.push(`- Focus: ${chalk.yellow(`[AI: Main focus for day ${i + 1}]`)}`);
+            sections.push(`- Check: ${chalk.yellow(`[AI: What should be done by end of day ${i + 1}?]`)}`);
+            sections.push(`- Risk: ${chalk.yellow(`[AI: What could block day ${i + 2}?]`)}`);
+        });
+        return sections.join('\n');
+    }
+    /**
+     * Build the planning instructions for AI
+     */
+    buildPlanInstructions(context) {
+        return chalk.magenta(`
+Sprint Planning Instructions:
+
+This is PLANNING MODE - we're creating a concrete implementation roadmap.
+Be realistic about velocity and include buffer time.
+
+1. Break down the work into clear, measurable phases
+2. Each task should be 0.5-4 hours (larger = break down further)
+3. Include specific acceptance criteria
+4. Consider team capacity and dependencies
+5. Build in time for code review and testing
+6. Account for meetings and context switching (~20% overhead)
+
+Guidelines:
+- ${context.sprintDays} days = ~${context.sprintDays * 6} hours of focused coding time
+- Include daily checkpoints for progress assessment
+- Front-load risky or blocking work
+- Back-load polish and nice-to-haves
+
+After planning is complete, store the sprint plan:
+
+ginko plan --store --id=${context.planId} --content="[complete sprint plan]"
+
+The plan will be stored in: docs/SPRINTS/SPRINT-${new Date().toISOString().split('T')[0]}-[feature].md
+
+This plan will guide daily standups and progress tracking.`);
+    }
+    /**
+     * Validate the generated output
+     */
+    validateOutput() {
+        if (!this.ctx.content) {
+            this.addError('No plan content generated');
+            this.adjustConfidence(0.5);
+            return this;
+        }
+        const content = this.ctx.content;
+        const context = this.ctx.context;
+        // Check for required sections
+        const requiredPatterns = [
+            { name: 'Overview', pattern: /## Overview/i },
+            { name: 'Success Criteria', pattern: /## Success Criteria/i },
+            { name: 'Implementation Phases', pattern: /## Implementation Phases/i },
+            { name: 'Dependencies', pattern: /## Dependencies/i },
+            { name: 'Testing Strategy', pattern: /## Testing Strategy/i },
+            { name: 'Rollback Plan', pattern: /## Rollback Plan/i },
+            { name: 'Daily Standup Topics', pattern: /## Daily Standup Topics/i }
+        ];
+        const missing = [];
+        for (const section of requiredPatterns) {
+            if (!section.pattern.test(content)) {
+                missing.push(section.name);
+            }
+        }
+        if (missing.length > 0) {
+            this.addError(`Missing required sections: ${missing.join(', ')}`);
+            this.adjustConfidence(0.7);
+        }
+        // Check for phases
+        const phaseCount = (content.match(/### Phase \d+:/g) || []).length;
+        if (phaseCount === 0) {
+            this.addError('No implementation phases found');
+            this.adjustConfidence(0.6);
+        }
+        if (this.options.verbose) {
+            console.log(chalk.gray('  ✓ Output validated'));
+        }
+        return this;
+    }
+    /**
+     * Display the plan output
+     */
+    async display() {
+        if (!this.ctx.content) {
+            this.addError('No content to display');
+            return this;
+        }
+        const context = this.ctx.context;
+        // Output plan framework (to stdout to avoid stderr)
+        process.stdout.write(chalk.magenta('\n📋 Sprint Planning Mode') + '\n');
+        process.stdout.write(chalk.dim('─'.repeat(60)) + '\n');
+        process.stdout.write(this.ctx.content + '\n');
+        process.stdout.write(chalk.dim('─'.repeat(60)) + '\n');
+        // Ensure stdout is flushed before continuing
+        await new Promise(resolve => process.stdout.write('', resolve));
+        return this;
+    }
+    /**
+     * Custom validation for plan pipeline
+     */
+    customValidate() {
+        if (!this.ctx.template) {
+            this.addError('Template required for plan');
+            this.adjustConfidence(0.7);
+        }
+        if (!this.feature || this.feature.trim() === '') {
+            this.addError('Feature description is required');
+            this.adjustConfidence(0.5);
+        }
+        const context = this.ctx.context;
+        if (!context?.sprintDays || context.sprintDays < 1) {
+            this.addError('Invalid sprint duration');
+            this.adjustConfidence(0.6);
+        }
+    }
+    /**
+     * Custom recovery logic
+     */
+    customRecover() {
+        // If no context, create a basic one
+        if (!this.ctx.context) {
+            const planId = `plan-${Date.now()}`;
+            const sprintDays = this.options.days || 5;
+            this.ctx.context = {
+                feature: this.feature,
+                sprintDays,
+                planId,
+                timestamp: new Date().toISOString(),
+                phases: this.generatePhases(sprintDays)
+            };
+            this.removeError('No context available');
+            this.adjustConfidence(1.1); // Slight boost after recovery
+        }
+    }
+    /**
+     * Custom execution logic
+     */
+    async customExecute() {
+        // Ensure we have content
+        if (!this.ctx.content) {
+            this.generatePrompt();
+        }
+    }
+    /**
+     * Generate phases based on sprint duration
+     */
+    generatePhases(days) {
+        if (days <= 2) {
+            return [
+                { name: 'Phase 1: Implementation', duration: '1 day' },
+                { name: 'Phase 2: Testing & Polish', duration: '1 day' }
+            ];
+        }
+        else if (days <= 5) {
+            return [
+                { name: 'Phase 1: Foundation', duration: `${Math.floor(days * 0.3)} day(s)` },
+                { name: 'Phase 2: Core Implementation', duration: `${Math.floor(days * 0.4)} day(s)` },
+                { name: 'Phase 3: Testing & Refinement', duration: `${Math.ceil(days * 0.3)} day(s)` }
+            ];
+        }
+        else {
+            return [
+                { name: 'Phase 1: Architecture & Setup', duration: `${Math.floor(days * 0.2)} day(s)` },
+                { name: 'Phase 2: Core Features', duration: `${Math.floor(days * 0.3)} day(s)` },
+                { name: 'Phase 3: Integration', duration: `${Math.floor(days * 0.2)} day(s)` },
+                { name: 'Phase 4: Testing & Documentation', duration: `${Math.floor(days * 0.2)} day(s)` },
+                { name: 'Phase 5: Polish & Deploy', duration: `${Math.ceil(days * 0.1)} day(s)` }
+            ];
+        }
+    }
+    /**
+     * Find ADR reference from feature description
+     */
+    async findADRReference(feature) {
+        // Check if feature mentions an ADR
+        const adrMatch = feature.match(/ADR-(\d+)/i);
+        if (adrMatch) {
+            return adrMatch[0].toUpperCase();
+        }
+        // Check if feature matches recent ADR titles
+        const adrDir = path.join(this.projectRoot, 'docs', 'reference', 'architecture');
+        if (await fs.pathExists(adrDir)) {
+            const files = await fs.readdir(adrDir);
+            const recentADRs = files
+                .filter(f => f.startsWith('ADR-'))
+                .sort()
+                .reverse()
+                .slice(0, 5); // Check last 5 ADRs
+            for (const adrFile of recentADRs) {
+                const content = await fs.readFile(path.join(adrDir, adrFile), 'utf8');
+                const titleMatch = content.match(/^#\s+ADR-\d+:\s+(.+)$/m);
+                if (titleMatch) {
+                    const title = titleMatch[1].toLowerCase();
+                    if (feature.toLowerCase().includes(title) || title.includes(feature.toLowerCase())) {
+                        return adrFile.match(/ADR-\d+/)[0];
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get ADR content for context
+     */
+    async getADRContent(adrReference) {
+        const adrDir = path.join(this.projectRoot, 'docs', 'reference', 'architecture');
+        const adrFiles = await fs.readdir(adrDir).catch(() => []);
+        const adrFile = adrFiles.find(f => f.includes(adrReference));
+        if (adrFile) {
+            const content = await fs.readFile(path.join(adrDir, adrFile), 'utf8');
+            return content;
+        }
+        return undefined;
+    }
+    /**
+     * Main build method using fluent interface
+     */
+    async build() {
+        try {
+            if (this.options.verbose) {
+                console.log(chalk.bold.cyan('\n🚀 Building plan with Simple Pipeline Pattern\n'));
+            }
+            await this
+                .initialize()
+                .then(p => p.loadTemplate())
+                .then(p => p.gatherContext())
+                .then(p => {
+                p.generatePrompt();
+                p.validateOutput();
+                return p;
+            })
+                .then(p => p.validate())
+                .then(p => {
+                p.recover();
+                return p;
+            })
+                .then(p => p.display())
+                .then(p => p.execute());
+            if (this.options.verbose) {
+                console.log(chalk.bold.green('\n✨ Plan pipeline completed successfully!\n'));
+            }
+            return this.ctx.content || '';
+        }
+        catch (error) {
+            console.error(chalk.red(`\n❌ Pipeline failed: ${error}`));
+            throw error;
+        }
+    }
+}
+/**
+ * Store sprint plan to filesystem
+ */
+export async function storeSprintPlan(planId, content, verbose = false) {
+    const ginkoDir = await getGinkoDir();
+    const projectRoot = path.dirname(ginkoDir);
+    // Extract title from content
+    const titleMatch = content.match(/^#\s+Sprint Plan:\s+(.+)$/m);
+    const title = titleMatch ? titleMatch[1] : 'Untitled Sprint';
+    const date = new Date().toISOString().split('T')[0];
+    const filename = `SPRINT-${date}-${title.toLowerCase().replace(/[^a-z0-9]+/g, '-')}.md`;
+    // Store sprint plan
+    const sprintDir = path.join(projectRoot, 'docs', 'SPRINTS');
+    await fs.ensureDir(sprintDir);
+    const sprintPath = path.join(sprintDir, filename);
+    await fs.writeFile(sprintPath, content);
+    // Also update current sprint symlink
+    const currentPath = path.join(sprintDir, 'CURRENT-SPRINT.md');
+    if (await fs.pathExists(currentPath)) {
+        await fs.remove(currentPath);
+    }
+    // Create symlink to current sprint
+    await fs.symlink(sprintPath, currentPath).catch(() => {
+        // If symlink fails (Windows), copy instead
+        fs.copyFile(sprintPath, currentPath);
+    });
+    if (verbose) {
+        console.log(chalk.green(`✅ Sprint plan created: ${path.relative(projectRoot, sprintPath)}`));
+        console.log(chalk.dim(`   Current sprint: ${path.relative(projectRoot, currentPath)}`));
+    }
+    else {
+        console.log('done');
+    }
+    // Provide phase transition options
+    if (verbose) {
+        console.log();
+        console.log(chalk.dim('─'.repeat(60)));
+        console.log(chalk.bold('Planning phase complete. Next steps:'));
+        console.log();
+        console.log(chalk.cyan('  ginko start') + chalk.dim(' - Begin implementation'));
+        console.log(chalk.cyan('  ginko capture') + chalk.dim(' - Document implementation decisions'));
+        console.log(chalk.cyan('  ginko ship') + chalk.dim(' - Commit and push your work'));
+        console.log();
+        console.log(chalk.dim('Note: Sprint plan is now active and ready for execution.'));
+    }
+    // Clean up temp file
+    const tempPath = path.join(ginkoDir, '.temp', `${planId}.json`);
+    await fs.remove(tempPath).catch(() => { });
+}
+/**
+ * Adapter for CLI command usage
+ * Maintains backward compatibility with existing command structure
+ */
+export class PlanReflectionCommand {
+    pipeline = null;
+    /**
+     * Execute the plan command
+     */
+    async execute(feature, options = {}) {
+        try {
+            // Phase 2: Store AI-generated sprint plan
+            if (options.store && options.id) {
+                await storeSprintPlan(options.id, options.content || '', options.verbose);
+                return;
+            }
+            // Phase 1 requires feature/ADR reference
+            if (!feature) {
+                process.stdout.write(chalk.red('error: feature or ADR reference required') + '\n');
+                process.stdout.write(chalk.dim('usage: ginko plan "implement ADR-023" --days 5') + '\n');
+                process.exit(1);
+            }
+            // Create and execute pipeline
+            this.pipeline = new PlanReflectionPipeline(feature, options);
+            await this.pipeline.build();
+            // Exit with code 0 to avoid stderr interpretation
+            // The AI prompt is expected behavior, not an error
+            process.exit(0);
+        }
+        catch (error) {
+            process.stdout.write(chalk.red('error: ') + (error instanceof Error ? error.message : String(error)) + '\n');
+            process.exit(1);
+        }
+    }
+}
+// Export for CLI use
+export default PlanReflectionCommand;
+//# sourceMappingURL=plan-reflection-pipeline.js.map