den-github-manager 1.0.0

package/src/core/analyzer.js

@@ -0,0 +1,266 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { Logger } from '../utils/logger.js';
+
+export class Analyzer {
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+    this.logger = new Logger();
+  }
+
+  /**
+   * Analyze project and return comprehensive report
+   */
+  async analyze() {
+    this.logger.info('🔍 Analyzing project structure...');
+
+    const analysis = {
+      projectPath: this.projectPath,
+      projectName: path.basename(this.projectPath),
+      hasGit: await this.checkGit(),
+      hasBacklog: await this.checkBacklog(),
+      hasREADME: await this.checkREADME(),
+      hasPackageJson: await this.checkPackageJson(),
+      hasDocumentation: await this.checkDocumentation(),
+      existingIssues: await this.checkExistingIssues(),
+      existingMilestones: await this.checkExistingMilestones(),
+      projectType: await this.detectProjectType(),
+      techStack: await this.detectTechStack(),
+      phase: await this.detectPhase(),
+      filesStructure: await this.analyzeStructure()
+    };
+
+    return analysis;
+  }
+
+  async checkGit() {
+    try {
+      await fs.access(path.join(this.projectPath, '.git'));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async checkBacklog() {
+    const possiblePaths = [
+      'docs/backlog.md',
+      'BACKLOG.md',
+      'docs/BACKLOG.md',
+      'documentation/backlog.md'
+    ];
+
+    for (const p of possiblePaths) {
+      try {
+        const fullPath = path.join(this.projectPath, p);
+        await fs.access(fullPath);
+        return { exists: true, path: p };
+      } catch {
+        continue;
+      }
+    }
+
+    return { exists: false, path: null };
+  }
+
+  async checkREADME() {
+    try {
+      const readmePath = path.join(this.projectPath, 'README.md');
+      const content = await fs.readFile(readmePath, 'utf-8');
+
+      return {
+        exists: true,
+        hasRoadmap: /roadmap/i.test(content),
+        hasFeatures: /features/i.test(content),
+        hasTODO: /todo|to-do/i.test(content),
+        length: content.length
+      };
+    } catch {
+      return { exists: false };
+    }
+  }
+
+  async checkPackageJson() {
+    try {
+      const pkgPath = path.join(this.projectPath, 'package.json');
+      const content = await fs.readFile(pkgPath, 'utf-8');
+      const pkg = JSON.parse(content);
+
+      return {
+        exists: true,
+        name: pkg.name,
+        version: pkg.version,
+        scripts: Object.keys(pkg.scripts || {}),
+        dependencies: Object.keys(pkg.dependencies || {}).length
+      };
+    } catch {
+      return { exists: false };
+    }
+  }
+
+  async checkDocumentation() {
+    const docPaths = ['docs', 'documentation', 'doc'];
+
+    for (const dir of docPaths) {
+      try {
+        const fullPath = path.join(this.projectPath, dir);
+        const stats = await fs.stat(fullPath);
+        if (stats.isDirectory()) {
+          const files = await fs.readdir(fullPath);
+          return {
+            exists: true,
+            path: dir,
+            files: files.filter(f => f.endsWith('.md')),
+            count: files.length
+          };
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    return { exists: false };
+  }
+
+  async checkExistingIssues() {
+    // This would require GitHub API integration
+    // For now, return placeholder
+    return {
+      checked: false,
+      count: 0,
+      message: 'GitHub API integration needed'
+    };
+  }
+
+  async checkExistingMilestones() {
+    // This would require GitHub API integration
+    return {
+      checked: false,
+      count: 0,
+      message: 'GitHub API integration needed'
+    };
+  }
+
+  async detectProjectType() {
+    const indicators = {
+      'package.json': 'nodejs',
+      'requirements.txt': 'python',
+      'Cargo.toml': 'rust',
+      'go.mod': 'go',
+      'pom.xml': 'java',
+      'Gemfile': 'ruby',
+      'composer.json': 'php'
+    };
+
+    for (const [file, type] of Object.entries(indicators)) {
+      try {
+        await fs.access(path.join(this.projectPath, file));
+        return type;
+      } catch {
+        continue;
+      }
+    }
+
+    return 'unknown';
+  }
+
+  async detectTechStack() {
+    const stack = [];
+
+    // Check package.json for JavaScript/TypeScript
+    try {
+      const pkgPath = path.join(this.projectPath, 'package.json');
+      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      if (deps.react) stack.push('React');
+      if (deps.next) stack.push('Next.js');
+      if (deps.vue) stack.push('Vue');
+      if (deps.express) stack.push('Express');
+      if (deps.typescript) stack.push('TypeScript');
+    } catch {}
+
+    return stack;
+  }
+
+  async detectPhase() {
+    // Detect project phase based on various indicators
+    const hasTests = await this.checkForTests();
+    const hasCI = await this.checkForCI();
+    const hasDocs = await this.checkDocumentation();
+
+    if (!hasTests && !hasCI && !hasDocs.exists) {
+      return 'new'; // Early stage
+    } else if (hasTests || hasDocs.exists) {
+      return 'development'; // Active development
+    } else if (hasTests && hasCI) {
+      return 'production'; // Mature project
+    }
+
+    return 'unknown';
+  }
+
+  async checkForTests() {
+    const testDirs = ['test', 'tests', '__tests__', 'spec'];
+
+    for (const dir of testDirs) {
+      try {
+        await fs.access(path.join(this.projectPath, dir));
+        return true;
+      } catch {
+        continue;
+      }
+    }
+
+    return false;
+  }
+
+  async checkForCI() {
+    try {
+      await fs.access(path.join(this.projectPath, '.github/workflows'));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async analyzeStructure() {
+    try {
+      const files = await fs.readdir(this.projectPath);
+
+      return {
+        hasSource: files.includes('src') || files.includes('lib'),
+        hasTests: files.includes('test') || files.includes('tests'),
+        hasPublic: files.includes('public'),
+        hasAssets: files.includes('assets'),
+        totalFiles: files.length
+      };
+    } catch {
+      return { error: 'Could not read directory' };
+    }
+  }
+
+  /**
+   * Generate a summary report
+   */
+  generateReport(analysis) {
+    this.logger.section('📊 Project Analysis Report');
+
+    this.logger.info(`Project: ${analysis.projectName}`);
+    this.logger.info(`Type: ${analysis.projectType}`);
+    this.logger.info(`Phase: ${analysis.phase}`);
+
+    if (analysis.techStack.length > 0) {
+      this.logger.info(`Tech Stack: ${analysis.techStack.join(', ')}`);
+    }
+
+    this.logger.section('📁 Resources');
+    this.logger.status(analysis.hasGit, 'Git repository');
+    this.logger.status(analysis.hasBacklog.exists, `Backlog (${analysis.hasBacklog.path || 'not found'})`);
+    this.logger.status(analysis.hasREADME.exists, 'README.md');
+    this.logger.status(analysis.hasDocumentation.exists, `Documentation (${analysis.hasDocumentation.count || 0} files)`);
+
+    return analysis;
+  }
+}

package/src/core/generator.js

@@ -0,0 +1,199 @@
+import { Logger } from '../utils/logger.js';
+
+export class Generator {
+  constructor() {
+    this.logger = new Logger();
+  }
+
+  /**
+   * Generate backlog from analysis
+   */
+  async generateBacklog(analysis, template = 'simple') {
+    this.logger.info('📝 Generating backlog...');
+
+    const backlog = {
+      milestones: this.generateMilestones(analysis, template),
+      epics: this.generateEpics(analysis, template),
+      stories: this.generateStories(analysis, template)
+    };
+
+    return this.formatBacklog(backlog);
+  }
+
+  generateMilestones(analysis, template) {
+    const templates = {
+      simple: [
+        { id: 'M0', title: 'Foundation', desc: 'Setup and initial configuration', state: 'closed' },
+        { id: 'M1', title: 'Core Features', desc: 'Main functionality', state: 'open' },
+        { id: 'M2', title: 'Polish', desc: 'Testing and refinement', state: 'open' }
+      ],
+      startup: [
+        { id: 'M0', title: 'Foundation', desc: 'Repo, docs, environment', state: 'closed' },
+        { id: 'M1', title: 'MVP Core', desc: 'Essential features for MVP', state: 'open' },
+        { id: 'M2', title: 'User Testing', desc: 'Testing with real users', state: 'open' },
+        { id: 'M3', title: 'Production Ready', desc: 'Launch preparation', state: 'open' }
+      ],
+      agile: [
+        { id: 'Sprint 1', title: 'Sprint 1', desc: 'Initial sprint - 2 weeks', state: 'open' },
+        { id: 'Sprint 2', title: 'Sprint 2', desc: 'Second sprint - 2 weeks', state: 'open' },
+        { id: 'Sprint 3', title: 'Sprint 3', desc: 'Third sprint - 2 weeks', state: 'open' }
+      ],
+      enterprise: [
+        { id: 'Phase 1', title: 'Discovery', desc: 'Requirements and planning', state: 'closed' },
+        { id: 'Phase 2', title: 'Design', desc: 'Architecture and design', state: 'open' },
+        { id: 'Phase 3', title: 'Development', desc: 'Implementation', state: 'open' },
+        { id: 'Phase 4', title: 'Testing', desc: 'QA and testing', state: 'open' },
+        { id: 'Phase 5', title: 'Deployment', desc: 'Production deployment', state: 'open' }
+      ]
+    };
+
+    return templates[template] || templates.simple;
+  }
+
+  generateEpics(analysis, template) {
+    const baseEpics = [
+      { id: 'E1', name: 'Setup & Configuration', milestone: 'M0' },
+      { id: 'E2', name: 'Core Functionality', milestone: 'M1' },
+      { id: 'E3', name: 'User Interface', milestone: 'M1' }
+    ];
+
+    // Add tech-specific epics
+    if (analysis.techStack.includes('React')) {
+      baseEpics.push({ id: 'E4', name: 'React Components', milestone: 'M1' });
+    }
+
+    if (analysis.techStack.includes('Express')) {
+      baseEpics.push({ id: 'E5', name: 'API Endpoints', milestone: 'M1' });
+    }
+
+    return baseEpics;
+  }
+
+  generateStories(analysis, template) {
+    const stories = [];
+
+    // M0 stories (completed)
+    stories.push({
+      id: 'US-E1-01',
+      title: 'Setup repository',
+      priority: 'P0',
+      points: 3,
+      status: 'completed',
+      milestone: 'M0',
+      epic: 'E1'
+    });
+
+    stories.push({
+      id: 'US-E1-02',
+      title: 'Configure development environment',
+      priority: 'P0',
+      points: 5,
+      status: 'completed',
+      milestone: 'M0',
+      epic: 'E1'
+    });
+
+    // M1 stories (pending)
+    stories.push({
+      id: 'US-E2-01',
+      title: 'Implement core logic',
+      priority: 'P0',
+      points: 8,
+      status: 'pending',
+      milestone: 'M1',
+      epic: 'E2'
+    });
+
+    stories.push({
+      id: 'US-E3-01',
+      title: 'Create main UI components',
+      priority: 'P1',
+      points: 5,
+      status: 'pending',
+      milestone: 'M1',
+      epic: 'E3'
+    });
+
+    return stories;
+  }
+
+  formatBacklog(backlog) {
+    let md = '# Product Backlog\n\n';
+    md += `Generated: ${new Date().toISOString().split('T')[0]}\n\n`;
+
+    // Milestones
+    md += '## Milestones\n\n';
+    md += '| ID | Milestone | Objective | State |\n';
+    md += '|----|-----------|-----------|-------|\n';
+
+    for (const m of backlog.milestones) {
+      const icon = m.state === 'closed' ? '✅' : '⬜';
+      md += `| ${m.id} | ${m.title} | ${m.desc} | ${icon} ${m.state} |\n`;
+    }
+
+    md += '\n---\n\n';
+
+    // Epics
+    md += '## Epics\n\n';
+    md += '| ID | Epic | Description | Milestone |\n';
+    md += '|----|------|-------------|-----------||\n';
+
+    for (const e of backlog.epics) {
+      md += `| ${e.id} | ${e.name} | | ${e.milestone} |\n`;
+    }
+
+    md += '\n---\n\n';
+
+    // User Stories
+    md += '## User Stories\n\n';
+
+    for (const story of backlog.stories) {
+      const statusIcon = {
+        completed: '✅',
+        'in-progress': '🚧',
+        pending: '⬜'
+      }[story.status] || '⬜';
+
+      md += `### ${story.id}: ${story.title}\n\n`;
+      md += `**Priority**: ${story.priority} | **Points**: ${story.points} | **Status**: ${statusIcon} ${story.status}\n\n`;
+      md += `**Epic**: ${story.epic} | **Milestone**: ${story.milestone}\n\n`;
+      md += `**Criterios de Aceptación**:\n`;
+      md += `- [ ] Implement functionality\n`;
+      md += `- [ ] Add tests\n`;
+      md += `- [ ] Update documentation\n\n`;
+      md += '---\n\n';
+    }
+
+    return md;
+  }
+
+  /**
+   * Generate project config file
+   */
+  generateConfig(analysis, options = {}) {
+    return {
+      version: '1.0.0',
+      projectName: analysis.projectName,
+      methodology: options.methodology || 'kanban',
+      backlogPath: 'docs/backlog.md',
+      templates: {
+        issue: '.github/ISSUE_TEMPLATE/user-story.md',
+        milestone: '.github/MILESTONE_TEMPLATE.md'
+      },
+      labels: {
+        priority: ['P0:Critical', 'P1:High', 'P2:Medium'],
+        epics: analysis.techStack.map((tech, i) => `Epic:E${i + 1}-${tech}`),
+        storyPoints: ['story-points:3', 'story-points:5', 'story-points:8'],
+        status: ['status:in-progress', 'status:completed']
+      },
+      milestones: {
+        prefix: options.milestonePrefix || 'M',
+        duration: options.duration || 'flexible'
+      },
+      project: {
+        name: `${analysis.projectName} Development Board`,
+        views: ['status', 'milestone', 'epic', 'priority']
+      }
+    };
+  }
+}

package/src/core/github-client.js

@@ -0,0 +1,246 @@
+import { Octokit } from '@octokit/rest';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { Logger } from '../utils/logger.js';
+
+const execAsync = promisify(exec);
+
+export class GitHubClient {
+  constructor() {
+    this.logger = new Logger();
+    this.octokit = null;
+    this.repo = null;
+  }
+
+  /**
+   * Initialize GitHub client
+   */
+  async init() {
+    try {
+      // Try to get token from gh CLI
+      const { stdout } = await execAsync('gh auth token');
+      const token = stdout.trim();
+
+      this.octokit = new Octokit({ auth: token });
+      this.repo = await this.detectRepo();
+
+      this.logger.success('GitHub client initialized');
+      return true;
+    } catch (error) {
+      this.logger.error('Failed to initialize GitHub client');
+      this.logger.error('Make sure gh CLI is installed and authenticated');
+      this.logger.info('Run: gh auth login');
+      return false;
+    }
+  }
+
+  /**
+   * Detect current repository
+   */
+  async detectRepo() {
+    try {
+      const { stdout } = await execAsync('git remote get-url origin');
+      const match = stdout.match(/github\.com[:/](.+?)\/(.+?)\.git/);
+
+      if (match) {
+        return {
+          owner: match[1],
+          repo: match[2]
+        };
+      }
+    } catch (error) {
+      this.logger.warn('Could not detect GitHub repository');
+    }
+
+    return null;
+  }
+
+  /**
+   * Create milestones
+   */
+  async createMilestones(milestones) {
+    if (!this.octokit || !this.repo) {
+      throw new Error('GitHub client not initialized');
+    }
+
+    this.logger.info(`Creating ${milestones.length} milestones...`);
+    const created = [];
+
+    for (const milestone of milestones) {
+      try {
+        const result = await this.octokit.issues.createMilestone({
+          owner: this.repo.owner,
+          repo: this.repo.repo,
+          title: milestone.title,
+          description: milestone.desc,
+          state: milestone.state || 'open'
+        });
+
+        created.push(result.data);
+        this.logger.success(`✓ ${milestone.title}`);
+      } catch (error) {
+        if (error.status === 422) {
+          this.logger.warn(`⚠ Milestone already exists: ${milestone.title}`);
+        } else {
+          this.logger.error(`✗ Failed to create: ${milestone.title}`);
+        }
+      }
+    }
+
+    return created;
+  }
+
+  /**
+   * Create labels
+   */
+  async createLabels(labels) {
+    if (!this.octokit || !this.repo) {
+      throw new Error('GitHub client not initialized');
+    }
+
+    this.logger.info(`Creating labels...`);
+    const created = [];
+
+    const labelConfigs = [
+      { name: 'P0:Critical', color: 'd73a4a', description: 'Critical priority' },
+      { name: 'P1:High', color: 'ff9800', description: 'High priority' },
+      { name: 'P2:Medium', color: 'fbca04', description: 'Medium priority' },
+      { name: 'status:in-progress', color: '0075ca', description: 'In progress' },
+      { name: 'status:completed', color: '0e8a16', description: 'Completed' },
+      { name: 'story-points:3', color: 'c5def5', description: '3 story points' },
+      { name: 'story-points:5', color: 'c5def5', description: '5 story points' },
+      { name: 'story-points:8', color: 'c5def5', description: '8 story points' },
+      ...labels.map(l => ({
+        name: l.name || l,
+        color: l.color || 'ededed',
+        description: l.description || ''
+      }))
+    ];
+
+    for (const label of labelConfigs) {
+      try {
+        const result = await this.octokit.issues.createLabel({
+          owner: this.repo.owner,
+          repo: this.repo.repo,
+          name: label.name,
+          color: label.color,
+          description: label.description
+        });
+
+        created.push(result.data);
+        this.logger.success(`✓ ${label.name}`);
+      } catch (error) {
+        if (error.status === 422) {
+          // Label already exists, skip
+        } else {
+          this.logger.warn(`⚠ ${label.name}`);
+        }
+      }
+    }
+
+    return created;
+  }
+
+  /**
+   * Create issues
+   */
+  async createIssues(stories, milestones) {
+    if (!this.octokit || !this.repo) {
+      throw new Error('GitHub client not initialized');
+    }
+
+    this.logger.info(`Creating ${stories.length} issues...`);
+    const created = [];
+
+    // Get milestone numbers
+    const { data: existingMilestones } = await this.octokit.issues.listMilestones({
+      owner: this.repo.owner,
+      repo: this.repo.repo,
+      state: 'all'
+    });
+
+    const milestoneMap = new Map(
+      existingMilestones.map(m => [m.title, m.number])
+    );
+
+    for (const story of stories) {
+      try {
+        const labels = [story.priority, `story-points:${story.points}`];
+
+        if (story.epic) labels.push(story.epic);
+        if (story.status) labels.push(`status:${story.status}`);
+
+        const milestoneNumber = milestoneMap.get(story.milestone);
+
+        const issue = await this.octokit.issues.create({
+          owner: this.repo.owner,
+          repo: this.repo.repo,
+          title: `${story.id}: ${story.title}`,
+          body: this.formatIssueBody(story),
+          labels: labels.filter(Boolean),
+          milestone: milestoneNumber
+        });
+
+        // Close if completed
+        if (story.status === 'completed') {
+          await this.octokit.issues.update({
+            owner: this.repo.owner,
+            repo: this.repo.repo,
+            issue_number: issue.data.number,
+            state: 'closed'
+          });
+        }
+
+        created.push(issue.data);
+        this.logger.success(`✓ #${issue.data.number} ${story.title}`);
+      } catch (error) {
+        this.logger.error(`✗ Failed: ${story.title}`);
+      }
+    }
+
+    return created;
+  }
+
+  formatIssueBody(story) {
+    let body = `## User Story\n\n`;
+    body += `**Priority:** ${story.priority}\n`;
+    body += `**Story Points:** ${story.points}\n`;
+    body += `**Epic:** ${story.epic}\n`;
+    body += `**Milestone:** ${story.milestone}\n\n`;
+    body += `## Acceptance Criteria\n\n`;
+    body += `- [ ] Implement core functionality\n`;
+    body += `- [ ] Add unit tests\n`;
+    body += `- [ ] Update documentation\n`;
+    body += `- [ ] Code review completed\n\n`;
+    body += `---\n`;
+    body += `*Created by den-github-manager*`;
+
+    return body;
+  }
+
+  /**
+   * Get repository info
+   */
+  async getRepoInfo() {
+    if (!this.octokit || !this.repo) {
+      return null;
+    }
+
+    try {
+      const { data } = await this.octokit.repos.get({
+        owner: this.repo.owner,
+        repo: this.repo.repo
+      });
+
+      return {
+        name: data.name,
+        fullName: data.full_name,
+        description: data.description,
+        url: data.html_url,
+        private: data.private
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+}