prjct-cli 0.11.5 → 0.12.0

package/core/constants/formats.ts

@@ -0,0 +1,187 @@
+/**
+ * File Format Constants
+ *
+ * Single source of truth for all file patterns and formats used in prjct.
+ * Use these constants instead of hardcoded strings.
+ *
+ * @example
+ * ```typescript
+ * import { FORMATS, STATUS } from '../constants/formats'
+ *
+ * // Instead of:
+ * const nowContent = `# NOW\n\n**${task}**`
+ *
+ * // Use:
+ * const nowContent = FORMATS.NOW.header(task)
+ * ```
+ */
+
+/**
+ * NOW file format patterns.
+ */
+export const NOW = {
+  /** Header marker for NOW file */
+  HEADER: '# NOW',
+
+  /** Pattern to extract task from NOW content */
+  TASK_PATTERN: /\*\*(.+?)\*\*/,
+
+  /** Generate NOW file content */
+  content: (task: string, startedAt: string, agent?: string, confidence?: number): string => {
+    const lines = [
+      '# NOW',
+      '',
+      `**${task}**`,
+      '',
+      `Started: ${startedAt}`,
+    ]
+    if (agent) {
+      lines.push(`Agent: ${agent}${confidence ? ` (${Math.round(confidence * 100)}% confidence)` : ''}`)
+    }
+    return lines.join('\n') + '\n'
+  },
+
+  /** Extract task from NOW content */
+  extractTask: (content: string): string | null => {
+    const match = content.match(NOW.TASK_PATTERN)
+    return match ? match[1] : null
+  },
+} as const
+
+/**
+ * SHIPPED file format patterns.
+ */
+export const SHIPPED = {
+  /** Header marker for SHIPPED file */
+  HEADER: '# SHIPPED 🚀',
+
+  /** Generate ship entry */
+  entry: (feature: string, date: string, duration?: string): string => {
+    const lines = [
+      `## ${feature}`,
+      '',
+      `Shipped: ${date}`,
+    ]
+    if (duration) {
+      lines.push(`Duration: ${duration}`)
+    }
+    return lines.join('\n') + '\n\n'
+  },
+} as const
+
+/**
+ * NEXT file format patterns.
+ */
+export const NEXT = {
+  /** Header marker for NEXT file */
+  HEADER: '# NEXT',
+
+  /** Pattern for task entries */
+  TASK_PATTERN: /^[-*]\s+\[([x ])\]\s+(.+)$/gm,
+
+  /** Generate task entry */
+  entry: (task: string, completed: boolean = false): string => {
+    return `- [${completed ? 'x' : ' '}] ${task}\n`
+  },
+} as const
+
+/**
+ * IDEAS file format patterns.
+ */
+export const IDEAS = {
+  /** Header marker for IDEAS file */
+  HEADER: '# IDEAS 💡',
+
+  /** Generate idea entry */
+  entry: (idea: string, date: string): string => {
+    return `- ${idea} _(${date})_\n`
+  },
+} as const
+
+/**
+ * ROADMAP file format patterns.
+ */
+export const ROADMAP = {
+  /** Header marker for ROADMAP file */
+  HEADER: '# ROADMAP 🗺️',
+
+  /** Status markers */
+  STATUS: {
+    PLANNED: '📋 Planned',
+    IN_PROGRESS: '🚧 In Progress',
+    COMPLETED: '✅ Completed',
+    BLOCKED: '🚫 Blocked',
+  },
+
+  /** Generate feature entry */
+  entry: (feature: string, status: keyof typeof ROADMAP.STATUS, tasks?: string[]): string => {
+    const lines = [
+      `## ${feature}`,
+      '',
+      `Status: ${ROADMAP.STATUS[status]}`,
+    ]
+    if (tasks && tasks.length > 0) {
+      lines.push('', '### Tasks', '')
+      tasks.forEach(task => lines.push(`- [ ] ${task}`))
+    }
+    return lines.join('\n') + '\n\n'
+  },
+} as const
+
+/**
+ * Session file paths.
+ */
+export const SESSION = {
+  /** Date format for session directories */
+  DATE_FORMAT: 'YYYY-MM-DD',
+
+  /** Generate session path */
+  path: (year: string, month: string, day: string): string => {
+    return `sessions/${year}-${month}/${year}-${month}-${day}`
+  },
+
+  /** Session metadata filename */
+  METADATA_FILE: 'session-meta.json',
+
+  /** Context log filename */
+  CONTEXT_FILE: 'context.jsonl',
+} as const
+
+/**
+ * Status values used throughout prjct.
+ */
+export const STATUS = {
+  PENDING: 'pending',
+  IN_PROGRESS: 'in_progress',
+  COMPLETED: 'completed',
+  BLOCKED: 'blocked',
+  PAUSED: 'paused',
+} as const
+
+export type Status = typeof STATUS[keyof typeof STATUS]
+
+/**
+ * Priority levels.
+ */
+export const PRIORITY = {
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  CRITICAL: 'critical',
+} as const
+
+export type Priority = typeof PRIORITY[keyof typeof PRIORITY]
+
+/**
+ * Combined exports for easy import.
+ */
+export const FORMATS = {
+  NOW,
+  SHIPPED,
+  NEXT,
+  IDEAS,
+  ROADMAP,
+  SESSION,
+  STATUS,
+  PRIORITY,
+} as const

package/core/constants/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Constants Module
+ *
+ * Centralized constants for prjct-cli.
+ */
+
+export * from './formats'

package/core/{context-sync.js → context-sync.ts}

@@ -13,24 +13,56 @@
  * Called by: /p:sync, /p:analyze, /p:init
  */
 
-const fs = require('fs').promises
-const path = require('path')
-const os = require('os')
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+
+interface StackInfo {
+  primary: string | null
+  full: string | null
+  languages: string[]
+  frameworks: string[]
+  dependencies: string[]
+}
+
+interface ProjectStructure {
+  fileCount: number | null
+  directories: string[]
+}
+
+interface GitCommit {
+  hash: string
+  message: string
+}
+
+interface GitStats {
+  commits: number | null
+  contributors: number | null
+  recentCommits: GitCommit[]
+}
+
+interface AgentExpertise {
+  name: string
+  role: string
+  expertise: string
+}
+
+interface ContextResult {
+  agents: string[]
+  stack: StackInfo
+  currentTask: string | null
+}
 
 /**
  * Generate RICH project context file for Claude
  * Embeds key information so Claude doesn't need to read multiple files
- *
- * @param {string} projectPath - Local project path
- * @param {string} projectId - Project ID from config
- * @returns {Promise<{agents: string[], stack: object, currentTask: string|null}>}
  */
-async function generateLocalContext(projectPath, projectId) {
+async function generateLocalContext(projectPath: string, projectId: string): Promise<ContextResult> {
   const globalPath = path.join(os.homedir(), '.prjct-cli/projects', projectId)
   const projectName = path.basename(projectPath)
 
   // Helper to read files safely
-  const readSafe = async (p) => {
+  const readSafe = async (p: string): Promise<string | null> => {
     try {
       return await fs.readFile(p, 'utf-8')
     } catch {
@@ -40,7 +72,7 @@ async function generateLocalContext(projectPath, projectId) {
 
   // 1. Read ALL data sources in parallel
   const agentsDir = path.join(globalPath, 'agents')
-  let agentFiles = []
+  let agentFiles: string[] = []
   try {
     agentFiles = await fs.readdir(agentsDir)
     agentFiles = agentFiles.filter(f => f.endsWith('.md'))
@@ -152,10 +184,10 @@ For detailed information, read these files:
 /**
  * Extract FULL stack info from repo-summary
  */
-function extractFullStack(summary) {
-  if (!summary) return { primary: null, full: null }
+function extractFullStack(summary: string | null): StackInfo {
+  if (!summary) return { primary: null, full: null, languages: [], frameworks: [], dependencies: [] }
 
-  const result = { primary: null, full: null, languages: [], frameworks: [], dependencies: [] }
+  const result: StackInfo = { primary: null, full: null, languages: [], frameworks: [], dependencies: [] }
 
   // Extract languages (e.g., "### JavaScript/TypeScript")
   const langMatch = summary.match(/###\s*(JavaScript|TypeScript|Python|Go|Rust|Ruby|Java|C#|PHP)/i)
@@ -177,10 +209,10 @@ function extractFullStack(summary) {
 /**
  * Extract project structure from repo-summary
  */
-function extractProjectStructure(summary) {
+function extractProjectStructure(summary: string | null): ProjectStructure {
   if (!summary) return { fileCount: null, directories: [] }
 
-  const result = { fileCount: null, directories: [] }
+  const result: ProjectStructure = { fileCount: null, directories: [] }
 
   // Extract file count
   const fileMatch = summary.match(/\*\*Total Files\*\*:\s*(\d+)/i)
@@ -196,10 +228,10 @@ function extractProjectStructure(summary) {
 /**
  * Extract git stats from repo-summary
  */
-function extractGitStats(summary) {
+function extractGitStats(summary: string | null): GitStats {
   if (!summary) return { commits: null, contributors: null, recentCommits: [] }
 
-  const result = { commits: null, contributors: null, recentCommits: [] }
+  const result: GitStats = { commits: null, contributors: null, recentCommits: [] }
 
   // Extract commit count
   const commitMatch = summary.match(/\*\*Total Commits\*\*:\s*(\d+)/i)
@@ -217,7 +249,7 @@ function extractGitStats(summary) {
       result.recentCommits = commitLines.slice(0, 5).map(line => {
         const match = line.match(/- `([a-f0-9]+)` (.+?) \(/)
         return match ? { hash: match[1], message: match[2] } : null
-      }).filter(Boolean)
+      }).filter((c): c is GitCommit => c !== null)
     }
   }
 
@@ -227,8 +259,8 @@ function extractGitStats(summary) {
 /**
  * Extract agent expertise from agent files
  */
-async function extractAgentExpertise(agentsDir, agentFiles) {
-  const expertise = []
+async function extractAgentExpertise(agentsDir: string, agentFiles: string[]): Promise<AgentExpertise[]> {
+  const expertise: AgentExpertise[] = []
 
   for (const file of agentFiles.slice(0, 6)) { // Max 6 agents to keep context small
     try {
@@ -257,7 +289,7 @@ async function extractAgentExpertise(agentsDir, agentFiles) {
 /**
  * Extract current task from now.md
  */
-function extractCurrentTask(now) {
+function extractCurrentTask(now: string | null): string | null {
   if (!now) return null
 
   const lines = now.split('\n')
@@ -273,7 +305,7 @@ function extractCurrentTask(now) {
 /**
  * Extract top N tasks from next.md
  */
-function extractTopTasks(next, count) {
+function extractTopTasks(next: string | null, count: number): string[] {
   if (!next) return []
 
   return next
@@ -287,10 +319,10 @@ function extractTopTasks(next, count) {
 /**
  * Extract active features from roadmap.md
  */
-function extractActiveFeatures(roadmap) {
+function extractActiveFeatures(roadmap: string | null): string[] {
   if (!roadmap) return []
 
-  const features = []
+  const features: string[] = []
   const lines = roadmap.split('\n')
   let inActive = false
 
@@ -314,7 +346,7 @@ function extractActiveFeatures(roadmap) {
 /**
  * Extract recent ideas from ideas.md
  */
-function extractRecentIdeas(ideas) {
+function extractRecentIdeas(ideas: string | null): string[] {
   if (!ideas) return []
 
   return ideas
@@ -325,4 +357,5 @@ function extractRecentIdeas(ideas) {
     .filter(Boolean)
 }
 
-module.exports = { generateLocalContext }
+export { generateLocalContext }
+export default { generateLocalContext }

package/core/data/agents-manager.ts

@@ -0,0 +1,76 @@
+/**
+ * Agents Manager
+ *
+ * Manages agents.json - specialized AI agents.
+ */
+
+import { ArrayManager } from './base-manager'
+import type { AgentSchema, AgentsSchema } from '../schemas'
+import { DEFAULT_AGENT } from '../schemas'
+
+class AgentsManager extends ArrayManager<AgentSchema> {
+  constructor() {
+    super('agents.json')
+  }
+
+  async getAgents(projectId: string): Promise<AgentsSchema> {
+    return this.read(projectId)
+  }
+
+  async getAgent(projectId: string, name: string): Promise<AgentSchema | undefined> {
+    return this.find(projectId, (agent) => agent.name === name)
+  }
+
+  async addAgent(
+    projectId: string,
+    agent: Pick<AgentSchema, 'name' | 'description'> & Partial<AgentSchema>
+  ): Promise<AgentsSchema> {
+    const fullAgent: AgentSchema = {
+      ...DEFAULT_AGENT,
+      ...agent
+    }
+    return this.add(projectId, fullAgent)
+  }
+
+  async updateAgent(
+    projectId: string,
+    name: string,
+    updates: Partial<AgentSchema>
+  ): Promise<AgentsSchema> {
+    return this.updateItem(
+      projectId,
+      (agent) => agent.name === name,
+      (agent) => ({ ...agent, ...updates })
+    )
+  }
+
+  async removeAgent(projectId: string, name: string): Promise<AgentsSchema> {
+    return this.remove(projectId, (agent) => agent.name === name)
+  }
+
+  async setAgents(projectId: string, agents: AgentsSchema): Promise<void> {
+    await this.write(projectId, agents)
+  }
+
+  async incrementTasksCompleted(projectId: string, name: string): Promise<AgentsSchema> {
+    return this.updateItem(
+      projectId,
+      (agent) => agent.name === name,
+      (agent) => ({
+        ...agent,
+        tasksCompleted: (agent.tasksCompleted || 0) + 1
+      })
+    )
+  }
+
+  async updateSuccessRate(
+    projectId: string,
+    name: string,
+    successRate: number
+  ): Promise<AgentsSchema> {
+    return this.updateAgent(projectId, name, { successRate })
+  }
+}
+
+export const agentsManager = new AgentsManager()
+export default agentsManager

package/core/data/analysis-manager.ts

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

@@ -0,0 +1,156 @@
+/**
+ * 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))
+    )
+  }
+}