@baselineos/persona 0.1.0

package/src/personas/dev-lead.ts

@@ -0,0 +1,654 @@
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { readFile, writeFile, access } from 'fs/promises';
+import { constants as fsConstants } from 'fs';
+
+const execAsync = promisify(exec);
+
+// ─── Type Definitions ────────────────────────────────────────────────────────
+
+export interface Task {
+  id: string;
+  title: string;
+  description: string;
+  type: string;
+  priority: string;
+  estimatedHours: number;
+  assignedAt: string;
+  status: string;
+}
+
+export interface TeamMember {
+  id: string;
+  name: string;
+  role: string;
+  skills: string[];
+  capacity: number;
+  currentTasks: Task[];
+  performance: {
+    velocity: number;
+    quality: number;
+    collaboration: number;
+  };
+  joinedAt: string;
+}
+
+export interface ReviewComment {
+  id: string;
+  author: string;
+  content: string;
+  line?: number;
+  file?: string;
+  type: string;
+  createdAt: string;
+}
+
+export interface CodeReview {
+  id: string;
+  title: string;
+  description: string;
+  files: string[];
+  reviewer: string;
+  author: string;
+  status: string;
+  comments: ReviewComment[];
+  createdAt: string;
+  approvedAt?: string;
+  approver?: string;
+}
+
+export interface TechDebtItem {
+  id: string;
+  title: string;
+  description: string;
+  category: string;
+  severity: string;
+  estimatedEffort: number;
+  impact: string;
+  file?: string;
+  line?: number;
+  identifiedAt: string;
+  resolvedAt?: string;
+  status: string;
+}
+
+export interface CodebaseAnalysis {
+  totalFiles: number;
+  filesByType: Record<string, number>;
+  filesByExtension: Record<string, number>;
+  totalLines?: number;
+  codeQualityScore: number;
+  techDebtItems: number;
+  analyzedAt: string;
+}
+
+export interface BuildResult {
+  id: string;
+  status: string;
+  command: string;
+  startTime: string;
+  endTime?: string;
+  duration?: number;
+  output: string;
+  errors: string[];
+}
+
+export interface TestResult {
+  id: string;
+  status: string;
+  command: string;
+  startTime: string;
+  endTime?: string;
+  duration?: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  output: string;
+}
+
+export interface WorkspaceData {
+  team: TeamMember[];
+  reviews: CodeReview[];
+  techDebt: TechDebtItem[];
+  lastUpdated: string;
+}
+
+export interface DevLeadStatus {
+  persona: string;
+  teamSize: number;
+  activeReviews: number;
+  techDebtItems: number;
+  openTasks: number;
+  teamCapacity: number;
+  averageQuality: number;
+}
+
+// ─── Software Development Lead Persona ──────────────────────────────────────
+
+export class SoftwareDevelopmentLeadPersona extends EventEmitter {
+  private team: Map<string, TeamMember>;
+  private reviews: Map<string, CodeReview>;
+  private techDebt: TechDebtItem[];
+  private builds: BuildResult[];
+  private tests: TestResult[];
+  private workspacePath: string;
+
+  constructor(workspacePath: string = './workspace') {
+    super();
+    this.team = new Map();
+    this.reviews = new Map();
+    this.techDebt = [];
+    this.builds = [];
+    this.tests = [];
+    this.workspacePath = workspacePath;
+    console.log('[SoftwareDevelopmentLeadPersona] Persona initialized');
+  }
+
+  // ─── Team Management ──────────────────────────────────────────────────────
+
+  addTeamMember(name: string, role: string, skills: string[], capacity: number = 40): TeamMember {
+    const member: TeamMember = {
+      id: randomUUID(),
+      name,
+      role,
+      skills,
+      capacity,
+      currentTasks: [],
+      performance: {
+        velocity: 1.0,
+        quality: 1.0,
+        collaboration: 1.0,
+      },
+      joinedAt: new Date().toISOString(),
+    };
+
+    this.team.set(member.id, member);
+    this.emit('team:memberAdded', { memberId: member.id, name });
+    console.log(`[SoftwareDevelopmentLeadPersona] Team member added: ${name} (${role})`);
+    return member;
+  }
+
+  assignTask(memberId: string, taskData: Omit<Task, 'id' | 'assignedAt' | 'status'>): Task {
+    const member = this.team.get(memberId);
+    if (!member) {
+      throw new Error(`Team member '${memberId}' not found`);
+    }
+
+    const currentLoad = member.currentTasks.reduce((sum, t) => sum + t.estimatedHours, 0);
+    if (currentLoad + taskData.estimatedHours > member.capacity) {
+      console.log(`[SoftwareDevelopmentLeadPersona] Warning: ${member.name} may be over capacity (${currentLoad + taskData.estimatedHours}/${member.capacity}h)`);
+    }
+
+    const task: Task = {
+      ...taskData,
+      id: randomUUID(),
+      assignedAt: new Date().toISOString(),
+      status: 'assigned',
+    };
+
+    member.currentTasks.push(task);
+    this.emit('task:assigned', { memberId, taskId: task.id, title: task.title });
+    console.log(`[SoftwareDevelopmentLeadPersona] Task assigned to ${member.name}: ${task.title}`);
+    return task;
+  }
+
+  // ─── Code Reviews ────────────────────────────────────────────────────────
+
+  initiateCodeReview(
+    title: string,
+    description: string,
+    files: string[],
+    author: string,
+    reviewer: string
+  ): CodeReview {
+    const review: CodeReview = {
+      id: randomUUID(),
+      title,
+      description,
+      files,
+      reviewer,
+      author,
+      status: 'pending',
+      comments: [],
+      createdAt: new Date().toISOString(),
+    };
+
+    this.reviews.set(review.id, review);
+    this.emit('review:created', { reviewId: review.id, title });
+    console.log(`[SoftwareDevelopmentLeadPersona] Code review initiated: ${title}`);
+    return review;
+  }
+
+  addReviewComment(
+    reviewId: string,
+    author: string,
+    content: string,
+    options: { line?: number; file?: string; type?: string } = {}
+  ): ReviewComment {
+    const review = this.reviews.get(reviewId);
+    if (!review) {
+      throw new Error(`Code review '${reviewId}' not found`);
+    }
+
+    const comment: ReviewComment = {
+      id: randomUUID(),
+      author,
+      content,
+      line: options.line,
+      file: options.file,
+      type: options.type || 'comment',
+      createdAt: new Date().toISOString(),
+    };
+
+    review.comments.push(comment);
+
+    if (review.status === 'pending') {
+      review.status = 'in-review';
+    }
+
+    this.emit('review:commented', { reviewId, commentId: comment.id, author });
+    console.log(`[SoftwareDevelopmentLeadPersona] Review comment added by ${author} on ${review.title}`);
+    return comment;
+  }
+
+  approveCodeReview(reviewId: string, approver: string): CodeReview {
+    const review = this.reviews.get(reviewId);
+    if (!review) {
+      throw new Error(`Code review '${reviewId}' not found`);
+    }
+
+    review.status = 'approved';
+    review.approvedAt = new Date().toISOString();
+    review.approver = approver;
+
+    this.emit('review:approved', { reviewId, approver });
+    console.log(`[SoftwareDevelopmentLeadPersona] Code review approved: ${review.title} by ${approver}`);
+    return review;
+  }
+
+  // ─── Technical Debt ───────────────────────────────────────────────────────
+
+  identifyTechnicalDebt(
+    title: string,
+    description: string,
+    category: string,
+    severity: string,
+    estimatedEffort: number,
+    impact: string,
+    options: { file?: string; line?: number } = {}
+  ): TechDebtItem {
+    const item: TechDebtItem = {
+      id: randomUUID(),
+      title,
+      description,
+      category,
+      severity,
+      estimatedEffort,
+      impact,
+      file: options.file,
+      line: options.line,
+      identifiedAt: new Date().toISOString(),
+      status: 'identified',
+    };
+
+    this.techDebt.push(item);
+    this.emit('techDebt:identified', { itemId: item.id, title, severity });
+    console.log(`[SoftwareDevelopmentLeadPersona] Tech debt identified: ${title} (${severity})`);
+    return item;
+  }
+
+  prioritizeTechnicalDebt(criteria: string = 'severity'): TechDebtItem[] {
+    const severityOrder: Record<string, number> = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3,
+    };
+
+    switch (criteria) {
+      case 'severity':
+        this.techDebt.sort((a, b) => {
+          const aOrder = severityOrder[a.severity] ?? 4;
+          const bOrder = severityOrder[b.severity] ?? 4;
+          return aOrder - bOrder;
+        });
+        break;
+      case 'effort':
+        this.techDebt.sort((a, b) => a.estimatedEffort - b.estimatedEffort);
+        break;
+      case 'impact': {
+        const impactOrder: Record<string, number> = { critical: 0, high: 1, medium: 2, low: 3 };
+        this.techDebt.sort((a, b) => {
+          const aOrder = impactOrder[a.impact] ?? 4;
+          const bOrder = impactOrder[b.impact] ?? 4;
+          return aOrder - bOrder;
+        });
+        break;
+      }
+      case 'category':
+        this.techDebt.sort((a, b) => a.category.localeCompare(b.category));
+        break;
+      default:
+        this.techDebt.sort((a, b) => {
+          const aOrder = severityOrder[a.severity] ?? 4;
+          const bOrder = severityOrder[b.severity] ?? 4;
+          return aOrder - bOrder;
+        });
+    }
+
+    this.emit('techDebt:prioritized', { criteria, itemCount: this.techDebt.length });
+    console.log(`[SoftwareDevelopmentLeadPersona] Tech debt prioritized by ${criteria}: ${this.techDebt.length} items`);
+    return [...this.techDebt];
+  }
+
+  // ─── Codebase Analysis ────────────────────────────────────────────────────
+
+  async analyzeCodebase(directory: string): Promise<CodebaseAnalysis> {
+    console.log(`[SoftwareDevelopmentLeadPersona] Analyzing codebase: ${directory}`);
+
+    const filesByType = await this.countFilesByType(directory);
+    const filesByExtension = await this.countFilesByExtension(directory);
+    const totalFiles = Object.values(filesByExtension).reduce((sum, count) => sum + count, 0);
+    const codeQualityScore = this.calculateCodeQualityScore();
+    const techDebtCount = this.techDebt.filter((item) => item.status !== 'resolved').length;
+
+    const analysis: CodebaseAnalysis = {
+      totalFiles,
+      filesByType,
+      filesByExtension,
+      codeQualityScore,
+      techDebtItems: techDebtCount,
+      analyzedAt: new Date().toISOString(),
+    };
+
+    this.emit('codebase:analyzed', { directory, totalFiles, codeQualityScore });
+    console.log(`[SoftwareDevelopmentLeadPersona] Codebase analysis complete: ${totalFiles} files, quality score: ${codeQualityScore}`);
+    return analysis;
+  }
+
+  private async countFilesByType(directory: string): Promise<Record<string, number>> {
+    const filesByType: Record<string, number> = {
+      source: 0,
+      test: 0,
+      config: 0,
+      documentation: 0,
+      asset: 0,
+      other: 0,
+    };
+
+    try {
+      const { stdout } = await execAsync(`find "${directory}" -type f -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -5000`);
+      const files = stdout.trim().split('\n').filter(Boolean);
+
+      for (const file of files) {
+        const lower = file.toLowerCase();
+        if (lower.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/)) {
+          filesByType['test']++;
+        } else if (lower.match(/\.(ts|js|tsx|jsx|py|rb|go|rs|java|c|cpp|h)$/)) {
+          filesByType['source']++;
+        } else if (lower.match(/\.(json|yaml|yml|toml|ini|env|conf|cfg)$/)) {
+          filesByType['config']++;
+        } else if (lower.match(/\.(md|txt|rst|doc|docx|pdf)$/)) {
+          filesByType['documentation']++;
+        } else if (lower.match(/\.(png|jpg|jpeg|gif|svg|ico|mp4|mp3|woff|ttf)$/)) {
+          filesByType['asset']++;
+        } else {
+          filesByType['other']++;
+        }
+      }
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[SoftwareDevelopmentLeadPersona] Error counting files by type: ${message}`);
+    }
+
+    return filesByType;
+  }
+
+  private async countFilesByExtension(directory: string): Promise<Record<string, number>> {
+    const filesByExtension: Record<string, number> = {};
+
+    try {
+      const { stdout } = await execAsync(`find "${directory}" -type f -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -5000`);
+      const files = stdout.trim().split('\n').filter(Boolean);
+
+      for (const file of files) {
+        const parts = file.split('.');
+        const ext = parts.length > 1 ? `.${parts[parts.length - 1]}` : 'no-extension';
+        filesByExtension[ext] = (filesByExtension[ext] || 0) + 1;
+      }
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[SoftwareDevelopmentLeadPersona] Error counting files by extension: ${message}`);
+    }
+
+    return filesByExtension;
+  }
+
+  private async scanCodebase(directory: string, pattern: string): Promise<string[]> {
+    try {
+      const { stdout } = await execAsync(`grep -rl "${pattern}" "${directory}" --include="*.ts" --include="*.js" 2>/dev/null | head -100`);
+      return stdout.trim().split('\n').filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+
+  private calculateCodeQualityScore(): number {
+    let score = 100;
+
+    const unresolvedDebt = this.techDebt.filter((item) => item.status !== 'resolved');
+
+    for (const item of unresolvedDebt) {
+      switch (item.severity) {
+        case 'critical':
+          score -= 15;
+          break;
+        case 'high':
+          score -= 10;
+          break;
+        case 'medium':
+          score -= 5;
+          break;
+        case 'low':
+          score -= 2;
+          break;
+      }
+    }
+
+    const pendingReviews = Array.from(this.reviews.values()).filter(
+      (r) => r.status === 'pending' || r.status === 'in-review'
+    );
+    score -= pendingReviews.length * 3;
+
+    return Math.max(0, Math.min(100, Math.round(score)));
+  }
+
+  // ─── Build & Test ─────────────────────────────────────────────────────────
+
+  async runBuild(command: string = 'npm run build'): Promise<BuildResult> {
+    const build: BuildResult = {
+      id: randomUUID(),
+      status: 'running',
+      command,
+      startTime: new Date().toISOString(),
+      output: '',
+      errors: [],
+    };
+
+    console.log(`[SoftwareDevelopmentLeadPersona] Running build: ${command}`);
+
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: this.workspacePath,
+        timeout: 300000,
+      });
+
+      build.status = 'success';
+      build.output = stdout;
+      if (stderr) {
+        build.errors = stderr.split('\n').filter(Boolean);
+      }
+    } catch (error: unknown) {
+      build.status = 'failed';
+      if (error instanceof Error) {
+        build.output = (error as Error & { stdout?: string }).stdout || '';
+        build.errors = [(error as Error & { stderr?: string }).stderr || error.message];
+      } else {
+        build.errors = [String(error)];
+      }
+    }
+
+    build.endTime = new Date().toISOString();
+    build.duration = new Date(build.endTime).getTime() - new Date(build.startTime).getTime();
+
+    this.builds.push(build);
+    this.emit('build:completed', { buildId: build.id, status: build.status });
+    console.log(`[SoftwareDevelopmentLeadPersona] Build ${build.status}: ${command} (${build.duration}ms)`);
+    return build;
+  }
+
+  async runTests(command: string = 'npm test'): Promise<TestResult> {
+    const testResult: TestResult = {
+      id: randomUUID(),
+      status: 'running',
+      command,
+      startTime: new Date().toISOString(),
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      output: '',
+    };
+
+    console.log(`[SoftwareDevelopmentLeadPersona] Running tests: ${command}`);
+
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: this.workspacePath,
+        timeout: 600000,
+      });
+
+      testResult.output = stdout + (stderr ? '\n' + stderr : '');
+      testResult.status = 'passed';
+
+      const passedMatch = stdout.match(/(\d+)\s*(passing|passed|pass)/i);
+      const failedMatch = stdout.match(/(\d+)\s*(failing|failed|fail)/i);
+      const skippedMatch = stdout.match(/(\d+)\s*(pending|skipped|skip)/i);
+
+      testResult.passed = passedMatch ? parseInt(passedMatch[1], 10) : 0;
+      testResult.failed = failedMatch ? parseInt(failedMatch[1], 10) : 0;
+      testResult.skipped = skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
+
+      if (testResult.failed > 0) {
+        testResult.status = 'failed';
+      }
+    } catch (error: unknown) {
+      testResult.status = 'failed';
+      if (error instanceof Error) {
+        testResult.output = (error as Error & { stdout?: string }).stdout || error.message;
+      } else {
+        testResult.output = String(error);
+      }
+    }
+
+    testResult.endTime = new Date().toISOString();
+    testResult.duration = new Date(testResult.endTime).getTime() - new Date(testResult.startTime).getTime();
+
+    this.tests.push(testResult);
+    this.emit('tests:completed', {
+      testId: testResult.id,
+      status: testResult.status,
+      passed: testResult.passed,
+      failed: testResult.failed,
+    });
+    console.log(`[SoftwareDevelopmentLeadPersona] Tests ${testResult.status}: ${testResult.passed} passed, ${testResult.failed} failed, ${testResult.skipped} skipped (${testResult.duration}ms)`);
+    return testResult;
+  }
+
+  // ─── File Utilities ───────────────────────────────────────────────────────
+
+  async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await access(filePath, fsConstants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // ─── Workspace Persistence ────────────────────────────────────────────────
+
+  async loadWorkspaceData(): Promise<WorkspaceData | null> {
+    try {
+      const filePath = `${this.workspacePath}/dev-lead-data.json`;
+      const data = await readFile(filePath, 'utf-8');
+      const parsed: WorkspaceData = JSON.parse(data);
+
+      for (const member of parsed.team) {
+        this.team.set(member.id, member);
+      }
+      for (const review of parsed.reviews) {
+        this.reviews.set(review.id, review);
+      }
+      this.techDebt = parsed.techDebt || [];
+
+      console.log(`[SoftwareDevelopmentLeadPersona] Workspace data loaded: ${this.team.size} members, ${this.reviews.size} reviews, ${this.techDebt.length} debt items`);
+      return parsed;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[SoftwareDevelopmentLeadPersona] No existing workspace data found: ${message}`);
+      return null;
+    }
+  }
+
+  async saveWorkspaceData(): Promise<void> {
+    try {
+      const data: WorkspaceData = {
+        team: Array.from(this.team.values()),
+        reviews: Array.from(this.reviews.values()),
+        techDebt: this.techDebt,
+        lastUpdated: new Date().toISOString(),
+      };
+
+      const filePath = `${this.workspacePath}/dev-lead-data.json`;
+      await writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+      console.log('[SoftwareDevelopmentLeadPersona] Workspace data saved');
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[SoftwareDevelopmentLeadPersona] Failed to save workspace data: ${message}`);
+    }
+  }
+
+  // ─── Status ───────────────────────────────────────────────────────────────
+
+  getPersonaStatus(): DevLeadStatus {
+    const activeReviews = Array.from(this.reviews.values()).filter(
+      (r) => r.status === 'pending' || r.status === 'in-review'
+    );
+
+    let openTasks = 0;
+    let totalCapacity = 0;
+    let totalQuality = 0;
+    let memberCount = 0;
+
+    for (const member of this.team.values()) {
+      openTasks += member.currentTasks.filter((t) => t.status !== 'completed' && t.status !== 'cancelled').length;
+      totalCapacity += member.capacity - member.currentTasks.reduce((sum, t) => sum + t.estimatedHours, 0);
+      totalQuality += member.performance.quality;
+      memberCount++;
+    }
+
+    const unresolvedDebt = this.techDebt.filter((item) => item.status !== 'resolved');
+
+    return {
+      persona: 'Software Development Lead',
+      teamSize: this.team.size,
+      activeReviews: activeReviews.length,
+      techDebtItems: unresolvedDebt.length,
+      openTasks,
+      teamCapacity: Math.max(0, totalCapacity),
+      averageQuality: memberCount > 0 ? Math.round((totalQuality / memberCount) * 100) / 100 : 0,
+    };
+  }
+}