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

package/dist/prompts/cdd/setup.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeAll } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
 
-describe('setup.json prompt structure', () => {
+describe('setup.json prompt structure (interactive, code-driven)', () => {
   let setupPrompt: string;
 
   beforeAll(() => {
@@ -11,158 +11,55 @@ describe('setup.json prompt structure', () => {
     setupPrompt = setupJson.prompt;
   });
 
-  describe('Autogenerate option mandate', () => {
-    const requiredText = 'E) Autogenerate and review';
-    const mandatoryInstructionPattern = /\*\*Mandatory:\*\*.*autogenerate and review/is;
-
-    it('should contain Section 2.1 (Product Guide) with autogenerate mandate', () => {
-      expect(setupPrompt).toContain('### 2.1 Generate Product Guide');
-      
-      const section21Start = setupPrompt.indexOf('### 2.1 Generate Product Guide');
-      const section22Start = setupPrompt.indexOf('### 2.2 Generate Product Guidelines');
-      const section21 = setupPrompt.substring(section21Start, section22Start);
-      
-      expect(section21).toMatch(mandatoryInstructionPattern);
-      expect(section21).toContain(requiredText);
-    });
-
-    it('should contain Section 2.2 (Product Guidelines) with autogenerate mandate', () => {
-      expect(setupPrompt).toContain('### 2.2 Generate Product Guidelines');
-      
-      const section22Start = setupPrompt.indexOf('### 2.2 Generate Product Guidelines');
-      const section23Start = setupPrompt.indexOf('### 2.3 Define Technology Stack');
-      const section22 = setupPrompt.substring(section22Start, section23Start);
-      
-      expect(section22).toMatch(mandatoryInstructionPattern);
-      expect(section22).toContain(requiredText);
-    });
-
-    it('should contain Section 2.3 (Tech Stack) with autogenerate mandate', () => {
-      expect(setupPrompt).toContain('### 2.3 Define Technology Stack');
-      
-      const section23Start = setupPrompt.indexOf('### 2.3 Define Technology Stack');
-      const section24Start = setupPrompt.indexOf('### 2.4 Select Code Styleguides');
-      const section23 = setupPrompt.substring(section23Start, section24Start);
-      
-      expect(section23).toMatch(mandatoryInstructionPattern);
-      expect(section23).toContain(requiredText);
-    });
-
-    it('should contain Section 2.4 (Code Styleguides) with autogenerate mandate', () => {
-      expect(setupPrompt).toContain('### 2.4 Select Code Styleguides');
-      
-      const section24Start = setupPrompt.indexOf('### 2.4 Select Code Styleguides');
-      const section25Start = setupPrompt.indexOf('### 2.5 Define Workflow');
-      const section24 = setupPrompt.substring(section24Start, section25Start);
-      
-      expect(section24).toMatch(mandatoryInstructionPattern);
-      expect(section24).toContain(requiredText);
-    });
+  it('should have description and prompt fields', () => {
+    const setupJsonPath = path.join(__dirname, 'setup.json');
+    const setupJson = JSON.parse(fs.readFileSync(setupJsonPath, 'utf-8'));
 
-    it('should contain Section 2.5 (Workflow) with autogenerate mandate', () => {
-      expect(setupPrompt).toContain('### 2.5 Define Workflow');
-      
-      const section25Start = setupPrompt.indexOf('### 2.5 Define Workflow');
-      const section30Start = setupPrompt.indexOf('## 3.0 INITIAL TRACK');
-      const section25 = setupPrompt.substring(section25Start, section30Start);
-      
-      expect(section25).toMatch(mandatoryInstructionPattern);
-      expect(section25).toContain(requiredText);
-    });
+    expect(setupJson).toHaveProperty('description');
+    expect(setupJson.description).toBeTruthy();
+    expect(setupJson).toHaveProperty('prompt');
+    expect(typeof setupJson.prompt).toBe('string');
+    expect(setupJson.prompt).toBeTruthy();
   });
 
-  describe('Sequential questioning instructions', () => {
-    const sequentialPattern = /ask questions sequentially.*one by one/is;
-
-    it('should enforce sequential questioning in Section 2.1', () => {
-      const section21Start = setupPrompt.indexOf('### 2.1 Generate Product Guide');
-      const section22Start = setupPrompt.indexOf('### 2.2 Generate Product Guidelines');
-      const section21 = setupPrompt.substring(section21Start, section22Start);
-      
-      expect(section21).toMatch(sequentialPattern);
-    });
-
-    it('should enforce sequential questioning in Section 2.2', () => {
-      const section22Start = setupPrompt.indexOf('### 2.2 Generate Product Guidelines');
-      const section23Start = setupPrompt.indexOf('### 2.3 Define Technology Stack');
-      const section22 = setupPrompt.substring(section22Start, section23Start);
-      
-      expect(section22).toMatch(sequentialPattern);
-    });
-
-    it('should enforce sequential questioning in Section 2.4', () => {
-      const section24Start = setupPrompt.indexOf('### 2.4 Select Code Styleguides');
-      const section25Start = setupPrompt.indexOf('### 2.5 Define Workflow');
-      const section24 = setupPrompt.substring(section24Start, section25Start);
-      
-      expect(section24).toMatch(sequentialPattern);
-    });
-
-    it('should enforce sequential questioning in Section 2.5', () => {
-      const section25Start = setupPrompt.indexOf('### 2.5 Define Workflow');
-      const section30Start = setupPrompt.indexOf('## 3.0 INITIAL TRACK');
-      const section25 = setupPrompt.substring(section25Start, section30Start);
-      
-      expect(section25).toMatch(sequentialPattern);
-    });
+  it('should describe interactive, auto-generated setup', () => {
+    expect(setupPrompt).toContain('CDD SETUP');
+    expect(setupPrompt.toLowerCase()).toContain('interactive');
+    expect(setupPrompt.toLowerCase()).toContain('auto');
+    expect(setupPrompt.toLowerCase()).toContain('code-driven');
   });
 
-  describe('Basic prompt structure validation', () => {
-    it('should have description field', () => {
-      const setupJsonPath = path.join(__dirname, 'setup.json');
-      const setupJson = JSON.parse(fs.readFileSync(setupJsonPath, 'utf-8'));
-      
-      expect(setupJson).toHaveProperty('description');
-      expect(setupJson.description).toBeTruthy();
-    });
-
-    it('should have prompt field', () => {
-      const setupJsonPath = path.join(__dirname, 'setup.json');
-      const setupJson = JSON.parse(fs.readFileSync(setupJsonPath, 'utf-8'));
-      
-      expect(setupJson).toHaveProperty('prompt');
-      expect(setupJson.prompt).toBeTruthy();
-      expect(typeof setupJson.prompt).toBe('string');
-    });
+  it('should reference the TypeScript implementation entry point', () => {
+    expect(setupPrompt).toContain('src/utils/interactiveSetup.ts');
+    expect(setupPrompt).toContain('executeInteractiveSetup');
+    expect(setupPrompt).toContain('generateSetupSummary');
+  });
 
-    it('should contain all major setup phases', () => {
-      expect(setupPrompt).toContain('## 1.0 SYSTEM DIRECTIVE');
-      expect(setupPrompt).toContain('## 1.1 BEGIN `RESUME` CHECK');
-      expect(setupPrompt).toContain('## 1.3 PROJECT MATURITY DETECTION');
-      expect(setupPrompt).toContain('## 2.0 INITIALIZATION PHASE');
-      expect(setupPrompt).toContain('## 3.0 INITIAL TRACK');
-      expect(setupPrompt).toContain('## 4.0 COMPLETION');
-    });
+  it('should mandate 5 options per question (A-E)', () => {
+    expect(setupPrompt).toContain('A-C');
+    expect(setupPrompt).toContain('D');
+    expect(setupPrompt).toContain('E');
+    expect(setupPrompt).toContain('A, B, C, D, E');
+  });
 
-    it('should contain all 5 interactive sections', () => {
-      expect(setupPrompt).toContain('### 2.1 Generate Product Guide');
-      expect(setupPrompt).toContain('### 2.2 Generate Product Guidelines');
-      expect(setupPrompt).toContain('### 2.3 Define Technology Stack');
-      expect(setupPrompt).toContain('### 2.4 Select Code Styleguides');
-      expect(setupPrompt).toContain('### 2.5 Define Workflow');
-    });
+  it('should mention all 5 output documents', () => {
+    expect(setupPrompt).toContain('conductor-cdd/product.md');
+    expect(setupPrompt).toContain('conductor-cdd/guidelines.md');
+    expect(setupPrompt).toContain('conductor-cdd/tech-stack.md');
+    expect(setupPrompt).toContain('conductor-cdd/styleguides.md');
+    expect(setupPrompt).toContain('conductor-cdd/workflow.md');
   });
 
-  describe('Backward compatibility', () => {
-    it('should maintain existing resume logic', () => {
-      expect(setupPrompt).toContain('last_successful_step');
-      expect(setupPrompt).toContain('setup_state.json');
-      expect(setupPrompt).toContain('2.1_product_guide');
-      expect(setupPrompt).toContain('2.2_product_guidelines');
-      expect(setupPrompt).toContain('2.3_tech_stack');
-      expect(setupPrompt).toContain('2.4_code_styleguides');
-      expect(setupPrompt).toContain('2.5_workflow');
-    });
+  it('should describe resume behavior and expected checkpoints', () => {
+    expect(setupPrompt).toContain('conductor-cdd/setup_state.json');
+    expect(setupPrompt).toContain('last_successful_step');
 
-    it('should maintain brownfield detection logic', () => {
-      expect(setupPrompt).toContain('BROWNFIELD');
-      expect(setupPrompt).toContain('GREENFIELD');
-      expect(setupPrompt).toContain('PROJECT MATURITY DETECTION');
-    });
+    expect(setupPrompt).toContain('2.1_product_guide');
+    expect(setupPrompt).toContain('2.2_product_guidelines');
+    expect(setupPrompt).toContain('2.3_tech_stack');
+    expect(setupPrompt).toContain('2.4_code_styleguides');
+    expect(setupPrompt).toContain('2.5_workflow');
 
-    it('should allow manual Q&A flow (no hard requirement for autogenerate)', () => {
-      expect(setupPrompt).not.toContain('MUST autogenerate');
-      expect(setupPrompt).not.toContain('MUST use autogenerate');
-    });
+    expect(setupPrompt).toContain('cdd:setup');
   });
 });

package/dist/test/integration/rebrand.test.js

@@ -2,6 +2,7 @@ import { describe, it, expect } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
 describe('Rebrand Integration Tests', () => {
+    const LEGACY_AGENT_NAME = 'orche' + 'strator';
     describe('Package Metadata', () => {
         it('should have correct package name', () => {
             const pkgPath = path.join(process.cwd(), 'package.json');
@@ -17,7 +18,7 @@ describe('Rebrand Integration Tests', () => {
             const pkgPath = path.join(process.cwd(), 'package.json');
             const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
             expect(pkg.repository.url).toContain('opencode-conductor-cdd');
-            expect(pkg.repository.url).not.toContain('opencode-orchestrator');
+            expect(pkg.repository.url).not.toContain('opencode-' + LEGACY_AGENT_NAME);
         });
     });
     describe('Prompt Files Structure', () => {
@@ -25,9 +26,9 @@ describe('Rebrand Integration Tests', () => {
             const cddPromptsPath = path.join(process.cwd(), 'src/prompts/cdd');
             expect(fs.existsSync(cddPromptsPath)).toBe(true);
         });
-        it('should NOT have orchestrator prompts directory', () => {
-            const orchestratorPromptsPath = path.join(process.cwd(), 'src/prompts/orchestrator');
-            expect(fs.existsSync(orchestratorPromptsPath)).toBe(false);
+        it('should NOT have legacy prompts directory', () => {
+            const legacyPromptsPath = path.join(process.cwd(), 'src/prompts/' + LEGACY_AGENT_NAME);
+            expect(fs.existsSync(legacyPromptsPath)).toBe(false);
         });
         it('should have all required CDD prompt files', () => {
             const cddPromptsPath = path.join(process.cwd(), 'src/prompts/cdd');
@@ -41,9 +42,9 @@ describe('Rebrand Integration Tests', () => {
             const cddAgentPath = path.join(process.cwd(), 'src/prompts/agent/cdd.md');
             expect(fs.existsSync(cddAgentPath)).toBe(true);
         });
-        it('should NOT have orchestrator agent prompt file', () => {
-            const orchestratorAgentPath = path.join(process.cwd(), 'src/prompts/agent/orchestrator.md');
-            expect(fs.existsSync(orchestratorAgentPath)).toBe(false);
+        it('should NOT have legacy agent prompt file', () => {
+            const legacyAgentPath = path.join(process.cwd(), 'src/prompts/agent/' + LEGACY_AGENT_NAME + '.md');
+            expect(fs.existsSync(legacyAgentPath)).toBe(false);
         });
     });
     describe('Source Code References', () => {
@@ -53,7 +54,7 @@ describe('Rebrand Integration Tests', () => {
             expect(indexContent).toContain('./prompts/cdd/implement.json');
             expect(indexContent).toContain('./prompts/cdd/newTrack.json');
             expect(indexContent).toContain('./prompts/cdd/setup.json');
-            expect(indexContent).not.toContain('./prompts/orchestrator/');
+            expect(indexContent).not.toContain('./prompts/' + LEGACY_AGENT_NAME + '/');
         });
         it('should register cdd: commands in index.ts', () => {
             const indexPath = path.join(process.cwd(), 'src/index.ts');
@@ -63,7 +64,7 @@ describe('Rebrand Integration Tests', () => {
             expect(indexContent).toContain('"cdd:setup"');
             expect(indexContent).toContain('"cdd:status"');
             expect(indexContent).toContain('"cdd:revert"');
-            expect(indexContent).not.toContain('"orchestrator:');
+            expect(indexContent).not.toContain('"' + LEGACY_AGENT_NAME + ':');
         });
         it('should reference conductor-cdd directory in index.ts', () => {
             const indexPath = path.join(process.cwd(), 'src/index.ts');
@@ -81,7 +82,7 @@ describe('Rebrand Integration Tests', () => {
             const stateManagerPath = path.join(process.cwd(), 'src/utils/stateManager.ts');
             const content = fs.readFileSync(stateManagerPath, 'utf-8');
             expect(content).toContain('conductor-cdd');
-            expect(content).not.toContain('orchestrator/');
+            expect(content).not.toContain(LEGACY_AGENT_NAME + '/');
         });
         it('should use detectCDDConfig function name', () => {
             const configDetectionPath = path.join(process.cwd(), 'src/utils/configDetection.ts');
@@ -93,7 +94,7 @@ describe('Rebrand Integration Tests', () => {
             const commitMessagesPath = path.join(process.cwd(), 'src/utils/commitMessages.ts');
             const content = fs.readFileSync(commitMessagesPath, 'utf-8');
             expect(content).toContain('cdd(');
-            expect(content).not.toContain('orchestrator(');
+            expect(content).not.toContain(LEGACY_AGENT_NAME + '(');
         });
     });
     describe('README Documentation', () => {
@@ -109,10 +110,10 @@ describe('Rebrand Integration Tests', () => {
             expect(content).toContain('/cdd:newTrack');
             expect(content).toContain('/cdd:implement');
         });
-        it('should NOT reference orchestrator commands in README', () => {
+        it('should NOT reference legacy commands in README', () => {
             const readmePath = path.join(process.cwd(), 'README.md');
             const content = fs.readFileSync(readmePath, 'utf-8');
-            expect(content).not.toContain('/orchestrator:');
+            expect(content).not.toContain('/' + LEGACY_AGENT_NAME + ':');
         });
     });
     describe('Build Scripts', () => {
@@ -120,7 +121,7 @@ describe('Rebrand Integration Tests', () => {
             const scriptPath = path.join(process.cwd(), 'scripts/convert-legacy.cjs');
             const content = fs.readFileSync(scriptPath, 'utf-8');
             expect(content).toContain('src/prompts/cdd');
-            expect(content).not.toContain('src/prompts/orchestrator');
+            expect(content).not.toContain('src/prompts/' + LEGACY_AGENT_NAME);
         });
     });
 });

package/dist/utils/agentMapping.js

@@ -14,6 +14,8 @@ const SLIM_AGENT_MAPPING = {
     'librarian': 'librarian',
     // Agents without slim equivalent
     'sisyphus': null,
+    // Legacy name (oh-my-opencode-slim compatibility)
+    // See: https://github.com/alvinunreal/oh-my-opencode-slim
     'orchestrator': null,
 };
 /**

package/dist/utils/archive-tracks.d.ts

@@ -23,3 +23,31 @@ export interface TrackPlan {
         completed: boolean;
     }[];
 }
+/**
+ * Parses metadata.json content and validates required fields
+ */
+export declare function parseMetadata(jsonContent: string): TrackMetadata;
+/**
+ * Checks if all tasks in a plan.md file are marked as completed
+ * Looks for task markers: [x] = complete, [ ] = incomplete, [~] = in-progress
+ */
+export declare function isPlanFullyCompleted(planContent: string): boolean;
+/**
+ * Determines if a track is finished by checking both metadata status and plan completion
+ */
+export declare function isTrackFinished(metadata: TrackMetadata, planContent: string): boolean;
+/**
+ * Moves a track directory from tracks/ to archive/
+ * Creates the archive directory if it doesn't exist
+ */
+export declare function moveTrackToArchive(projectRoot: string, trackId: string): void;
+/**
+ * Removes a track entry from tracks.md registry file
+ * Handles the track block and its surrounding separator lines
+ */
+export declare function removeTrackFromRegistry(tracksFilePath: string, trackId: string): void;
+/**
+ * Main function to archive all completed tracks in a project
+ * Scans tracks/ directory, identifies completed tracks, and archives them
+ */
+export declare function archiveCompletedTracks(projectRoot: string): ArchiveResult;

package/dist/utils/archive-tracks.js

@@ -1 +1,154 @@
-export {};
+/**
+ * Parses metadata.json content and validates required fields
+ */
+export function parseMetadata(jsonContent) {
+    const data = JSON.parse(jsonContent);
+    // Validate required fields
+    const requiredFields = ['track_id', 'type', 'status', 'created_at', 'updated_at', 'description'];
+    for (const field of requiredFields) {
+        if (!(field in data)) {
+            throw new Error(`Invalid metadata: missing required field '${field}'`);
+        }
+    }
+    return data;
+}
+/**
+ * Checks if all tasks in a plan.md file are marked as completed
+ * Looks for task markers: [x] = complete, [ ] = incomplete, [~] = in-progress
+ */
+export function isPlanFullyCompleted(planContent) {
+    // Match all task markers: - [x], - [ ], - [~]
+    const taskRegex = /^[\s]*-\s*\[([x ~]|\s)\]/gm;
+    const matches = planContent.match(taskRegex);
+    // If no tasks found, consider it complete (no work to do)
+    if (!matches || matches.length === 0) {
+        return true;
+    }
+    // Check if all tasks are marked with [x]
+    return matches.every(match => match.includes('[x]'));
+}
+/**
+ * Determines if a track is finished by checking both metadata status and plan completion
+ */
+export function isTrackFinished(metadata, planContent) {
+    const isMetadataComplete = metadata.status === 'completed';
+    const isPlanComplete = isPlanFullyCompleted(planContent);
+    return isMetadataComplete && isPlanComplete;
+}
+/**
+ * Moves a track directory from tracks/ to archive/
+ * Creates the archive directory if it doesn't exist
+ */
+export function moveTrackToArchive(projectRoot, trackId) {
+    const { existsSync, mkdirSync } = require('fs');
+    const { join } = require('path');
+    const { execSync } = require('child_process');
+    const tracksDir = join(projectRoot, 'conductor-cdd', 'tracks');
+    const archiveDir = join(projectRoot, 'conductor-cdd', 'archive');
+    const sourcePath = join(tracksDir, trackId);
+    const destPath = join(archiveDir, trackId);
+    // Verify source exists
+    if (!existsSync(sourcePath)) {
+        throw new Error(`Track directory not found: ${sourcePath}`);
+    }
+    // Create archive directory if needed
+    if (!existsSync(archiveDir)) {
+        mkdirSync(archiveDir, { recursive: true });
+    }
+    // Use mv command to move the directory
+    execSync(`mv "${sourcePath}" "${destPath}"`);
+}
+/**
+ * Removes a track entry from tracks.md registry file
+ * Handles the track block and its surrounding separator lines
+ */
+export function removeTrackFromRegistry(tracksFilePath, trackId) {
+    const { readFileSync, writeFileSync } = require('fs');
+    let content = readFileSync(tracksFilePath, 'utf-8');
+    // Split by separator to get track blocks
+    const separator = '\n---\n';
+    const parts = content.split(separator);
+    // Filter out the block containing the trackId
+    const filteredParts = parts.filter((part) => {
+        // Check if this part contains a link to the track we want to remove
+        return !part.includes(`./tracks/${trackId}/`);
+    });
+    // If nothing was filtered, track wasn't found - that's okay
+    if (filteredParts.length === parts.length) {
+        return;
+    }
+    // Rejoin with separator
+    content = filteredParts.join(separator);
+    writeFileSync(tracksFilePath, content, 'utf-8');
+}
+/**
+ * Main function to archive all completed tracks in a project
+ * Scans tracks/ directory, identifies completed tracks, and archives them
+ */
+export function archiveCompletedTracks(projectRoot) {
+    const { readdirSync, readFileSync, existsSync } = require('fs');
+    const { join } = require('path');
+    const result = {
+        archived: [],
+        skipped: [],
+        errors: []
+    };
+    const cddDir = join(projectRoot, 'conductor-cdd');
+    const tracksDir = join(cddDir, 'tracks');
+    const tracksFile = join(cddDir, 'tracks.md');
+    // Check if tracks directory exists
+    if (!existsSync(tracksDir)) {
+        return result;
+    }
+    // Get all track directories
+    const trackDirs = readdirSync(tracksDir, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+    // Process each track
+    for (const trackId of trackDirs) {
+        try {
+            const trackPath = join(tracksDir, trackId);
+            const metadataPath = join(trackPath, 'metadata.json');
+            const planPath = join(trackPath, 'plan.md');
+            // Check if required files exist
+            if (!existsSync(metadataPath)) {
+                result.errors.push({
+                    trackId,
+                    error: 'metadata.json not found'
+                });
+                continue;
+            }
+            if (!existsSync(planPath)) {
+                result.errors.push({
+                    trackId,
+                    error: 'plan.md not found'
+                });
+                continue;
+            }
+            // Parse metadata and plan
+            const metadataContent = readFileSync(metadataPath, 'utf-8');
+            const planContent = readFileSync(planPath, 'utf-8');
+            const metadata = parseMetadata(metadataContent);
+            // Check if track is finished
+            if (isTrackFinished(metadata, planContent)) {
+                // Archive the track
+                moveTrackToArchive(projectRoot, trackId);
+                // Remove from tracks.md if it exists
+                if (existsSync(tracksFile)) {
+                    removeTrackFromRegistry(tracksFile, trackId);
+                }
+                result.archived.push(trackId);
+            }
+            else {
+                result.skipped.push(trackId);
+            }
+        }
+        catch (error) {
+            result.errors.push({
+                trackId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    return result;
+}

package/dist/utils/archive-tracks.test.d.ts

@@ -0,0 +1 @@
+export {};