@baselineos/persona 0.1.0

package/src/index.ts

@@ -0,0 +1,33 @@
+export { BaselinePersonaEngine } from './engine.js';
+export { PersonaUISystem } from './ui.js';
+export { AgileProductManagerPersona } from './personas/agile-pm.js';
+export { SoftwareDevelopmentLeadPersona } from './personas/dev-lead.js';
+
+export type {
+  PersonaConfig,
+  Persona,
+  ActivePersona,
+  StudioConfig,
+  AgilePMConfig,
+  BehaviorData,
+  BehaviorPattern,
+  PersonaEngineConfig,
+} from './engine.js';
+
+export type {
+  PersonaOption,
+  WorkflowInstance,
+} from './ui.js';
+
+export type {
+  Sprint,
+  Story,
+  BacklogItem,
+} from './personas/agile-pm.js';
+
+export type {
+  TeamMember,
+  Task,
+  CodeReview,
+  ReviewComment,
+} from './personas/dev-lead.js';

package/src/personas/agile-pm.ts

@@ -0,0 +1,399 @@
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+import { readFile, writeFile } from 'fs/promises';
+
+// ─── Type Definitions ────────────────────────────────────────────────────────
+
+export interface Story {
+  id: string;
+  title: string;
+  description: string;
+  points: number;
+  priority: string;
+  assignee?: string;
+  status: string;
+  acceptance: string[];
+  completedAt?: string;
+  updatedAt?: string;
+}
+
+export interface Sprint {
+  id: string;
+  name: string;
+  startDate: string;
+  endDate: string;
+  goals: string[];
+  stories: Story[];
+  team: string[];
+  status: string;
+}
+
+export interface BacklogItem {
+  id: string;
+  title: string;
+  description: string;
+  type: string;
+  priority: string;
+  points: number;
+  epic?: string;
+  createdAt: string;
+}
+
+export interface VelocityData {
+  sprintId: string;
+  sprintName: string;
+  plannedPoints: number;
+  completedPoints: number;
+  velocity: number;
+}
+
+export interface BurndownEntry {
+  day: number;
+  date: string;
+  idealRemaining: number;
+  actualRemaining: number;
+}
+
+export interface SprintReport {
+  sprint: Sprint;
+  totalStories: number;
+  completedStories: number;
+  totalPoints: number;
+  completedPoints: number;
+  completionRate: number;
+  velocity: number;
+  storiesByStatus: Record<string, number>;
+  storiesByPriority: Record<string, number>;
+}
+
+export interface WorkspaceData {
+  sprints: Sprint[];
+  backlog: BacklogItem[];
+  lastUpdated: string;
+}
+
+export interface PersonaStatus {
+  persona: string;
+  activeSprints: number;
+  totalStories: number;
+  backlogSize: number;
+  averageVelocity: number;
+  completedSprints: number;
+}
+
+// ─── Agile Product Manager Persona ──────────────────────────────────────────
+
+export class AgileProductManagerPersona extends EventEmitter {
+  private sprints: Map<string, Sprint>;
+  private backlog: BacklogItem[];
+  private velocityHistory: VelocityData[];
+  private workspacePath: string;
+
+  constructor(workspacePath: string = './workspace') {
+    super();
+    this.sprints = new Map();
+    this.backlog = [];
+    this.velocityHistory = [];
+    this.workspacePath = workspacePath;
+    console.log('[AgileProductManagerPersona] Persona initialized');
+  }
+
+  // ─── Sprint Management ────────────────────────────────────────────────────
+
+  createSprint(name: string, startDate: string, duration: number, goals: string[], team: string[]): Sprint {
+    const endDate = this.calculateEndDate(startDate, duration);
+
+    const sprint: Sprint = {
+      id: randomUUID(),
+      name,
+      startDate,
+      endDate,
+      goals,
+      stories: [],
+      team,
+      status: 'planning',
+    };
+
+    this.sprints.set(sprint.id, sprint);
+    this.emit('sprint:created', { sprintId: sprint.id, name });
+    console.log(`[AgileProductManagerPersona] Sprint created: ${name} (${startDate} - ${endDate})`);
+    return sprint;
+  }
+
+  addStoryToSprint(sprintId: string, story: Omit<Story, 'id' | 'status' | 'updatedAt'>): Story {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+
+    const fullStory: Story = {
+      ...story,
+      id: randomUUID(),
+      status: 'todo',
+      updatedAt: new Date().toISOString(),
+    };
+
+    sprint.stories.push(fullStory);
+    this.emit('story:added', { sprintId, storyId: fullStory.id, title: fullStory.title });
+    console.log(`[AgileProductManagerPersona] Story added to sprint ${sprint.name}: ${fullStory.title}`);
+    return fullStory;
+  }
+
+  updateStoryStatus(sprintId: string, storyId: string, newStatus: string): Story {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+
+    const story = sprint.stories.find((s) => s.id === storyId);
+    if (!story) {
+      throw new Error(`Story '${storyId}' not found in sprint '${sprintId}'`);
+    }
+
+    const oldStatus = story.status;
+    story.status = newStatus;
+    story.updatedAt = new Date().toISOString();
+
+    if (newStatus === 'done') {
+      story.completedAt = new Date().toISOString();
+    }
+
+    this.emit('story:statusChanged', { sprintId, storyId, oldStatus, newStatus });
+    console.log(`[AgileProductManagerPersona] Story ${story.title}: ${oldStatus} -> ${newStatus}`);
+    return story;
+  }
+
+  // ─── Backlog Management ───────────────────────────────────────────────────
+
+  addToBacklog(item: Omit<BacklogItem, 'id' | 'createdAt'>): BacklogItem {
+    const fullItem: BacklogItem = {
+      ...item,
+      id: randomUUID(),
+      createdAt: new Date().toISOString(),
+    };
+
+    this.backlog.push(fullItem);
+    this.emit('backlog:itemAdded', { itemId: fullItem.id, title: fullItem.title });
+    console.log(`[AgileProductManagerPersona] Backlog item added: ${fullItem.title}`);
+    return fullItem;
+  }
+
+  prioritizeBacklog(criteria: string = 'priority'): BacklogItem[] {
+    const priorityOrder: Record<string, number> = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3,
+    };
+
+    switch (criteria) {
+      case 'priority':
+        this.backlog.sort((a, b) => {
+          const aPriority = priorityOrder[a.priority] ?? 4;
+          const bPriority = priorityOrder[b.priority] ?? 4;
+          return aPriority - bPriority;
+        });
+        break;
+      case 'points':
+        this.backlog.sort((a, b) => b.points - a.points);
+        break;
+      case 'created':
+        this.backlog.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+        break;
+      case 'type':
+        this.backlog.sort((a, b) => a.type.localeCompare(b.type));
+        break;
+      default:
+        this.backlog.sort((a, b) => {
+          const aPriority = priorityOrder[a.priority] ?? 4;
+          const bPriority = priorityOrder[b.priority] ?? 4;
+          return aPriority - bPriority;
+        });
+    }
+
+    this.emit('backlog:prioritized', { criteria, itemCount: this.backlog.length });
+    console.log(`[AgileProductManagerPersona] Backlog prioritized by ${criteria}: ${this.backlog.length} items`);
+    return [...this.backlog];
+  }
+
+  // ─── Velocity & Metrics ───────────────────────────────────────────────────
+
+  calculateVelocity(sprintId: string): VelocityData {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+
+    const totalPoints = sprint.stories.reduce((sum, s) => sum + s.points, 0);
+    const completedPoints = sprint.stories
+      .filter((s) => s.status === 'done')
+      .reduce((sum, s) => sum + s.points, 0);
+
+    const velocityData: VelocityData = {
+      sprintId: sprint.id,
+      sprintName: sprint.name,
+      plannedPoints: totalPoints,
+      completedPoints,
+      velocity: completedPoints,
+    };
+
+    this.velocityHistory.push(velocityData);
+    this.emit('velocity:calculated', { sprintId, velocity: completedPoints });
+    return velocityData;
+  }
+
+  // ─── Reporting ────────────────────────────────────────────────────────────
+
+  generateSprintReport(sprintId: string): SprintReport {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+
+    const totalStories = sprint.stories.length;
+    const completedStories = sprint.stories.filter((s) => s.status === 'done').length;
+    const totalPoints = sprint.stories.reduce((sum, s) => sum + s.points, 0);
+    const completedPoints = sprint.stories
+      .filter((s) => s.status === 'done')
+      .reduce((sum, s) => sum + s.points, 0);
+
+    const storiesByStatus: Record<string, number> = {};
+    for (const story of sprint.stories) {
+      storiesByStatus[story.status] = (storiesByStatus[story.status] || 0) + 1;
+    }
+
+    const storiesByPriority: Record<string, number> = {};
+    for (const story of sprint.stories) {
+      storiesByPriority[story.priority] = (storiesByPriority[story.priority] || 0) + 1;
+    }
+
+    const report: SprintReport = {
+      sprint,
+      totalStories,
+      completedStories,
+      totalPoints,
+      completedPoints,
+      completionRate: totalStories > 0 ? (completedStories / totalStories) * 100 : 0,
+      velocity: completedPoints,
+      storiesByStatus,
+      storiesByPriority,
+    };
+
+    this.emit('report:generated', { sprintId, type: 'sprint' });
+    console.log(`[AgileProductManagerPersona] Sprint report generated for: ${sprint.name}`);
+    return report;
+  }
+
+  generateBurndownData(sprintId: string): BurndownEntry[] {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+
+    const totalPoints = sprint.stories.reduce((sum, s) => sum + s.points, 0);
+    const startDate = new Date(sprint.startDate);
+    const endDate = new Date(sprint.endDate);
+    const totalDays = Math.ceil((endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24));
+    const dailyIdealBurn = totalPoints / totalDays;
+
+    const burndownData: BurndownEntry[] = [];
+    let actualRemaining = totalPoints;
+
+    for (let day = 0; day <= totalDays; day++) {
+      const currentDate = new Date(startDate);
+      currentDate.setDate(currentDate.getDate() + day);
+      const dateStr = currentDate.toISOString().split('T')[0];
+
+      const storiesCompletedByDate = sprint.stories.filter((s) => {
+        if (!s.completedAt) return false;
+        return new Date(s.completedAt) <= currentDate;
+      });
+
+      const completedPoints = storiesCompletedByDate.reduce((sum, s) => sum + s.points, 0);
+      actualRemaining = totalPoints - completedPoints;
+
+      burndownData.push({
+        day,
+        date: dateStr,
+        idealRemaining: Math.max(0, totalPoints - dailyIdealBurn * day),
+        actualRemaining,
+      });
+    }
+
+    this.emit('burndown:generated', { sprintId, dataPoints: burndownData.length });
+    return burndownData;
+  }
+
+  // ─── Utility Methods ──────────────────────────────────────────────────────
+
+  private calculateEndDate(startDate: string, durationDays: number): string {
+    const date = new Date(startDate);
+    date.setDate(date.getDate() + durationDays);
+    return date.toISOString().split('T')[0];
+  }
+
+  async loadWorkspaceData(): Promise<WorkspaceData | null> {
+    try {
+      const filePath = `${this.workspacePath}/agile-pm-data.json`;
+      const data = await readFile(filePath, 'utf-8');
+      const parsed: WorkspaceData = JSON.parse(data);
+
+      for (const sprint of parsed.sprints) {
+        this.sprints.set(sprint.id, sprint);
+      }
+      this.backlog = parsed.backlog || [];
+
+      console.log(`[AgileProductManagerPersona] Workspace data loaded: ${this.sprints.size} sprints, ${this.backlog.length} backlog items`);
+      return parsed;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[AgileProductManagerPersona] No existing workspace data found: ${message}`);
+      return null;
+    }
+  }
+
+  async saveWorkspaceData(): Promise<void> {
+    try {
+      const data: WorkspaceData = {
+        sprints: Array.from(this.sprints.values()),
+        backlog: this.backlog,
+        lastUpdated: new Date().toISOString(),
+      };
+
+      const filePath = `${this.workspacePath}/agile-pm-data.json`;
+      await writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+      console.log('[AgileProductManagerPersona] Workspace data saved');
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[AgileProductManagerPersona] Failed to save workspace data: ${message}`);
+    }
+  }
+
+  getPersonaStatus(): PersonaStatus {
+    const activeSprints = Array.from(this.sprints.values()).filter(
+      (s) => s.status === 'active' || s.status === 'planning'
+    );
+    const completedSprints = Array.from(this.sprints.values()).filter(
+      (s) => s.status === 'completed'
+    );
+
+    let totalStories = 0;
+    for (const sprint of this.sprints.values()) {
+      totalStories += sprint.stories.length;
+    }
+
+    const avgVelocity =
+      this.velocityHistory.length > 0
+        ? this.velocityHistory.reduce((sum, v) => sum + v.velocity, 0) / this.velocityHistory.length
+        : 0;
+
+    return {
+      persona: 'Agile Product Manager',
+      activeSprints: activeSprints.length,
+      totalStories,
+      backlogSize: this.backlog.length,
+      averageVelocity: Math.round(avgVelocity * 100) / 100,
+      completedSprints: completedSprints.length,
+    };
+  }
+}