prjct-cli 0.13.3 → 0.15.0

package/core/data/analysis-manager.ts

@@ -1,83 +0,0 @@
-/**
- * Analysis Manager
- *
- * Manages analysis.json - repository analysis data.
- */
-
-import { BaseManager } from './base-manager'
-import type { AnalysisSchema, CodePattern, AntiPattern } from '../schemas'
-import { DEFAULT_ANALYSIS } from '../schemas'
-
-class AnalysisManager extends BaseManager<AnalysisSchema> {
-  constructor() {
-    super('analysis.json')
-  }
-
-  protected getDefault(projectId: string): AnalysisSchema {
-    return {
-      ...DEFAULT_ANALYSIS,
-      projectId,
-      analyzedAt: new Date().toISOString()
-    }
-  }
-
-  async getAnalysis(projectId: string): Promise<AnalysisSchema> {
-    return this.read(projectId)
-  }
-
-  async updateAnalysis(
-    projectId: string,
-    updates: Partial<Omit<AnalysisSchema, 'projectId'>>
-  ): Promise<AnalysisSchema> {
-    return this.update(projectId, (analysis) => ({
-      ...analysis,
-      ...updates,
-      analyzedAt: new Date().toISOString()
-    }))
-  }
-
-  async setLanguages(projectId: string, languages: string[]): Promise<AnalysisSchema> {
-    return this.updateAnalysis(projectId, { languages })
-  }
-
-  async setFrameworks(projectId: string, frameworks: string[]): Promise<AnalysisSchema> {
-    return this.updateAnalysis(projectId, { frameworks })
-  }
-
-  async addPattern(projectId: string, pattern: CodePattern): Promise<AnalysisSchema> {
-    return this.update(projectId, (analysis) => ({
-      ...analysis,
-      patterns: [...analysis.patterns, pattern],
-      analyzedAt: new Date().toISOString()
-    }))
-  }
-
-  async addAntiPattern(projectId: string, antiPattern: AntiPattern): Promise<AnalysisSchema> {
-    return this.update(projectId, (analysis) => ({
-      ...analysis,
-      antiPatterns: [...analysis.antiPatterns, antiPattern],
-      analyzedAt: new Date().toISOString()
-    }))
-  }
-
-  async setPatterns(projectId: string, patterns: CodePattern[]): Promise<AnalysisSchema> {
-    return this.updateAnalysis(projectId, { patterns })
-  }
-
-  async setAntiPatterns(projectId: string, antiPatterns: AntiPattern[]): Promise<AnalysisSchema> {
-    return this.updateAnalysis(projectId, { antiPatterns })
-  }
-
-  async getPatterns(projectId: string): Promise<CodePattern[]> {
-    const analysis = await this.read(projectId)
-    return analysis.patterns
-  }
-
-  async getAntiPatterns(projectId: string): Promise<AntiPattern[]> {
-    const analysis = await this.read(projectId)
-    return analysis.antiPatterns
-  }
-}
-
-export const analysisManager = new AnalysisManager()
-export default analysisManager

package/core/data/base-manager.ts

@@ -1,156 +0,0 @@
-/**
- * Base Manager
- *
- * Abstract base class for JSON file managers.
- * Provides common CRUD operations for all data types.
- */
-
-import path from 'path'
-import * as fileHelper from '../utils/file-helper'
-import pathManager from '../infrastructure/path-manager'
-
-export abstract class BaseManager<T> {
-  protected filename: string
-  protected cache: Map<string, T> = new Map()
-  protected cacheTimeout = 5000 // 5 seconds
-  protected lastRead: Map<string, number> = new Map()
-
-  constructor(filename: string) {
-    this.filename = filename
-  }
-
-  /**
-   * Get file path for a project.
-   */
-  protected getFilePath(projectId: string): string {
-    const globalPath = pathManager.getGlobalProjectPath(projectId)
-    return path.join(globalPath, this.filename)
-  }
-
-  /**
-   * Get default value for this data type.
-   */
-  protected abstract getDefault(projectId: string): T
-
-  /**
-   * Read data from JSON file.
-   */
-  async read(projectId: string): Promise<T> {
-    const now = Date.now()
-    const lastReadTime = this.lastRead.get(projectId) || 0
-
-    // Return cached if fresh
-    if (now - lastReadTime < this.cacheTimeout && this.cache.has(projectId)) {
-      return this.cache.get(projectId)!
-    }
-
-    const filePath = this.getFilePath(projectId)
-    const data = await fileHelper.readJson<T>(filePath, this.getDefault(projectId))
-
-    // Update cache
-    this.cache.set(projectId, data!)
-    this.lastRead.set(projectId, now)
-
-    return data!
-  }
-
-  /**
-   * Write data to JSON file.
-   */
-  async write(projectId: string, data: T): Promise<void> {
-    const filePath = this.getFilePath(projectId)
-
-    // Ensure directory exists
-    await fileHelper.ensureDir(path.dirname(filePath))
-
-    await fileHelper.writeJson(filePath, data)
-
-    // Update cache
-    this.cache.set(projectId, data)
-    this.lastRead.set(projectId, Date.now())
-  }
-
-  /**
-   * Check if file exists.
-   */
-  async exists(projectId: string): Promise<boolean> {
-    const filePath = this.getFilePath(projectId)
-    return fileHelper.fileExists(filePath)
-  }
-
-  /**
-   * Initialize with default data.
-   */
-  async initialize(projectId: string): Promise<T> {
-    const data = this.getDefault(projectId)
-    await this.write(projectId, data)
-    return data
-  }
-
-  /**
-   * Clear cache.
-   */
-  clearCache(projectId?: string): void {
-    if (projectId) {
-      this.cache.delete(projectId)
-      this.lastRead.delete(projectId)
-    } else {
-      this.cache.clear()
-      this.lastRead.clear()
-    }
-  }
-
-  /**
-   * Update data with a partial update.
-   */
-  async update(projectId: string, updater: (data: T) => T): Promise<T> {
-    const current = await this.read(projectId)
-    const updated = updater(current)
-    await this.write(projectId, updated)
-    return updated
-  }
-}
-
-/**
- * Base manager for array-based JSON files.
- */
-export abstract class ArrayManager<T> extends BaseManager<T[]> {
-  protected getDefault(): T[] {
-    return []
-  }
-
-  /**
-   * Add item to array.
-   */
-  async add(projectId: string, item: T): Promise<T[]> {
-    return this.update(projectId, (data) => [...data, item])
-  }
-
-  /**
-   * Remove item by predicate.
-   */
-  async remove(projectId: string, predicate: (item: T) => boolean): Promise<T[]> {
-    return this.update(projectId, (data) => data.filter((item) => !predicate(item)))
-  }
-
-  /**
-   * Find item by predicate.
-   */
-  async find(projectId: string, predicate: (item: T) => boolean): Promise<T | undefined> {
-    const data = await this.read(projectId)
-    return data.find(predicate)
-  }
-
-  /**
-   * Update item by predicate.
-   */
-  async updateItem(
-    projectId: string,
-    predicate: (item: T) => boolean,
-    updater: (item: T) => T
-  ): Promise<T[]> {
-    return this.update(projectId, (data) =>
-      data.map((item) => (predicate(item) ? updater(item) : item))
-    )
-  }
-}

package/core/data/ideas-manager.ts

@@ -1,81 +0,0 @@
-/**
- * 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/outcomes-manager.ts

@@ -1,96 +0,0 @@
-/**
- * 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

@@ -1,75 +0,0 @@
-/**
- * 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

@@ -1,118 +0,0 @@
-/**
- * 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

@@ -1,65 +0,0 @@
-/**
- * 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