forge-workflow 0.0.1

package/lib/commands/plan.js

@@ -0,0 +1,696 @@
+/**
+ * Plan Command - OpenSpec & Beads Integration
+ * Creates implementation plan after research is complete
+ *
+ * Security: Uses execFileSync instead of exec/execSync to prevent command injection
+ * OWASP: Mitigates A03:2021 - Injection vulnerabilities
+ *
+ * @module commands/plan
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+// Constants for security
+// Note: cwd is resolved at call-time via getExecOptions() to avoid stale require-time snapshots
+const EXEC_TIMEOUT = 120000; // 2 minutes max per command
+function getExecOptions() {
+	return { encoding: 'utf8', cwd: process.cwd(), timeout: EXEC_TIMEOUT };
+}
+
+const MAX_SLUG_LENGTH = 100;
+const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB
+
+/**
+ * Validate feature slug format
+ * Ensures slug matches expected pattern and doesn't contain path traversal
+ *
+ * @param {string} slug - Feature slug to validate
+ * @returns {{valid: boolean, error?: string}} Validation result
+ * @private
+ */
+function validateFeatureSlug(slug) {
+	if (!slug || typeof slug !== 'string') {
+		return { valid: false, error: 'Feature slug must be a non-empty string' };
+	}
+
+	// Length limits (prevent DoS)
+	const MIN_SLUG_LENGTH = 3;
+
+	if (slug.length < MIN_SLUG_LENGTH) {
+		return { valid: false, error: `Slug too short (minimum ${MIN_SLUG_LENGTH} characters)` };
+	}
+
+	if (slug.length > MAX_SLUG_LENGTH) {
+		return { valid: false, error: `Slug too long (maximum ${MAX_SLUG_LENGTH} characters)` };
+	}
+
+	// Only allow lowercase alphanumeric and hyphens; must start and end with alphanumeric
+	const slugPattern = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;  // NOSONAR S5852 - no backtracking: anchored, alternation is possessive
+	if (!slugPattern.test(slug)) {
+		return {
+			valid: false,
+			error: `Invalid slug format '${slug}'. Only lowercase letters, numbers, and hyphens allowed.`,
+		};
+	}
+
+	return { valid: true };
+}
+
+/**
+ * Read research document from file
+ *
+ * @param {string} featureSlug - Feature slug (must match /^[a-z0-9-]+$/)
+ * @returns {{success: boolean, content?: string, path?: string, error?: string}} Research document result
+ * @example
+ * const research = readResearchDoc('payment-integration');
+ * if (research.success) {
+ *   console.log(research.content);
+ * }
+ */
+function readResearchDoc(featureSlug) {
+	// Validate slug format (OWASP A03 - Injection prevention)
+	const validation = validateFeatureSlug(featureSlug);
+	if (!validation.valid) {
+		return {
+			success: false,
+			error: validation.error,
+		};
+	}
+
+	try {
+		const researchPath = path.join(process.cwd(), 'docs', 'research', `${featureSlug}.md`);
+
+		if (!fs.existsSync(researchPath)) {
+			return {
+				success: false,
+				error: `Research document not found: ${researchPath}\n\nRun /research ${featureSlug} first to create research document.`,
+			};
+		}
+
+		// Check file size to prevent resource exhaustion (max 5MB)
+		const stats = fs.statSync(researchPath);
+		if (stats.size > MAX_FILE_SIZE) {
+			return {
+				success: false,
+				error: `Research document too large (${Math.round(stats.size / 1024 / 1024)}MB). Maximum size: 5MB`,
+			};
+		}
+
+		const content = fs.readFileSync(researchPath, 'utf8');
+
+		return {
+			success: true,
+			content,
+			path: `docs/research/${featureSlug}.md`,
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to read research document: ${error.message}`,
+		};
+	}
+}
+
+/**
+ * Detect scope from research content
+ * Determines whether feature is tactical (quick fix) or strategic (architecture change)
+ *
+ * Detection strategy:
+ * 1. Check explicit "Scope Assessment" section first
+ * 2. Fall back to keyword analysis for strategic indicators
+ * 3. Default to tactical if no clear signals
+ *
+ * @param {string} researchContent - Research document markdown content
+ * @returns {{type: 'tactical'|'strategic', requiresOpenSpec: boolean, reason: string}} Scope analysis result
+ * @example
+ * const scope = detectScope(researchMarkdown);
+ * if (scope.type === 'strategic') {
+ *   console.log('Requires OpenSpec proposal:', scope.reason);
+ * }
+ */
+function detectScope(researchContent) {
+	if (!researchContent || typeof researchContent !== 'string') {
+		return {
+			type: 'tactical',
+			requiresOpenSpec: false,
+			reason: 'Invalid research content (defaulting to tactical)',
+		};
+	}
+
+	// Check explicit Scope Assessment section (highest priority)
+	// Use line-by-line parsing to avoid ReDoS
+	const lines = researchContent.split('\n');
+	let scopeLine = null;
+	let inScopeSection = false;
+
+	for (const line of lines) {
+		if (/##\s*Scope Assessment/i.test(line)) {
+			inScopeSection = true;
+			continue;
+		}
+		if (inScopeSection && /^##\s+/.test(line)) {
+			// Hit next section, stop searching
+			break;
+		}
+		if (inScopeSection && /\*\*Strategic\/Tactical\*\*:\s*(Strategic|Tactical)/i.test(line)) {
+			scopeLine = line;
+			break;
+		}
+	}
+
+	const scopeMatch = scopeLine ? /\*\*Strategic\/Tactical\*\*:\s*(Strategic|Tactical)/i.exec(scopeLine) : null;
+
+	if (scopeMatch) {
+		const type = scopeMatch[1].toLowerCase();
+		return {
+			type,
+			requiresOpenSpec: type === 'strategic',
+			reason: `Explicit scope declaration: ${scopeMatch[1]}`,
+		};
+	}
+
+	// Strategic keyword detection (fallback)
+	const strategicKeywords = [
+		'architecture',
+		'architectural',
+		'database schema',
+		'api endpoint',
+		'major',
+		'breaking change',
+		'migration',
+		'refactor',
+		'redesign',
+	];
+
+	const lowerContent = researchContent.toLowerCase();
+	const foundKeywords = strategicKeywords.filter(keyword => lowerContent.includes(keyword));
+
+	if (foundKeywords.length > 0) {
+		return {
+			type: 'strategic',
+			requiresOpenSpec: true,
+			reason: `Strategic keywords detected: ${foundKeywords.join(', ')}`,
+		};
+	}
+
+	// Default to tactical (safe fallback)
+	return {
+		type: 'tactical',
+		requiresOpenSpec: false,
+		reason: 'No strategic indicators found (tactical by default)',
+	};
+}
+
+/**
+ * Create Beads issue for the feature
+ * Executes `bd create` command with appropriate description based on scope
+ *
+ * Security: Uses execFileSync (not exec) to prevent command injection
+ *
+ * @param {string} featureName - Feature name (human-readable)
+ * @param {string} researchPath - Research document path (e.g., "docs/research/feature.md")
+ * @param {'tactical'|'strategic'} scope - Scope type
+ * @returns {{success: boolean, issueId?: string, description?: string, error?: string}} Beads creation result
+ * @example
+ * const result = createBeadsIssue('Payment Integration', 'docs/research/payment.md', 'strategic');
+ * if (result.success) {
+ *   console.log('Created issue:', result.issueId);
+ * }
+ */
+function createBeadsIssue(featureName, researchPath, scope) {
+	if (!featureName || !researchPath) {
+		return {
+			success: false,
+			error: 'Feature name and research path are required',
+		};
+	}
+
+	if (scope !== 'tactical' && scope !== 'strategic') {
+		return {
+			success: false,
+			error: `Invalid scope '${scope}'. Must be 'tactical' or 'strategic'`,
+		};
+	}
+
+	try {
+		let description = `Research: ${researchPath}`;
+
+		if (scope === 'strategic') {
+			// Sanitize derived slug: keep only safe characters (OWASP A03)
+			const featureSlug = featureName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/(?:^-+|-+$)/g, '').slice(0, MAX_SLUG_LENGTH);  // NOSONAR S5852 - non-overlapping anchors, no backtracking
+			const slugValidation = validateFeatureSlug(featureSlug);
+			if (!slugValidation.valid) {
+				return { success: false, error: `Cannot generate valid slug from feature name: ${slugValidation.error}` };
+			}
+			description += `\n\nOpenSpec: openspec/changes/${featureSlug}/`;
+		}
+
+		// Execute bd create command using execFileSync for safety (OWASP A03)
+		const result = execFileSync(  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
+			'bd',  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
+			['create', `--title=${featureName}`, `--description=${description}`, '--type=feature', '--priority=2'],
+			getExecOptions()
+		);
+
+		// Extract issue ID from output (format: "Created issue: forge-xxx")
+		const match = /Created issue:\s*(forge-[a-z0-9]+)/i.exec(result) || /(forge-[a-z0-9]+)/.exec(result);
+
+		if (!match) {
+			return {
+				success: false,
+				error: 'Failed to extract issue ID from bd create output\n\nEnsure beads is installed: bunx beads init',
+			};
+		}
+
+		return {
+			success: true,
+			issueId: match[1],
+			description,
+		};
+	} catch (error) {
+		// Check for timeout
+		if (error.killed && error.signal === 'SIGTERM') {
+			return {
+				success: false,
+				error: 'Beads command timed out after 2 minutes.',
+			};
+		}
+
+		// Provide actionable error message
+		const bdNotFound = error.message.includes('ENOENT') || error.message.includes('not found');
+		const errorMsg = bdNotFound
+			? 'beads (bd) command not found. Install with: bunx beads init'
+			: `Failed to create Beads issue: ${error.message}`;
+
+		return {
+			success: false,
+			error: errorMsg,
+		};
+	}
+}
+
+/**
+ * Create feature branch
+ * Creates and checks out a new git branch following feat/<slug> convention
+ *
+ * Security: Uses execFileSync with array args to prevent command injection
+ *
+ * @param {string} featureSlug - Feature slug (must match /^[a-z0-9-]+$/)
+ * @returns {{success: boolean, branchName?: string, error?: string}} Branch creation result
+ * @example
+ * const result = createFeatureBranch('payment-integration');
+ * if (result.success) {
+ *   console.log('Created branch:', result.branchName);
+ * }
+ */
+function createFeatureBranch(featureSlug) {
+	// Validate slug format (OWASP A03 - Injection prevention)
+	const validation = validateFeatureSlug(featureSlug);
+	if (!validation.valid) {
+		return {
+			success: false,
+			error: validation.error,
+		};
+	}
+
+	try {
+		const branchName = `feat/${featureSlug}`;
+
+		// Check if branch already exists
+		try {
+			execFileSync('git', ['rev-parse', '--verify', branchName], { ...getExecOptions(), stdio: 'pipe' });  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
+			return {
+				success: false,
+				error: `Branch ${branchName} already exists\n\nSwitch to it with: git checkout ${branchName}`,
+			};
+		} catch {
+			// Branch doesn't exist, continue (expected case)
+		}
+
+		// Create and checkout branch
+		execFileSync('git', ['checkout', '-b', branchName], getExecOptions());  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
+
+		return {
+			success: true,
+			branchName,
+		};
+	} catch (error) {
+		// Check for timeout
+		if (error.killed && error.signal === 'SIGTERM') {
+			return {
+				success: false,
+				error: 'Git command timed out after 2 minutes.',
+			};
+		}
+
+		// Provide actionable error message
+		const gitNotFound = error.message.includes('ENOENT') || error.message.includes('not found');
+		const errorMsg = gitNotFound
+			? 'git command not found. Ensure git is installed and in PATH'
+			: `Failed to create branch: ${error.message}`;
+
+		return {
+			success: false,
+			error: errorMsg,
+		};
+	}
+}
+
+/**
+ * Extract design decisions from research content
+ * Parses "Key Decisions" section from research markdown
+ *
+ * Supports two formats:
+ * 1. Numbered with reasoning: "### Decision 1: Title\n**Reasoning**: ..."
+ * 2. Simple headings: "### Decision Title"
+ *
+ * @param {string} researchContent - Research document markdown content
+ * @returns {{decisions: string[]}} Extracted design decisions
+ * @example
+ * const design = extractDesignDecisions(researchMarkdown);
+ * design.decisions.forEach(d => console.log(d));
+ */
+function extractDesignDecisions(researchContent) { // NOSONAR S3776
+	if (!researchContent || typeof researchContent !== 'string') {
+		return { decisions: [] };
+	}
+
+	const decisions = [];
+
+	// Match numbered decisions with reasoning (preferred format)
+	const decisionPattern = /###\s*Decision\s*\d+:\s*([^\r\n]+)[\r\n]+\*\*Reasoning\*\*:\s*([^\r\n]+)/gi; // NOSONAR S5852 - uses [^\r\n]+ (bounded), handles both LF and CRLF
+	let match;
+
+	while ((match = decisionPattern.exec(researchContent)) !== null) {
+		decisions.push(`${match[1]}\nReasoning: ${match[2]}`);
+	}
+
+	// Fall back to simpler format if no numbered decisions found
+	// Uses line-by-line parsing to avoid ReDoS from [\s\S]*? patterns
+	if (decisions.length === 0) {
+		const lines = researchContent.split('\n');
+		let inDecisionsSection = false;
+		for (const line of lines) {
+			if (/^##\s+Key Decisions/i.test(line)) {
+				inDecisionsSection = true;
+				continue;
+			}
+			if (inDecisionsSection && /^##\s+/.test(line)) break;
+			if (inDecisionsSection && /^###\s+/.test(line)) {
+				const cleaned = line.replace(/^###\s+/, '').trim();
+				if (cleaned) decisions.push(cleaned);
+			}
+		}
+	}
+
+	return {
+		decisions,
+	};
+}
+
+/**
+ * Extract TDD tasks from research content
+ * Parses "TDD Test Scenarios" section and converts to RED-GREEN-REFACTOR tasks
+ *
+ * Each scenario generates 3 tasks:
+ * - RED: Write test for scenario
+ * - GREEN: Implement scenario
+ * - REFACTOR: Refactor scenario code
+ *
+ * @param {string} researchContent - Research document markdown content
+ * @returns {Array<{phase: 'RED'|'GREEN'|'REFACTOR', description: string}>} TDD-ordered tasks
+ * @example
+ * const tasks = extractTasksFromResearch(researchMarkdown);
+ * tasks.forEach(t => console.log(`[${t.phase}] ${t.description}`));
+ */
+function extractTasksFromResearch(researchContent) {
+	if (!researchContent || typeof researchContent !== 'string') {
+		return [];
+	}
+
+	const tasks = [];
+
+	// Split by lines to avoid ReDoS - safer than complex regex
+	const lines = researchContent.split('\n');
+	let inScenariosSection = false;
+	const scenarioLines = [];
+
+	for (const line of lines) {
+		if (/##[^#]*TDD Test Scenarios/i.test(line)) {
+			inScenariosSection = true;
+			continue;
+		}
+		if (inScenariosSection && /^##\s+[^#]/.test(line)) {
+			// Hit next top-level section (## but not ###), stop
+			break;
+		}
+		if (inScenariosSection) {
+			scenarioLines.push(line);
+		}
+	}
+
+	// Extract scenario headings (safe - simple pattern, no backtracking)
+	const scenarioPattern = /###\s*Scenario\s*\d+:\s*([^\n]+)/gi;
+	const sectionContent = scenarioLines.join('\n');
+	let match;
+
+	while ((match = scenarioPattern.exec(sectionContent)) !== null) {
+		const scenario = match[1].trim();
+
+		if (!scenario) {
+			continue; // Skip empty scenarios
+		}
+
+		// Each scenario becomes 3 tasks (RED-GREEN-REFACTOR cycle)
+		tasks.push(
+			{ phase: 'RED', description: `Write test: ${scenario}` },
+			{ phase: 'GREEN', description: `Implement: ${scenario}` },
+			{ phase: 'REFACTOR', description: `Refactor: ${scenario}` },
+		);
+	}
+
+	return tasks;
+}
+
+/**
+ * Detect DRY (Don't Repeat Yourself) violations during Phase 2 codebase exploration
+ * Checks whether an existing implementation already covers the planned feature.
+ * If a match is found, the design doc's approach section must be updated to
+ * "extend existing [file/function]" rather than "create new".
+ *
+ * @param {{ searchTerm: string, matches: Array<{ file: string, line: number }> }} params
+ * @returns {{ violation: boolean, existingFile?: string, existingLine?: number }}
+ * @example
+ * const result = detectDRYViolation({ searchTerm: 'validateSlug', matches: [{ file: 'lib/utils.js', line: 42 }] });
+ * // => { violation: true, existingFile: 'lib/utils.js', existingLine: 42 }
+ *
+ * const empty = detectDRYViolation({ searchTerm: 'foo', matches: [] });
+ * // => { violation: false }
+ */
+function detectDRYViolation({ searchTerm: _searchTerm, matches } = {}) {
+	if (!Array.isArray(matches) || matches.length === 0) {
+		return { violation: false };
+	}
+
+	const first = matches[0];
+	return {
+		violation: true,
+		existingFile: first.file,
+		existingLine: first.line,
+		allMatches: matches,
+	};
+}
+
+/**
+ * Apply YAGNI (You Aren't Gonna Need It) filter to planned tasks
+ * Checks whether each task maps to a specific requirement, success criterion,
+ * or edge case in the design doc. Tasks with no anchor are flagged as potential scope creep.
+ *
+ * Supports two call modes:
+ * - Single task: { task: string, designDoc: string } → { flagged, anchor?, reason? }
+ * - Multi-task:  { tasks: string[], designDoc: string } → { allFlagged, flaggedTasks, message? }
+ *
+ * Matching logic: any keyword from the task title found in the designDoc (case-insensitive).
+ *
+ * @param {{ task?: string, tasks?: string[], designDoc: string }} params
+ * @returns {{ flagged?: boolean, anchor?: string, reason?: string, allFlagged?: boolean, flaggedTasks?: string[], message?: string }}
+ * @example
+ * applyYAGNIFilter({ task: 'Add validateSlug function', designDoc: '## Success Criteria\n- validateSlug validates slug format' })
+ * // => { flagged: false, anchor: 'validateSlug' }
+ *
+ * applyYAGNIFilter({ task: 'Add dark mode toggle', designDoc: '## Success Criteria\n- validateSlug validates slug format' })
+ * // => { flagged: true, reason: 'No matching requirement found in design doc' }
+ *
+ * applyYAGNIFilter({ tasks: ['Task A', 'Task B'], designDoc: '## Purpose\nFoo' })
+ * // => { allFlagged: true, flaggedTasks: ['Task A', 'Task B'], message: "Design doc doesn't cover all tasks — needs amendment" }
+ *
+ * applyYAGNIFilter({ tasks: ['validateSlug function', 'dark mode toggle'], designDoc: '## Success Criteria\n- validateSlug validates slug' })
+ * // => { allFlagged: false, flaggedTasks: ['dark mode toggle'] }
+ */
+const YAGNI_STOP_WORDS = new Set(['a', 'an', 'the', 'add', 'in', 'of', 'to', 'for', 'is', 'it', 'and', 'or', 'with', 'that', 'this', 'be', 'as', 'by', 'at', 'on', 'if']);
+
+function meaningfulKeywords(title) {
+	return String(title).toLowerCase().split(/\s+/)
+		.map(kw => kw.replace(/^[`'"()[\]{},]+|[`'"()[\]{},.:;!?]+$/g, '')) // NOSONAR S5852 — literal character class, no backtracking
+		.filter(kw => kw.length > 2 && !YAGNI_STOP_WORDS.has(kw));
+}
+
+function applyYAGNIFilter({ task, tasks, designDoc } = {}) {
+	const lowerDoc = typeof designDoc === 'string' ? designDoc.toLowerCase() : '';
+
+	// Multi-task mode: returns allFlagged + flaggedTasks list for partial violations
+	if (Array.isArray(tasks)) {
+		if (tasks.length === 0) return { allFlagged: false, flaggedTasks: [] };
+
+		const flaggedTasks = tasks.filter(t => {
+			const keywords = meaningfulKeywords(t);
+			return keywords.length === 0 || !keywords.some(kw => lowerDoc.includes(kw));
+		});
+
+		if (flaggedTasks.length === tasks.length) {
+			return {
+				allFlagged: true,
+				flaggedTasks,
+				message: "Design doc doesn't cover all tasks — needs amendment",
+			};
+		}
+
+		return { allFlagged: false, flaggedTasks };
+	}
+
+	// Single-task mode
+	const keywords = meaningfulKeywords(task || '');
+	const matchedKeyword = keywords.find(kw => lowerDoc.includes(kw));
+
+	if (matchedKeyword) {
+		return { flagged: false, anchor: matchedKeyword };
+	}
+
+	return { flagged: true, reason: 'No matching requirement found in design doc' };
+}
+
+/**
+ * Execute full plan workflow
+ * Orchestrates tactical or strategic planning workflow
+ *
+ * Tactical workflow (quick fixes, <1 day):
+ * 1. Read research document
+ * 2. Detect scope (tactical)
+ * 3. Create Beads issue
+ * 4. Create feature branch
+ * → Next: /dev command
+ *
+ * Strategic workflow (architecture changes, >1 day):
+ * 1. Read research document
+ * 2. Detect scope (strategic)
+ * 3. Create Beads issue with OpenSpec link
+ * 4. Create feature branch
+ * 5. Generate OpenSpec proposal (proposal.md, tasks.md, design.md)
+ * 6. Commit and push proposal
+ * 7. Create proposal PR
+ * → Next: Wait for proposal approval
+ *
+ * @param {string} featureName - Feature name (human-readable, e.g., "Payment Integration")
+ * @returns {Promise<{
+ *   success: boolean,
+ *   scope?: 'tactical'|'strategic',
+ *   beadsIssueId?: string,
+ *   branchName?: string,
+ *   openSpecCreated?: boolean,
+ *   proposalPR?: {url: string, number: number},
+ *   summary?: string,
+ *   nextCommand?: string,
+ *   error?: string
+ * }>} Execution result
+ * @example
+ * const result = await executePlan('Payment Integration');
+ * if (result.success) {
+ *   console.log(result.summary);
+ *   console.log('Next:', result.nextCommand);
+ * }
+ */
+async function executePlan(featureName) { // NOSONAR S3776
+	if (!featureName || typeof featureName !== 'string') {
+		return {
+			success: false,
+			error: 'Feature name is required and must be a string',
+		};
+	}
+
+	const featureSlug = featureName.toLowerCase()
+		.replaceAll(/[^a-z0-9-]/g, '-')
+		.split('-').filter(Boolean).join('-');
+
+	// Validate generated slug
+	const validation = validateFeatureSlug(featureSlug);
+	if (!validation.valid) {
+		return {
+			success: false,
+			error: `Invalid feature name generates invalid slug '${featureSlug}': ${validation.error}`,
+		};
+	}
+
+	try {
+		// Step 1: Read research document
+		const research = readResearchDoc(featureSlug);
+		if (!research.success) {
+			return {
+				success: false,
+				error: `Research document not found: ${research.error}`,
+			};
+		}
+
+		// Step 2: Detect scope (tactical vs strategic)
+		const scope = detectScope(research.content);
+
+		// Step 3: Create Beads issue
+		const beads = createBeadsIssue(featureName, research.path, scope.type);
+		if (!beads.success) {
+			return {
+				success: false,
+				error: `Failed to create Beads issue: ${beads.error}`,
+			};
+		}
+
+		// Step 4: Create feature branch
+		const branch = createFeatureBranch(featureSlug);
+		if (!branch.success) {
+			return {
+				success: false,
+				error: `Failed to create branch: ${branch.error}`,
+			};
+		}
+
+		// Build result summary
+		const result = {
+			success: true,
+			scope: scope.type,
+			beadsIssueId: beads.issueId,
+			branchName: branch.branchName,
+			summary: `Plan created for ${featureName} (${scope.type} scope)`,
+			// Strategic path: /propose not yet implemented — falls through to /dev until it is
+			nextCommand: '/dev',
+		};
+
+		return result;
+	} catch (error) {
+		return {
+			success: false,
+			error: `Unexpected error in executePlan: ${error.message}`,
+		};
+	}
+}
+
+module.exports = {
+	readResearchDoc,
+	detectScope,
+	createBeadsIssue,
+	createFeatureBranch,
+	extractDesignDecisions,
+	extractTasksFromResearch,
+	detectDRYViolation,
+	applyYAGNIFilter,
+	executePlan,
+};