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

package/dist/utils/archive-tracks.test.js

@@ -0,0 +1,495 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { isTrackFinished, parseMetadata, isPlanFullyCompleted, moveTrackToArchive, removeTrackFromRegistry, archiveCompletedTracks } from './archive-tracks.js';
+import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+describe('archive-tracks', () => {
+    describe('parseMetadata', () => {
+        it('should parse valid metadata.json content', () => {
+            const jsonContent = JSON.stringify({
+                track_id: 'test_track_001',
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test track'
+            });
+            const result = parseMetadata(jsonContent);
+            expect(result).toEqual({
+                track_id: 'test_track_001',
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test track'
+            });
+        });
+        it('should throw error for invalid JSON', () => {
+            expect(() => parseMetadata('invalid json')).toThrow();
+        });
+        it('should throw error for missing required fields', () => {
+            const jsonContent = JSON.stringify({
+                track_id: 'test_track_001'
+            });
+            expect(() => parseMetadata(jsonContent)).toThrow('Invalid metadata');
+        });
+    });
+    describe('isPlanFullyCompleted', () => {
+        it('should return true when all tasks are marked as completed', () => {
+            const planContent = `
+# Plan
+
+## Phase 1
+- [x] Task 1
+- [x] Task 2
+
+## Phase 2
+- [x] Task 3
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(true);
+        });
+        it('should return false when any task is incomplete', () => {
+            const planContent = `
+# Plan
+
+## Phase 1
+- [x] Task 1
+- [ ] Task 2
+
+## Phase 2
+- [x] Task 3
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(false);
+        });
+        it('should return false when there are in-progress tasks', () => {
+            const planContent = `
+# Plan
+
+## Phase 1
+- [x] Task 1
+- [~] Task 2
+
+## Phase 2
+- [x] Task 3
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(false);
+        });
+        it('should return true for plan with no tasks', () => {
+            const planContent = `
+# Plan
+
+Just a description, no tasks.
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(true);
+        });
+        it('should handle nested sub-tasks correctly', () => {
+            const planContent = `
+## Phase 1
+- [x] Task 1
+  - [x] Subtask 1.1
+  - [x] Subtask 1.2
+- [x] Task 2
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(true);
+        });
+        it('should return false if any sub-task is incomplete', () => {
+            const planContent = `
+## Phase 1
+- [x] Task 1
+  - [x] Subtask 1.1
+  - [ ] Subtask 1.2
+- [x] Task 2
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(false);
+        });
+    });
+    describe('isTrackFinished', () => {
+        it('should return true when metadata is completed and plan is fully checked', () => {
+            const metadata = {
+                track_id: 'test_001',
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test'
+            };
+            const planContent = `
+## Phase 1
+- [x] Task 1
+- [x] Task 2
+`;
+            expect(isTrackFinished(metadata, planContent)).toBe(true);
+        });
+        it('should return false when metadata status is not completed', () => {
+            const metadata = {
+                track_id: 'test_001',
+                type: 'feature',
+                status: 'in_progress',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test'
+            };
+            const planContent = `
+## Phase 1
+- [x] Task 1
+- [x] Task 2
+`;
+            expect(isTrackFinished(metadata, planContent)).toBe(false);
+        });
+        it('should return false when plan has incomplete tasks', () => {
+            const metadata = {
+                track_id: 'test_001',
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test'
+            };
+            const planContent = `
+## Phase 1
+- [x] Task 1
+- [ ] Task 2
+`;
+            expect(isTrackFinished(metadata, planContent)).toBe(false);
+        });
+        it('should return false when both metadata and plan are incomplete', () => {
+            const metadata = {
+                track_id: 'test_001',
+                type: 'feature',
+                status: 'new',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test'
+            };
+            const planContent = `
+## Phase 1
+- [ ] Task 1
+- [ ] Task 2
+`;
+            expect(isTrackFinished(metadata, planContent)).toBe(false);
+        });
+    });
+    describe('moveTrackToArchive', () => {
+        let testDir;
+        let tracksDir;
+        let archiveDir;
+        beforeEach(() => {
+            // Create temporary test directory structure
+            testDir = join(tmpdir(), `archive-test-${Date.now()}`);
+            tracksDir = join(testDir, 'conductor-cdd', 'tracks');
+            archiveDir = join(testDir, 'conductor-cdd', 'archive');
+            mkdirSync(tracksDir, { recursive: true });
+        });
+        afterEach(() => {
+            // Clean up test directory
+            if (existsSync(testDir)) {
+                rmSync(testDir, { recursive: true, force: true });
+            }
+        });
+        it('should move track directory to archive', () => {
+            const trackId = 'test_track_001';
+            const trackPath = join(tracksDir, trackId);
+            // Create track directory with files
+            mkdirSync(trackPath);
+            writeFileSync(join(trackPath, 'spec.md'), '# Spec');
+            writeFileSync(join(trackPath, 'plan.md'), '# Plan');
+            // Move to archive
+            moveTrackToArchive(testDir, trackId);
+            // Verify track no longer in tracks/
+            expect(existsSync(trackPath)).toBe(false);
+            // Verify track now in archive/
+            const archivedPath = join(archiveDir, trackId);
+            expect(existsSync(archivedPath)).toBe(true);
+            expect(existsSync(join(archivedPath, 'spec.md'))).toBe(true);
+            expect(existsSync(join(archivedPath, 'plan.md'))).toBe(true);
+        });
+        it('should create archive directory if it does not exist', () => {
+            const trackId = 'test_track_002';
+            const trackPath = join(tracksDir, trackId);
+            mkdirSync(trackPath);
+            writeFileSync(join(trackPath, 'spec.md'), '# Spec');
+            // Archive dir should not exist yet
+            expect(existsSync(archiveDir)).toBe(false);
+            // Move to archive
+            moveTrackToArchive(testDir, trackId);
+            // Archive dir should now exist
+            expect(existsSync(archiveDir)).toBe(true);
+            expect(existsSync(join(archiveDir, trackId))).toBe(true);
+        });
+        it('should throw error if source track does not exist', () => {
+            expect(() => moveTrackToArchive(testDir, 'nonexistent_track')).toThrow();
+        });
+    });
+    describe('removeTrackFromRegistry', () => {
+        let testDir;
+        let tracksFile;
+        beforeEach(() => {
+            testDir = join(tmpdir(), `registry-test-${Date.now()}`);
+            mkdirSync(testDir, { recursive: true });
+            tracksFile = join(testDir, 'tracks.md');
+        });
+        afterEach(() => {
+            if (existsSync(testDir)) {
+                rmSync(testDir, { recursive: true, force: true });
+            }
+        });
+        it('should remove track entry from tracks.md', () => {
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: First Track**
+*Link: [./tracks/first_track/](./tracks/first_track/)*
+
+---
+
+- [x] **Track: Second Track**
+*Link: [./tracks/second_track/](./tracks/second_track/)*
+
+---
+
+- [~] **Track: Third Track**
+*Link: [./tracks/third_track/](./tracks/third_track/)*
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Remove second track
+            removeTrackFromRegistry(tracksFile, 'second_track');
+            const updatedContent = readFileSync(tracksFile, 'utf-8');
+            // Should not contain second track
+            expect(updatedContent).not.toContain('Second Track');
+            expect(updatedContent).not.toContain('second_track');
+            // Should still contain other tracks
+            expect(updatedContent).toContain('First Track');
+            expect(updatedContent).toContain('Third Track');
+        });
+        it('should handle track entry with separator lines correctly', () => {
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: Keep This**
+*Link: [./tracks/keep_this/](./tracks/keep_this/)*
+
+---
+
+- [x] **Track: Remove This**
+*Link: [./tracks/remove_this/](./tracks/remove_this/)*
+
+---
+
+- [~] **Track: Also Keep**
+*Link: [./tracks/also_keep/](./tracks/also_keep/)*
+`;
+            writeFileSync(tracksFile, tracksContent);
+            removeTrackFromRegistry(tracksFile, 'remove_this');
+            const updatedContent = readFileSync(tracksFile, 'utf-8');
+            expect(updatedContent).not.toContain('Remove This');
+            expect(updatedContent).toContain('Keep This');
+            expect(updatedContent).toContain('Also Keep');
+            // Should have clean separator lines (no duplicate ---)
+            const separatorCount = (updatedContent.match(/^---$/gm) || []).length;
+            expect(separatorCount).toBe(2); // One separator between each remaining track
+        });
+        it('should do nothing if track not found in registry', () => {
+            const tracksContent = `# Project Tracks
+
+- [x] **Track: Some Track**
+*Link: [./tracks/some_track/](./tracks/some_track/)*
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Try to remove non-existent track
+            removeTrackFromRegistry(tracksFile, 'nonexistent');
+            const updatedContent = readFileSync(tracksFile, 'utf-8');
+            // Content should be unchanged
+            expect(updatedContent).toBe(tracksContent);
+        });
+    });
+    describe('archiveCompletedTracks (Integration)', () => {
+        let testDir;
+        let tracksDir;
+        let archiveDir;
+        let tracksFile;
+        beforeEach(() => {
+            testDir = join(tmpdir(), `archive-integration-${Date.now()}`);
+            const cddDir = join(testDir, 'conductor-cdd');
+            tracksDir = join(cddDir, 'tracks');
+            archiveDir = join(cddDir, 'archive');
+            tracksFile = join(cddDir, 'tracks.md');
+            mkdirSync(tracksDir, { recursive: true });
+        });
+        afterEach(() => {
+            if (existsSync(testDir)) {
+                rmSync(testDir, { recursive: true, force: true });
+            }
+        });
+        it('should archive tracks that are fully completed', () => {
+            // Create completed track
+            const completedTrackId = 'completed_track_001';
+            const completedPath = join(tracksDir, completedTrackId);
+            mkdirSync(completedPath);
+            const completedMetadata = {
+                track_id: completedTrackId,
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Completed track'
+            };
+            const completedPlan = `
+## Phase 1
+- [x] Task 1
+- [x] Task 2
+`;
+            writeFileSync(join(completedPath, 'metadata.json'), JSON.stringify(completedMetadata, null, 2));
+            writeFileSync(join(completedPath, 'plan.md'), completedPlan);
+            writeFileSync(join(completedPath, 'spec.md'), '# Spec');
+            // Create tracks.md
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: Completed Track**
+*Link: [./tracks/${completedTrackId}/](./tracks/${completedTrackId}/)*
+
+---
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Run archival
+            const result = archiveCompletedTracks(testDir);
+            // Verify track was archived
+            expect(result.archived).toContain(completedTrackId);
+            expect(result.errors).toHaveLength(0);
+            // Verify track moved to archive
+            expect(existsSync(completedPath)).toBe(false);
+            expect(existsSync(join(archiveDir, completedTrackId))).toBe(true);
+            // Verify removed from tracks.md
+            const updatedTracks = readFileSync(tracksFile, 'utf-8');
+            expect(updatedTracks).not.toContain(completedTrackId);
+        });
+        it('should skip tracks that are not completed', () => {
+            // Create incomplete track (metadata complete but plan incomplete)
+            const incompleteTrackId = 'incomplete_track_001';
+            const incompletePath = join(tracksDir, incompleteTrackId);
+            mkdirSync(incompletePath);
+            const incompleteMetadata = {
+                track_id: incompleteTrackId,
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Incomplete track'
+            };
+            const incompletePlan = `
+## Phase 1
+- [x] Task 1
+- [ ] Task 2
+`;
+            writeFileSync(join(incompletePath, 'metadata.json'), JSON.stringify(incompleteMetadata, null, 2));
+            writeFileSync(join(incompletePath, 'plan.md'), incompletePlan);
+            const tracksContent = `# Project Tracks
+
+---
+
+- [~] **Track: Incomplete Track**
+*Link: [./tracks/${incompleteTrackId}/](./tracks/${incompleteTrackId}/)*
+
+---
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Run archival
+            const result = archiveCompletedTracks(testDir);
+            // Verify track was skipped
+            expect(result.skipped).toContain(incompleteTrackId);
+            expect(result.archived).not.toContain(incompleteTrackId);
+            // Verify track still in tracks/
+            expect(existsSync(incompletePath)).toBe(true);
+            expect(existsSync(join(archiveDir, incompleteTrackId))).toBe(false);
+        });
+        it('should handle multiple tracks correctly', () => {
+            // Create 2 completed tracks and 1 incomplete
+            const completed1 = 'completed_001';
+            const completed2 = 'completed_002';
+            const incomplete1 = 'incomplete_001';
+            for (const trackId of [completed1, completed2]) {
+                const trackPath = join(tracksDir, trackId);
+                mkdirSync(trackPath);
+                writeFileSync(join(trackPath, 'metadata.json'), JSON.stringify({
+                    track_id: trackId,
+                    type: 'feature',
+                    status: 'completed',
+                    created_at: '2026-01-19T00:00:00Z',
+                    updated_at: '2026-01-19T12:00:00Z',
+                    description: 'Completed'
+                }, null, 2));
+                writeFileSync(join(trackPath, 'plan.md'), '## Phase 1\n- [x] Task 1');
+            }
+            const incompletePath = join(tracksDir, incomplete1);
+            mkdirSync(incompletePath);
+            writeFileSync(join(incompletePath, 'metadata.json'), JSON.stringify({
+                track_id: incomplete1,
+                type: 'feature',
+                status: 'in_progress',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'In progress'
+            }, null, 2));
+            writeFileSync(join(incompletePath, 'plan.md'), '## Phase 1\n- [x] Task 1');
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: Completed 1**
+*Link: [./tracks/${completed1}/](./tracks/${completed1}/)*
+
+---
+
+- [x] **Track: Completed 2**
+*Link: [./tracks/${completed2}/](./tracks/${completed2}/)*
+
+---
+
+- [~] **Track: Incomplete 1**
+*Link: [./tracks/${incomplete1}/](./tracks/${incomplete1}/)*
+
+---
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Run archival
+            const result = archiveCompletedTracks(testDir);
+            // Verify results
+            expect(result.archived).toHaveLength(2);
+            expect(result.archived).toContain(completed1);
+            expect(result.archived).toContain(completed2);
+            expect(result.skipped).toContain(incomplete1);
+            // Verify filesystem state
+            expect(existsSync(join(tracksDir, completed1))).toBe(false);
+            expect(existsSync(join(tracksDir, completed2))).toBe(false);
+            expect(existsSync(join(tracksDir, incomplete1))).toBe(true);
+            expect(existsSync(join(archiveDir, completed1))).toBe(true);
+            expect(existsSync(join(archiveDir, completed2))).toBe(true);
+        });
+        it('should handle tracks with missing metadata.json gracefully', () => {
+            const trackId = 'missing_metadata_001';
+            const trackPath = join(tracksDir, trackId);
+            mkdirSync(trackPath);
+            writeFileSync(join(trackPath, 'plan.md'), '## Phase 1\n- [x] Task 1');
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: Missing Metadata**
+*Link: [./tracks/${trackId}/](./tracks/${trackId}/)*
+
+---
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Run archival
+            const result = archiveCompletedTracks(testDir);
+            // Should record an error
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].trackId).toBe(trackId);
+            // Track should still exist
+            expect(existsSync(trackPath)).toBe(true);
+        });
+    });
+});

package/dist/utils/codebaseAnalysis.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Codebase Analysis Module
+ *
+ * Analyzes existing codebases to extract context for brownfield projects:
+ * - Ignore patterns from various ignore files
+ * - Dependency manifests with metadata
+ * - Architecture patterns (Monorepo, MVC, Microservices, etc.)
+ * - Programming languages and frameworks
+ *
+ * Based on reference implementations:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+export interface IgnorePattern {
+    pattern: string;
+    negated: boolean;
+}
+export interface ManifestInfo {
+    type: 'package.json' | 'pom.xml' | 'requirements.txt' | 'go.mod' | 'Cargo.toml' | 'Gemfile';
+    path: string;
+    metadata: Record<string, any>;
+    dependencies?: Record<string, string>;
+}
+export interface CodebaseAnalysis {
+    languages: Record<string, number>;
+    frameworks: {
+        frontend: string[];
+        backend: string[];
+    };
+    databases: string[];
+    architecture: string[];
+    manifests: ManifestInfo[];
+    projectGoal?: string;
+}
+/**
+ * Parse ignore files with precedence: .geminiignore > .ignore > .gitignore
+ */
+export declare function parseIgnoreFiles(projectPath: string): IgnorePattern[];
+/**
+ * Detect and parse dependency manifests
+ */
+export declare function detectManifests(projectPath: string): ManifestInfo[];
+/**
+ * Infer architecture patterns from project structure
+ */
+export declare function inferArchitecture(projectPath: string): string[];
+/**
+ * Detect programming languages by file extensions
+ */
+export declare function detectLanguages(projectPath: string): Record<string, number>;
+/**
+ * Detect frameworks from manifests
+ */
+export declare function detectFrameworks(manifests: ManifestInfo[]): {
+    frontend: string[];
+    backend: string[];
+};
+/**
+ * Main function: Analyze entire codebase
+ */
+export declare function analyzeCodebase(projectPath: string): CodebaseAnalysis;