@iservu-inc/adf-cli 0.1.6 → 0.3.0

package/lib/frameworks/session-manager.js

@@ -0,0 +1,100 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+/**
+ * Session Manager
+ * Manages interview sessions - list, resume, delete
+ */
+
+class SessionManager {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.sessionsDir = path.join(projectPath, '.adf', 'sessions');
+  }
+
+  async listSessions() {
+    await fs.ensureDir(this.sessionsDir);
+    const sessions = await fs.readdir(this.sessionsDir);
+
+    const sessionDetails = [];
+
+    for (const sessionId of sessions) {
+      const sessionPath = path.join(this.sessionsDir, sessionId);
+      const progressFile = path.join(sessionPath, '_progress.json');
+
+      if (await fs.pathExists(progressFile)) {
+        const progress = await fs.readJson(progressFile);
+        sessionDetails.push({
+          sessionId,
+          sessionPath,
+          progress
+        });
+      }
+    }
+
+    return sessionDetails;
+  }
+
+  async getResumableSessions() {
+    const sessions = await this.listSessions();
+    return sessions.filter(s => s.progress.status === 'in-progress' && s.progress.canResume);
+  }
+
+  async promptToResume() {
+    const resumableSessions = await this.getResumableSessions();
+
+    if (resumableSessions.length === 0) {
+      return null; // No sessions to resume
+    }
+
+    console.log(chalk.cyan.bold('\n📂 Found Previous Interview Sessions\n'));
+
+    const choices = resumableSessions.map(s => {
+      const framework = s.sessionId.split('_').pop();
+      const date = new Date(s.progress.lastUpdated).toLocaleString();
+      const completion = Math.round((s.progress.completedBlocks.length / s.progress.totalBlocks) * 100);
+
+      return {
+        name: `${framework.toUpperCase()} | ${date} | ${completion}% complete (${s.progress.totalQuestionsAnswered} questions)`,
+        value: s.sessionId,
+        short: s.sessionId
+      };
+    });
+
+    choices.push({
+      name: chalk.gray('Start a new interview'),
+      value: 'new',
+      short: 'New interview'
+    });
+
+    const { choice } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'choice',
+        message: 'Resume previous interview or start new?',
+        choices
+      }
+    ]);
+
+    if (choice === 'new') {
+      return null;
+    }
+
+    const session = resumableSessions.find(s => s.sessionId === choice);
+    return session;
+  }
+
+  async deleteSession(sessionId) {
+    const sessionPath = path.join(this.sessionsDir, sessionId);
+    await fs.remove(sessionPath);
+  }
+
+  async deleteAllSessions() {
+    await fs.remove(this.sessionsDir);
+    await fs.ensureDir(this.sessionsDir);
+  }
+}
+
+module.exports = SessionManager;

package/lib/generators/agents-md-generator.js

@@ -0,0 +1,388 @@
+const ToolConfigGenerator = require('./tool-config-generator');
+
+/**
+ * Generator for AGENTS.md - Universal AI coding agent instructions
+ * Supported by: OpenAI Codex, Cursor, Windsurf, Google Jules, Factory, and more
+ *
+ * AGENTS.md is the industry standard open format for AI agent configuration
+ * See: https://agents.md/ and https://github.com/openai/agents.md
+ */
+class AgentsMdGenerator extends ToolConfigGenerator {
+  /**
+   * Generate AGENTS.md from framework outputs
+   */
+  async generate() {
+    await this.initialize();
+
+    let content;
+    if (this.framework === 'rapid') {
+      content = this.generateFromPRP();
+    } else if (this.framework === 'balanced') {
+      content = this.generateFromBalanced();
+    } else if (this.framework === 'comprehensive') {
+      content = this.generateFromBMAD();
+    } else {
+      throw new Error(`Unknown framework: ${this.framework}`);
+    }
+
+    const filePath = await this.writeToProject('AGENTS.md', content);
+    return filePath;
+  }
+
+  /**
+   * Generate AGENTS.md from PRP framework
+   */
+  generateFromPRP() {
+    const projectName = this.getProjectName();
+    const sections = this.outputs.sections || {};
+
+    return `# ${projectName}
+
+## Overview
+
+${sections['1._goal_definition'] || sections['goal_definition'] || 'AI-powered software development project'}
+
+## Tech Stack
+
+${this.extractTechStack(sections)}
+
+## Build Commands
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Build project
+npm run build
+\`\`\`
+
+## Test Commands
+
+\`\`\`bash
+# Run tests
+npm test
+
+# Run tests with coverage
+npm run test:coverage
+\`\`\`
+
+## Implementation Blueprint
+
+${sections['4._implementation_blueprint'] || sections['implementation_blueprint'] || ''}
+
+## Success Criteria
+
+${sections['5._validation'] || sections['validation'] || ''}
+
+## Development Workflow
+
+1. Review the goal and requirements
+2. Check the implementation blueprint
+3. Write tests first (if applicable)
+4. Implement feature following the blueprint
+5. Verify against success criteria
+6. Test thoroughly before committing
+
+## Key Context
+
+All project requirements and context are documented in:
+- Framework outputs: \`.adf/sessions/${this.getSessionId()}/outputs/\`
+- Q&A responses: \`.adf/sessions/${this.getSessionId()}/qa-responses/\`
+
+## AI Agent Instructions
+
+When working on this project:
+1. **Read the full context** in \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
+2. **Follow the implementation blueprint** exactly as specified
+3. **Validate against success criteria** before marking tasks complete
+4. **Ask clarifying questions** if requirements are unclear
+5. **Maintain consistency** with the tech stack and architecture
+
+---
+
+*Generated by [ADF CLI](https://www.npmjs.com/package/@iservu-inc/adf-cli) v${this.getADFVersion()}*
+`;
+  }
+
+  /**
+   * Generate AGENTS.md from Balanced framework
+   */
+  generateFromBalanced() {
+    const projectName = this.getProjectName();
+    const constitution = this.outputs.constitution || '';
+    const specification = this.outputs.specification || '';
+    const plan = this.outputs.plan || '';
+
+    const principles = this.extractSection(constitution, 'Core Principles');
+    const constraints = this.extractSection(constitution, 'Constraints');
+    const architecture = this.extractSection(specification, 'Architecture');
+    const techStack = this.extractSection(plan, 'Technology Stack');
+
+    return `# ${projectName}
+
+## Overview
+
+${this.extractSection(specification, 'Overview') || this.extractSection(specification, 'Purpose')}
+
+## Constitution
+
+### Core Principles
+
+${principles || 'Follow best practices for software development'}
+
+### Constraints
+
+${constraints || 'No specific constraints defined'}
+
+## Tech Stack
+
+${techStack || 'See technical plan for details'}
+
+## Architecture
+
+${architecture || 'See specification.md for complete architecture'}
+
+## Build Commands
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Build project
+npm run build
+
+# Run in development mode
+npm run dev
+\`\`\`
+
+## Test Commands
+
+\`\`\`bash
+# Run tests
+npm test
+
+# Run tests with coverage
+npm run test:coverage
+
+# Run linter
+npm run lint
+\`\`\`
+
+## Development Workflow
+
+1. Review the constitution and principles
+2. Check the specification for requirements
+3. Consult the technical plan for architecture decisions
+4. Review tasks.md for implementation breakdown
+5. Write tests first (TDD approach)
+6. Implement following architecture patterns
+7. Verify against acceptance criteria
+8. Run tests and linter before committing
+
+## Code Style
+
+See technical plan for detailed coding standards.
+
+**Key Points:**
+- Follow the architecture patterns defined in specification.md
+- Adhere to the constraints in constitution.md
+- Implement tasks as outlined in tasks.md
+
+## Key Context Files
+
+- **Constitution**: \`.adf/sessions/${this.getSessionId()}/outputs/constitution.md\` - Principles and constraints
+- **Specification**: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\` - Detailed requirements
+- **Technical Plan**: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\` - Architecture and decisions
+- **Tasks**: \`.adf/sessions/${this.getSessionId()}/outputs/tasks.md\` - Implementation breakdown
+
+## AI Agent Instructions
+
+When working on this project:
+
+1. **Read the constitution first** - Understand principles and constraints
+2. **Review the specification** - Know what needs to be built
+3. **Check the technical plan** - Follow architectural decisions
+4. **Reference tasks.md** - Understand implementation phases
+5. **Never violate constraints** - These are non-negotiable
+6. **Ask before deviating** - If architecture changes are needed
+7. **Maintain consistency** - With established patterns and decisions
+
+---
+
+*Generated by [ADF CLI](https://www.npmjs.com/package/@iservu-inc/adf-cli) v${this.getADFVersion()}*
+`;
+  }
+
+  /**
+   * Generate AGENTS.md from BMAD framework
+   */
+  generateFromBMAD() {
+    const projectName = this.getProjectName();
+    const prd = this.outputs.prd || '';
+    const architecture = this.outputs.architecture || '';
+
+    const overview = this.extractSection(prd, 'Executive Summary') ||
+                     this.extractSection(prd, 'Overview');
+    const goals = this.extractSection(prd, 'Goals and Objectives');
+    const techRequirements = this.extractSection(prd, 'Technical Requirements') ||
+                             this.extractSection(prd, 'Technical Architecture');
+    const archOverview = this.extractSection(architecture, 'System Overview') ||
+                         this.extractSection(architecture, 'Architecture Overview');
+
+    return `# ${projectName}
+
+## Product Overview
+
+${overview || 'Comprehensive software development project'}
+
+## Goals and Objectives
+
+${goals || 'See PRD for detailed goals'}
+
+## Technical Requirements
+
+${techRequirements || 'See PRD for complete technical requirements'}
+
+## Architecture
+
+${archOverview || 'See architecture.md for complete system design'}
+
+## Build Commands
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Build project
+npm run build
+
+# Run in development mode
+npm run dev
+
+# Run production build
+npm run build:production
+\`\`\`
+
+## Test Commands
+
+\`\`\`bash
+# Run all tests
+npm test
+
+# Run tests with coverage
+npm run test:coverage
+
+# Run integration tests
+npm run test:integration
+
+# Run e2e tests
+npm run test:e2e
+
+# Run linter
+npm run lint
+\`\`\`
+
+## Development Workflow
+
+1. Review the PRD (Product Requirements Document)
+2. Understand the system architecture
+3. Review relevant user stories
+4. Plan implementation approach
+5. Write tests first (TDD)
+6. Implement following architecture patterns
+7. Verify against acceptance criteria
+8. Run full test suite
+9. Create pull request with description
+
+## Code Quality Standards
+
+- Maintain test coverage >= 80%
+- Follow architectural patterns defined in architecture.md
+- Implement user stories as specified in stories.md
+- Write clean, maintainable, documented code
+- Handle errors gracefully
+- Consider scalability and performance
+
+## Key Context Files
+
+- **PRD**: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\` - Complete product requirements
+- **Architecture**: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\` - System design and technical architecture
+- **User Stories**: \`.adf/sessions/${this.getSessionId()}/outputs/stories.md\` - Detailed user stories with acceptance criteria
+
+## AI Agent Instructions
+
+When working on this project:
+
+1. **Read the PRD thoroughly** - Understand the complete product vision
+2. **Study the architecture** - Know the system design and component structure
+3. **Review user stories** - Understand user needs and acceptance criteria
+4. **Follow architectural patterns** - Maintain consistency with established design
+5. **Implement with quality** - Tests, documentation, error handling
+6. **Think long-term** - Consider scalability, maintainability, performance
+7. **Validate against requirements** - Ensure implementation matches PRD
+8. **Ask before major changes** - Architectural decisions should be discussed
+
+## Security Notes
+
+- Never commit sensitive data (API keys, passwords, tokens)
+- Use environment variables for configuration
+- Validate all user input
+- Follow security best practices
+- See PRD for specific security requirements
+
+## Performance Considerations
+
+- Follow performance requirements in PRD
+- Optimize critical paths
+- Monitor resource usage
+- See architecture.md for performance patterns
+
+---
+
+*Generated by [ADF CLI](https://www.npmjs.com/package/@iservu-inc/adf-cli) v${this.getADFVersion()}*
+`;
+  }
+
+  /**
+   * Extract tech stack from PRP sections
+   */
+  extractTechStack(sections) {
+    const contextualIntelligence = sections['3._contextual_intelligence'] ||
+                                   sections['contextual_intelligence'] || '';
+
+    // Look for tech stack mentions
+    const lines = contextualIntelligence.split('\n');
+    const techLines = [];
+    let inTechSection = false;
+
+    for (const line of lines) {
+      if (line.toLowerCase().includes('tech') ||
+          line.toLowerCase().includes('stack') ||
+          line.toLowerCase().includes('technology')) {
+        inTechSection = true;
+      }
+      if (inTechSection && line.trim()) {
+        techLines.push(line);
+      }
+      if (line.startsWith('##') && inTechSection && techLines.length > 0) {
+        break;
+      }
+    }
+
+    return techLines.length > 0 ? techLines.join('\n') : 'See framework outputs for tech stack details';
+  }
+
+  /**
+   * Get ADF CLI version
+   */
+  getADFVersion() {
+    try {
+      const packageJson = require('../../package.json');
+      return packageJson.version;
+    } catch (error) {
+      return '0.2.0';
+    }
+  }
+}
+
+module.exports = AgentsMdGenerator;