opencode-conductor-cdd-plugin 1.0.0-beta.18 → 1.0.0-beta.19

package/dist/utils/codebaseAnalysis.test.js

@@ -0,0 +1,556 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { parseIgnoreFiles, detectManifests, inferArchitecture, detectLanguages, detectFrameworks, analyzeCodebase, } from './codebaseAnalysis.js';
+/**
+ * Codebase Analysis Module Tests
+ *
+ * This module is responsible for analyzing existing codebases to extract:
+ * - Ignore patterns from .ignore, .geminiignore, .gitignore
+ * - Dependency manifests with versions and metadata
+ * - Architecture patterns (Monorepo, Microservices, MVC, etc.)
+ * - Programming languages and frameworks
+ *
+ * Based on reference implementations from:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+// Mock file system and child_process
+vi.mock('fs');
+vi.mock('child_process');
+describe('Codebase Analysis', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('parseIgnoreFiles', () => {
+        it('should parse .geminiignore with precedence over .gitignore', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.geminiignore');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('node_modules/\n*.log\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+            expect(result[0].pattern).toBe('node_modules/');
+            expect(result[0].negated).toBe(false);
+        });
+        it('should parse .gitignore if .geminiignore does not exist', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.gitignore');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('dist/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].pattern).toBe('dist/');
+        });
+        it('should parse .ignore file', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('.ignore') && !pathStr.endsWith('.geminiignore');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('temp/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(1);
+        });
+        it('should handle negation patterns with !', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('*.log\n!important.log\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+            expect(result[1].pattern).toBe('important.log');
+            expect(result[1].negated).toBe(true);
+        });
+        it('should ignore comment lines starting with #', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('# Comment\nnode_modules/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].pattern).toBe('node_modules/');
+        });
+        it('should ignore empty lines', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('node_modules/\n\n\ndist/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+        });
+        it('should return empty array when no ignore files exist', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toEqual([]);
+        });
+        it('should handle patterns with wildcards (* and **)', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('*.log\n**/node_modules\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+            expect(result[0].pattern).toBe('*.log');
+            expect(result[1].pattern).toBe('**/node_modules');
+        });
+        it('should handle directory patterns ending with /', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('dist/\nnode_modules/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+            expect(result[0].pattern).toBe('dist/');
+        });
+    });
+    describe('detectManifests', () => {
+        it('should detect package.json with name and version', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test-project',
+                version: '1.0.0',
+                description: 'Test project',
+            }));
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('package.json');
+            expect(result[0].metadata.name).toBe('test-project');
+            expect(result[0].metadata.version).toBe('1.0.0');
+        });
+        it('should detect package.json dependencies and devDependencies', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test',
+                dependencies: { react: '^18.0.0' },
+                devDependencies: { vitest: '^4.0.0' },
+            }));
+            const result = detectManifests('/test/project');
+            expect(result[0].dependencies).toEqual({
+                react: '^18.0.0',
+                vitest: '^4.0.0',
+            });
+        });
+        it('should detect pom.xml with Maven metadata', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('pom.xml');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('<project><groupId>com.example</groupId><artifactId>demo</artifactId><version>1.0</version></project>');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('pom.xml');
+            expect(result[0].metadata.groupId).toBe('com.example');
+            expect(result[0].metadata.artifactId).toBe('demo');
+        });
+        it('should detect requirements.txt with Python packages', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('requirements.txt');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('django==4.0.0\nflask>=2.0.0\n');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('requirements.txt');
+            expect(result[0].dependencies).toEqual({
+                django: '4.0.0',
+                flask: '2.0.0',
+            });
+        });
+        it('should detect go.mod with Go module information', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('go.mod');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('module github.com/example/project\n');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('go.mod');
+            expect(result[0].metadata.module).toBe('github.com/example/project');
+        });
+        it('should detect Cargo.toml with Rust metadata', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('Cargo.toml');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('[package]\nname = "test"\nversion = "0.1.0"\n');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('Cargo.toml');
+            expect(result[0].metadata.name).toBe('test');
+            expect(result[0].metadata.version).toBe('0.1.0');
+        });
+        it('should detect Gemfile with Ruby gems', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('Gemfile');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('gem "rails", "7.0.0"\ngem "pg"\n');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('Gemfile');
+            expect(result[0].dependencies).toEqual({
+                rails: '7.0.0',
+                pg: '*',
+            });
+        });
+        it('should return empty array when no manifests found', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = detectManifests('/test/project');
+            expect(result).toEqual([]);
+        });
+        it('should handle malformed JSON in package.json gracefully', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('{ invalid json');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].metadata.error).toBe('Malformed JSON');
+        });
+        it('should detect multiple manifests in same project', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                if (pathStr.endsWith('package.json')) {
+                    return JSON.stringify({ name: 'test' });
+                }
+                if (pathStr.endsWith('requirements.txt')) {
+                    return 'django==4.0.0';
+                }
+                return '';
+            });
+            const result = detectManifests('/test/project');
+            expect(result.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe('inferArchitecture', () => {
+        it('should detect monorepo with packages/ directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('packages');
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('monorepo');
+        });
+        it('should detect monorepo with workspaces in package.json', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test',
+                workspaces: ['packages/*'],
+            }));
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('monorepo');
+        });
+        it('should detect monorepo with lerna.json', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('lerna.json');
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('monorepo');
+        });
+        it('should detect microservices with multiple service directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.includes('user-service') || pathStr.includes('auth-service') || pathStr.endsWith('package.json');
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'user-service', isDirectory: () => true },
+                { name: 'auth-service', isDirectory: () => true },
+            ]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('microservices');
+        });
+        it('should detect MVC pattern with models/, views/, controllers/ directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('models') || pathStr.endsWith('views') || pathStr.endsWith('controllers');
+            });
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('mvc');
+        });
+        it('should detect Clean Architecture with domain/, application/, infrastructure/ directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('domain') || pathStr.endsWith('application') || pathStr.endsWith('infrastructure');
+            });
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('clean-architecture');
+        });
+        it('should detect Hexagonal Architecture with adapters/, ports/ directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('adapters') || pathStr.endsWith('ports');
+            });
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('hexagonal-architecture');
+        });
+        it('should detect layered architecture with src/api/, src/services/, src/data/ directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                // Must return true for src/ directory AND its subdirectories
+                if (pathStr.endsWith('/src'))
+                    return true;
+                if (pathStr.endsWith('/src/api'))
+                    return true;
+                if (pathStr.endsWith('/src/services'))
+                    return true;
+                if (pathStr.endsWith('/src/data'))
+                    return true;
+                return false;
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('layered-architecture');
+        });
+        it('should return "unknown" when no pattern matches', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('unknown');
+        });
+        it('should return multiple patterns if project uses hybrid architecture', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('packages') || pathStr.endsWith('models') || pathStr.endsWith('views') || pathStr.endsWith('controllers');
+            });
+            const result = inferArchitecture('/test/project');
+            expect(result.length).toBeGreaterThan(1);
+            expect(result).toContain('monorepo');
+            expect(result).toContain('mvc');
+        });
+    });
+    describe('detectLanguages', () => {
+        it('should detect TypeScript from .ts files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.TypeScript).toBeDefined();
+        });
+        it('should detect JavaScript from .js files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'app.js', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.JavaScript).toBeDefined();
+        });
+        it('should detect Python from .py files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Python).toBeDefined();
+        });
+        it('should detect Go from .go files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.go', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Go).toBeDefined();
+        });
+        it('should detect Rust from .rs files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.rs', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Rust).toBeDefined();
+        });
+        it('should detect Ruby from .rb files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'app.rb', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Ruby).toBeDefined();
+        });
+        it('should detect Java from .java files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'Main.java', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Java).toBeDefined();
+        });
+        it('should detect multiple languages in polyglot projects', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(Object.keys(result).length).toBeGreaterThan(1);
+        });
+        it('should return language usage percentage', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+                { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.TypeScript).toBeGreaterThan(0);
+            expect(result.TypeScript).toBeLessThanOrEqual(100);
+        });
+    });
+    describe('detectFrameworks', () => {
+        it('should detect React from package.json dependencies', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { react: '^18.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.frontend).toContain('React');
+        });
+        it('should detect Next.js from package.json dependencies', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { next: '^13.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.frontend).toContain('Next.js');
+        });
+        it('should detect Vue from package.json dependencies', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { vue: '^3.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.frontend).toContain('Vue');
+        });
+        it('should detect Express from package.json dependencies', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { express: '^4.18.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.backend).toContain('Express');
+        });
+        it('should detect Django from requirements.txt', () => {
+            const manifests = [{
+                    type: 'requirements.txt',
+                    path: '/test/requirements.txt',
+                    metadata: {},
+                    dependencies: { django: '4.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.backend).toContain('Django');
+        });
+        it('should detect Flask from requirements.txt', () => {
+            const manifests = [{
+                    type: 'requirements.txt',
+                    path: '/test/requirements.txt',
+                    metadata: {},
+                    dependencies: { flask: '2.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.backend).toContain('Flask');
+        });
+        it('should detect Spring Boot from pom.xml dependencies', () => {
+            const manifests = [{
+                    type: 'pom.xml',
+                    path: '/test/pom.xml',
+                    metadata: {},
+                    dependencies: { 'spring-boot-starter': '2.7.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.backend).toContain('Spring Boot');
+        });
+        it('should categorize frameworks as frontend or backend', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { react: '^18.0.0', express: '^4.18.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.frontend).toContain('React');
+            expect(result.backend).toContain('Express');
+        });
+        it('should detect database drivers', () => {
+            // This test is for databases, which is handled separately in analyzeCodebase
+            // Just verify the function doesn't crash
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { mongoose: '^6.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result).toBeDefined();
+        });
+    });
+    describe('analyzeCodebase', () => {
+        it('should perform comprehensive analysis with all sub-functions', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ name: 'test' }));
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = analyzeCodebase('/test/project');
+            expect(result).toHaveProperty('languages');
+            expect(result).toHaveProperty('frameworks');
+            expect(result).toHaveProperty('databases');
+            expect(result).toHaveProperty('architecture');
+            expect(result).toHaveProperty('manifests');
+        });
+        it('should respect ignore files during analysis', () => {
+            // This would be tested by integration tests
+            // Unit test just verifies function exists
+            expect(analyzeCodebase).toBeDefined();
+        });
+        it('should use git ls-files when available for efficiency', () => {
+            // This would be tested by integration tests
+            expect(analyzeCodebase).toBeDefined();
+        });
+        it('should fallback to manual directory scanning when git not available', () => {
+            vi.mocked(execSync).mockImplementation(() => {
+                throw new Error('Git not available');
+            });
+            expect(analyzeCodebase).toBeDefined();
+        });
+        it('should handle large files (>1MB) by reading only first/last 20 lines', () => {
+            // This would be tested by integration tests with actual large files
+            expect(analyzeCodebase).toBeDefined();
+        });
+        it('should prioritize README.md analysis', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('README.md');
+            });
+            vi.mocked(fs.readFileSync).mockImplementation((p) => {
+                if (p.toString().endsWith('README.md')) {
+                    return '# Test Project\n\nThis is a test project description';
+                }
+                return '';
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = analyzeCodebase('/test/project');
+            expect(result.projectGoal).toContain('test project');
+        });
+        it('should extract project goal from README or package.json description', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test',
+                description: 'A wonderful test project',
+            }));
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = analyzeCodebase('/test/project');
+            expect(result.projectGoal).toBe('A wonderful test project');
+        });
+        it('should return comprehensive analysis object', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test',
+                dependencies: { react: '^18.0.0' },
+            }));
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = analyzeCodebase('/test/project');
+            expect(result.languages).toBeDefined();
+            expect(result.frameworks.frontend).toBeDefined();
+            expect(result.frameworks.backend).toBeDefined();
+            expect(result.databases).toBeDefined();
+            expect(result.architecture).toBeDefined();
+            expect(result.manifests).toBeDefined();
+        });
+    });
+});

package/dist/utils/documentGeneration.d.ts

@@ -0,0 +1,97 @@
+import { Question, Section } from './questionGenerator.js';
+import { CodebaseAnalysis } from './codebaseAnalysis.js';
+/**
+ * Document Generation Module
+ *
+ * Orchestrates the full document generation workflow:
+ * - Present questions sequentially (max 5)
+ * - Handle user selections (A-E, including custom and auto-generate)
+ * - Draft documents from selected answers only
+ * - Approval/revision loops
+ * - State persistence for resume functionality
+ *
+ * Based on reference implementations:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+export interface QuestionAnswer {
+    questionId: string;
+    selections: string[];
+    selectedOptions: string[];
+    customText?: string;
+    timestamp: string;
+}
+export interface QuestionSession {
+    section: Section;
+    questionsAsked: Question[];
+    answers: QuestionAnswer[];
+    autoGenerateRequested: boolean;
+    autoGenerateAtQuestion?: number;
+    startTime: string;
+    endTime: string;
+}
+export interface DocumentDraft {
+    content: string;
+    inferredFromContext: boolean;
+    sectionsIncluded: string[];
+    wordCount: number;
+}
+export interface DocumentState {
+    section: Section;
+    checkpoint: string;
+    content: string;
+    filePath: string;
+    timestamp?: string;
+}
+export interface SaveStateResult {
+    success: boolean;
+    stateFile?: string;
+    checkpoint?: string;
+    filePath?: string;
+    previousCheckpoints?: string[];
+    error?: string;
+}
+export interface ApprovalResult {
+    approved: boolean;
+    finalContent?: string;
+    revisionGuidance?: string;
+}
+export interface DocumentGenerationOptions {
+    section: Section;
+    questions: Question[];
+    analysis: CodebaseAnalysis;
+    responder: (question: Question, questionNumber: number) => Promise<string[]>;
+    approvalFlow: (draft: DocumentDraft) => Promise<ApprovalResult>;
+    outputPath: string;
+    maxRevisions?: number;
+    customInputPrompt?: (question: Question) => Promise<string>;
+}
+export interface DocumentGenerationResult {
+    success: boolean;
+    checkpoint?: string;
+    autoGenerated?: boolean;
+    revisionCount?: number;
+    error?: string;
+}
+export interface PresentQuestionsOptions {
+    maxQuestions?: number;
+    customInputPrompt?: (question: Question) => Promise<string>;
+}
+/**
+ * Present questions sequentially to the user
+ * Stops after maxQuestions or when option E is selected
+ */
+export declare function presentQuestionsSequentially(questions: Question[], responder: (question: Question, questionNumber: number) => Promise<string[]>, options?: PresentQuestionsOptions): Promise<QuestionSession>;
+/**
+ * Draft document content from user's selected answers
+ * CRITICAL: Only use selected options, ignore questions and unselected options
+ */
+export declare function draftDocumentFromAnswers(session: QuestionSession, analysis: CodebaseAnalysis): DocumentDraft;
+/**
+ * Save document to file and update state
+ */
+export declare function saveDocumentState(state: DocumentState): Promise<SaveStateResult>;
+/**
+ * Orchestrate full document generation workflow
+ */
+export declare function generateDocument(options: DocumentGenerationOptions): Promise<DocumentGenerationResult>;