prjct-cli 0.11.4 → 0.12.0

package/core/data/ideas-manager.ts

@@ -0,0 +1,81 @@
+/**
+ * Ideas Manager
+ *
+ * Manages ideas.json - idea backlog.
+ */
+
+import { ArrayManager } from './base-manager'
+import type { IdeaSchema, IdeasSchema, IdeaPriority } from '../schemas'
+import { DEFAULT_IDEA } from '../schemas'
+
+class IdeasManager extends ArrayManager<IdeaSchema> {
+  constructor() {
+    super('ideas.json')
+  }
+
+  async getIdeas(projectId: string): Promise<IdeasSchema> {
+    return this.read(projectId)
+  }
+
+  async getPendingIdeas(projectId: string): Promise<IdeasSchema> {
+    const ideas = await this.read(projectId)
+    return ideas.filter((idea) => idea.status === 'pending')
+  }
+
+  async getIdea(projectId: string, id: string): Promise<IdeaSchema | undefined> {
+    return this.find(projectId, (idea) => idea.id === id)
+  }
+
+  async addIdea(
+    projectId: string,
+    content: string,
+    options?: Partial<Omit<IdeaSchema, 'id' | 'content' | 'createdAt'>>
+  ): Promise<IdeasSchema> {
+    const idea: IdeaSchema = {
+      ...DEFAULT_IDEA,
+      ...options,
+      id: `idea_${Date.now()}`,
+      content,
+      createdAt: new Date().toISOString()
+    }
+    return this.add(projectId, idea)
+  }
+
+  async updateIdea(
+    projectId: string,
+    id: string,
+    updates: Partial<Omit<IdeaSchema, 'id' | 'createdAt'>>
+  ): Promise<IdeasSchema> {
+    return this.updateItem(
+      projectId,
+      (idea) => idea.id === id,
+      (idea) => ({ ...idea, ...updates })
+    )
+  }
+
+  async archiveIdea(projectId: string, id: string): Promise<IdeasSchema> {
+    return this.updateIdea(projectId, id, {
+      status: 'archived',
+      archivedAt: new Date().toISOString()
+    })
+  }
+
+  async convertToFeature(projectId: string, id: string): Promise<IdeasSchema> {
+    return this.updateIdea(projectId, id, { status: 'converted' })
+  }
+
+  async setPriority(
+    projectId: string,
+    id: string,
+    priority: IdeaPriority
+  ): Promise<IdeasSchema> {
+    return this.updateIdea(projectId, id, { priority })
+  }
+
+  async removeIdea(projectId: string, id: string): Promise<IdeasSchema> {
+    return this.remove(projectId, (idea) => idea.id === id)
+  }
+}
+
+export const ideasManager = new IdeasManager()
+export default ideasManager

package/core/data/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Data Module
+ *
+ * JSON file managers for all project data types.
+ */
+
+// Base
+export { BaseManager, ArrayManager } from './base-manager'
+
+// Managers
+export { stateManager, default as stateManagerDefault } from './state-manager'
+export { projectManager, default as projectManagerDefault } from './project-manager'
+export { agentsManager, default as agentsManagerDefault } from './agents-manager'
+export { ideasManager, default as ideasManagerDefault } from './ideas-manager'
+export { roadmapManager, default as roadmapManagerDefault } from './roadmap-manager'
+export { shippedManager, default as shippedManagerDefault } from './shipped-manager'
+export { analysisManager, default as analysisManagerDefault } from './analysis-manager'
+export { outcomesManager, default as outcomesManagerDefault } from './outcomes-manager'
+
+// Convenience object with all managers
+export const dataManagers = {
+  state: require('./state-manager').stateManager,
+  project: require('./project-manager').projectManager,
+  agents: require('./agents-manager').agentsManager,
+  ideas: require('./ideas-manager').ideasManager,
+  roadmap: require('./roadmap-manager').roadmapManager,
+  shipped: require('./shipped-manager').shippedManager,
+  analysis: require('./analysis-manager').analysisManager,
+  outcomes: require('./outcomes-manager').outcomesManager
+}
+
+export default dataManagers

package/core/data/outcomes-manager.ts

@@ -0,0 +1,96 @@
+/**
+ * Outcomes Manager
+ *
+ * Manages outcomes.json - task completion metrics and history.
+ */
+
+import { ArrayManager } from './base-manager'
+import type { OutcomeSchema, OutcomesSchema, QualityScore } from '../schemas'
+
+class OutcomesManager extends ArrayManager<OutcomeSchema> {
+  constructor() {
+    super('outcomes.json')
+  }
+
+  async getOutcomes(projectId: string): Promise<OutcomesSchema> {
+    return this.read(projectId)
+  }
+
+  async getRecentOutcomes(projectId: string, limit = 20): Promise<OutcomesSchema> {
+    const outcomes = await this.read(projectId)
+    return outcomes
+      .sort((a, b) => new Date(b.completedAt).getTime() - new Date(a.completedAt).getTime())
+      .slice(0, limit)
+  }
+
+  async addOutcome(
+    projectId: string,
+    outcome: Omit<OutcomeSchema, 'id' | 'completedAt'>
+  ): Promise<OutcomesSchema> {
+    const fullOutcome: OutcomeSchema = {
+      ...outcome,
+      id: `outcome_${Date.now()}`,
+      completedAt: new Date().toISOString()
+    }
+    return this.add(projectId, fullOutcome)
+  }
+
+  async getByAgent(projectId: string, agentName: string): Promise<OutcomesSchema> {
+    const outcomes = await this.read(projectId)
+    return outcomes.filter((o) => o.agentUsed === agentName)
+  }
+
+  async getAverageQuality(projectId: string): Promise<number> {
+    const outcomes = await this.read(projectId)
+    if (outcomes.length === 0) return 0
+    const sum = outcomes.reduce((acc, o) => acc + o.qualityScore, 0)
+    return Math.round((sum / outcomes.length) * 10) / 10
+  }
+
+  async getCompletionRate(projectId: string): Promise<number> {
+    const outcomes = await this.read(projectId)
+    if (outcomes.length === 0) return 0
+    const completed = outcomes.filter((o) => o.completedAsPlanned).length
+    return Math.round((completed / outcomes.length) * 100)
+  }
+
+  async getTopBlockers(projectId: string, limit = 5): Promise<string[]> {
+    const outcomes = await this.read(projectId)
+    const blockerCounts = new Map<string, number>()
+
+    for (const outcome of outcomes) {
+      for (const blocker of outcome.blockers) {
+        blockerCounts.set(blocker, (blockerCounts.get(blocker) || 0) + 1)
+      }
+    }
+
+    return Array.from(blockerCounts.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, limit)
+      .map(([blocker]) => blocker)
+  }
+
+  async getAgentStats(
+    projectId: string,
+    agentName: string
+  ): Promise<{ count: number; avgQuality: number; successRate: number }> {
+    const agentOutcomes = await this.getByAgent(projectId, agentName)
+    if (agentOutcomes.length === 0) {
+      return { count: 0, avgQuality: 0, successRate: 0 }
+    }
+
+    const avgQuality =
+      agentOutcomes.reduce((acc, o) => acc + o.qualityScore, 0) / agentOutcomes.length
+    const successRate =
+      (agentOutcomes.filter((o) => o.completedAsPlanned).length / agentOutcomes.length) * 100
+
+    return {
+      count: agentOutcomes.length,
+      avgQuality: Math.round(avgQuality * 10) / 10,
+      successRate: Math.round(successRate)
+    }
+  }
+}
+
+export const outcomesManager = new OutcomesManager()
+export default outcomesManager

package/core/data/project-manager.ts

@@ -0,0 +1,75 @@
+/**
+ * Project Manager
+ *
+ * Manages project.json - project metadata.
+ */
+
+import { BaseManager } from './base-manager'
+import type { ProjectSchema } from '../schemas'
+import { DEFAULT_PROJECT } from '../schemas'
+
+class ProjectManager extends BaseManager<ProjectSchema> {
+  constructor() {
+    super('project.json')
+  }
+
+  protected getDefault(projectId: string): ProjectSchema {
+    return {
+      ...DEFAULT_PROJECT,
+      projectId,
+      name: '',
+      repoPath: '',
+      createdAt: new Date().toISOString(),
+      lastSync: new Date().toISOString()
+    }
+  }
+
+  async getProject(projectId: string): Promise<ProjectSchema> {
+    return this.read(projectId)
+  }
+
+  async updateProject(
+    projectId: string,
+    updates: Partial<Omit<ProjectSchema, 'projectId'>>
+  ): Promise<ProjectSchema> {
+    return this.update(projectId, (project) => ({
+      ...project,
+      ...updates,
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  async setTechStack(projectId: string, techStack: string[]): Promise<ProjectSchema> {
+    return this.updateProject(projectId, { techStack })
+  }
+
+  async setFileCount(projectId: string, fileCount: number): Promise<ProjectSchema> {
+    return this.updateProject(projectId, { fileCount })
+  }
+
+  async setCommitCount(projectId: string, commitCount: number): Promise<ProjectSchema> {
+    return this.updateProject(projectId, { commitCount })
+  }
+
+  async initializeProject(
+    projectId: string,
+    name: string,
+    repoPath: string,
+    options?: Partial<ProjectSchema>
+  ): Promise<ProjectSchema> {
+    const project: ProjectSchema = {
+      ...DEFAULT_PROJECT,
+      ...options,
+      projectId,
+      name,
+      repoPath,
+      createdAt: new Date().toISOString(),
+      lastSync: new Date().toISOString()
+    }
+    await this.write(projectId, project)
+    return project
+  }
+}
+
+export const projectManager = new ProjectManager()
+export default projectManager

package/core/data/roadmap-manager.ts

@@ -0,0 +1,118 @@
+/**
+ * Roadmap Manager
+ *
+ * Manages roadmap.json - feature roadmap.
+ */
+
+import { ArrayManager } from './base-manager'
+import type {
+  FeatureSchema,
+  RoadmapSchema,
+  FeatureStatus,
+  FeatureTask
+} from '../schemas'
+import { DEFAULT_FEATURE } from '../schemas'
+
+class RoadmapManager extends ArrayManager<FeatureSchema> {
+  constructor() {
+    super('roadmap.json')
+  }
+
+  async getFeatures(projectId: string): Promise<RoadmapSchema> {
+    return this.read(projectId)
+  }
+
+  async getActiveFeatures(projectId: string): Promise<RoadmapSchema> {
+    const features = await this.read(projectId)
+    return features.filter((f) => f.status === 'in_progress')
+  }
+
+  async getFeature(projectId: string, id: string): Promise<FeatureSchema | undefined> {
+    return this.find(projectId, (feature) => feature.id === id)
+  }
+
+  async addFeature(
+    projectId: string,
+    name: string,
+    options?: Partial<Omit<FeatureSchema, 'id' | 'name' | 'createdAt'>>
+  ): Promise<RoadmapSchema> {
+    const feature: FeatureSchema = {
+      ...DEFAULT_FEATURE,
+      ...options,
+      id: `feature_${Date.now()}`,
+      name,
+      createdAt: new Date().toISOString()
+    }
+    return this.add(projectId, feature)
+  }
+
+  async updateFeature(
+    projectId: string,
+    id: string,
+    updates: Partial<Omit<FeatureSchema, 'id' | 'createdAt'>>
+  ): Promise<RoadmapSchema> {
+    return this.updateItem(
+      projectId,
+      (feature) => feature.id === id,
+      (feature) => ({ ...feature, ...updates })
+    )
+  }
+
+  async setStatus(
+    projectId: string,
+    id: string,
+    status: FeatureStatus
+  ): Promise<RoadmapSchema> {
+    const updates: Partial<FeatureSchema> = { status }
+    if (status === 'completed' || status === 'shipped') {
+      updates.completedAt = new Date().toISOString()
+    }
+    return this.updateFeature(projectId, id, updates)
+  }
+
+  async addTask(
+    projectId: string,
+    featureId: string,
+    task: FeatureTask
+  ): Promise<RoadmapSchema> {
+    return this.updateItem(
+      projectId,
+      (feature) => feature.id === featureId,
+      (feature) => ({
+        ...feature,
+        tasks: [...feature.tasks, task]
+      })
+    )
+  }
+
+  async completeTask(
+    projectId: string,
+    featureId: string,
+    taskIndex: number
+  ): Promise<RoadmapSchema> {
+    return this.updateItem(
+      projectId,
+      (feature) => feature.id === featureId,
+      (feature) => ({
+        ...feature,
+        tasks: feature.tasks.map((task, i) =>
+          i === taskIndex ? { ...task, completed: true } : task
+        )
+      })
+    )
+  }
+
+  async removeFeature(projectId: string, id: string): Promise<RoadmapSchema> {
+    return this.remove(projectId, (feature) => feature.id === id)
+  }
+
+  async getProgress(projectId: string, featureId: string): Promise<number> {
+    const feature = await this.getFeature(projectId, featureId)
+    if (!feature || feature.tasks.length === 0) return 0
+    const completed = feature.tasks.filter((t) => t.completed).length
+    return Math.round((completed / feature.tasks.length) * 100)
+  }
+}
+
+export const roadmapManager = new RoadmapManager()
+export default roadmapManager

package/core/data/shipped-manager.ts

@@ -0,0 +1,65 @@
+/**
+ * Shipped Manager
+ *
+ * Manages shipped.json - completed/shipped items history.
+ */
+
+import { ArrayManager } from './base-manager'
+import type { ShippedItemSchema, ShippedSchema } from '../schemas'
+
+class ShippedManager extends ArrayManager<ShippedItemSchema> {
+  constructor() {
+    super('shipped.json')
+  }
+
+  async getShipped(projectId: string): Promise<ShippedSchema> {
+    return this.read(projectId)
+  }
+
+  async getRecentShipped(projectId: string, limit = 10): Promise<ShippedSchema> {
+    const shipped = await this.read(projectId)
+    return shipped
+      .sort((a, b) => new Date(b.shippedAt).getTime() - new Date(a.shippedAt).getTime())
+      .slice(0, limit)
+  }
+
+  async addShipped(
+    projectId: string,
+    item: Omit<ShippedItemSchema, 'id' | 'shippedAt'>
+  ): Promise<ShippedSchema> {
+    const shippedItem: ShippedItemSchema = {
+      ...item,
+      id: `shipped_${Date.now()}`,
+      shippedAt: new Date().toISOString()
+    }
+    return this.add(projectId, shippedItem)
+  }
+
+  async getByFeature(projectId: string, featureId: string): Promise<ShippedSchema> {
+    const shipped = await this.read(projectId)
+    return shipped.filter((item) => item.featureId === featureId)
+  }
+
+  async getTotalDuration(projectId: string): Promise<string> {
+    const shipped = await this.read(projectId)
+    // Parse durations and sum (simplified - assumes format like "2h 30m")
+    let totalMinutes = 0
+    for (const item of shipped) {
+      const hours = item.duration.match(/(\d+)h/)
+      const minutes = item.duration.match(/(\d+)m/)
+      if (hours) totalMinutes += parseInt(hours[1]) * 60
+      if (minutes) totalMinutes += parseInt(minutes[1])
+    }
+    const h = Math.floor(totalMinutes / 60)
+    const m = totalMinutes % 60
+    return h > 0 ? `${h}h ${m}m` : `${m}m`
+  }
+
+  async getCount(projectId: string): Promise<number> {
+    const shipped = await this.read(projectId)
+    return shipped.length
+  }
+}
+
+export const shippedManager = new ShippedManager()
+export default shippedManager

package/core/data/state-manager.ts

@@ -0,0 +1,214 @@
+/**
+ * State Manager
+ *
+ * Manages state.json - the unified project state.
+ */
+
+import { BaseManager } from './base-manager'
+import type {
+  StateSchema,
+  CurrentTask,
+  QueuedTask,
+  RecentActivity,
+  Stats
+} from '../schemas'
+import { DEFAULT_STATE, DEFAULT_STATS } from '../schemas'
+
+const MAX_RECENT_ACTIVITY = 10
+
+class StateManager extends BaseManager<StateSchema> {
+  constructor() {
+    super('state.json')
+  }
+
+  protected getDefault(projectId: string): StateSchema {
+    return {
+      ...DEFAULT_STATE,
+      projectId,
+      lastSync: new Date().toISOString()
+    }
+  }
+
+  // =========== Current Task ===========
+
+  async getCurrentTask(projectId: string): Promise<CurrentTask | null> {
+    const state = await this.read(projectId)
+    return state.currentTask
+  }
+
+  async setCurrentTask(projectId: string, task: CurrentTask | null): Promise<StateSchema> {
+    return this.update(projectId, (state) => ({
+      ...state,
+      currentTask: task,
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  async startTask(
+    projectId: string,
+    task: Omit<CurrentTask, 'startedAt'>
+  ): Promise<StateSchema> {
+    const currentTask: CurrentTask = {
+      ...task,
+      startedAt: new Date().toISOString()
+    }
+
+    return this.update(projectId, (state) => ({
+      ...state,
+      currentTask,
+      recentActivity: [
+        {
+          type: 'session_started' as const,
+          description: task.description,
+          timestamp: new Date().toISOString()
+        },
+        ...state.recentActivity
+      ].slice(0, MAX_RECENT_ACTIVITY),
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  async completeTask(projectId: string, duration: string): Promise<StateSchema> {
+    const state = await this.read(projectId)
+    if (!state.currentTask) {
+      throw new Error('No active task to complete')
+    }
+
+    const activity: RecentActivity = {
+      type: 'task_completed',
+      description: state.currentTask.description,
+      timestamp: new Date().toISOString(),
+      duration
+    }
+
+    return this.update(projectId, (s) => ({
+      ...s,
+      currentTask: null,
+      recentActivity: [activity, ...s.recentActivity].slice(0, MAX_RECENT_ACTIVITY),
+      stats: {
+        ...s.stats,
+        tasksToday: s.stats.tasksToday + 1
+      },
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  async pauseTask(projectId: string, reason?: string): Promise<StateSchema> {
+    const state = await this.read(projectId)
+    if (!state.currentTask) {
+      throw new Error('No active task to pause')
+    }
+
+    return this.update(projectId, (s) => ({
+      ...s,
+      currentTask: s.currentTask
+        ? {
+            ...s.currentTask,
+            pausedAt: new Date().toISOString(),
+            pauseReason: reason
+          }
+        : null,
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  async resumeTask(projectId: string): Promise<StateSchema> {
+    const state = await this.read(projectId)
+    if (!state.currentTask?.pausedAt) {
+      throw new Error('No paused task to resume')
+    }
+
+    return this.update(projectId, (s) => ({
+      ...s,
+      currentTask: s.currentTask
+        ? {
+            ...s.currentTask,
+            pausedAt: undefined,
+            pauseReason: undefined
+          }
+        : null,
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  // =========== Queue ===========
+
+  async getQueue(projectId: string): Promise<QueuedTask[]> {
+    const state = await this.read(projectId)
+    return state.queue
+  }
+
+  async addToQueue(
+    projectId: string,
+    task: Omit<QueuedTask, 'id' | 'createdAt'>
+  ): Promise<StateSchema> {
+    const queuedTask: QueuedTask = {
+      ...task,
+      id: `task_${Date.now()}`,
+      createdAt: new Date().toISOString()
+    }
+
+    return this.update(projectId, (state) => ({
+      ...state,
+      queue: [...state.queue, queuedTask].sort((a, b) => {
+        const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 }
+        return priorityOrder[a.priority] - priorityOrder[b.priority]
+      }),
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  async removeFromQueue(projectId: string, taskId: string): Promise<StateSchema> {
+    return this.update(projectId, (state) => ({
+      ...state,
+      queue: state.queue.filter((t) => t.id !== taskId),
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  async getNextTask(projectId: string): Promise<QueuedTask | null> {
+    const state = await this.read(projectId)
+    return state.queue.find((t) => !t.blockedReason) || null
+  }
+
+  // =========== Stats ===========
+
+  async getStats(projectId: string): Promise<Stats> {
+    const state = await this.read(projectId)
+    return state.stats
+  }
+
+  async updateStats(projectId: string, stats: Partial<Stats>): Promise<StateSchema> {
+    return this.update(projectId, (state) => ({
+      ...state,
+      stats: { ...state.stats, ...stats },
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  async resetDailyStats(projectId: string): Promise<StateSchema> {
+    return this.update(projectId, (state) => ({
+      ...state,
+      stats: { ...state.stats, tasksToday: 0 },
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  // =========== Activity ===========
+
+  async addActivity(projectId: string, activity: RecentActivity): Promise<StateSchema> {
+    return this.update(projectId, (state) => ({
+      ...state,
+      recentActivity: [activity, ...state.recentActivity].slice(0, MAX_RECENT_ACTIVITY),
+      lastSync: new Date().toISOString()
+    }))
+  }
+
+  async getRecentActivity(projectId: string): Promise<RecentActivity[]> {
+    const state = await this.read(projectId)
+    return state.recentActivity
+  }
+}
+
+export const stateManager = new StateManager()
+export default stateManager