prjct-cli 0.20.0 → 0.20.1

package/core/services/project-service.ts

@@ -0,0 +1,146 @@
+/**
+ * ProjectService - Project detection, validation, and path resolution
+ *
+ * Handles project initialization detection, author management, and directory analysis.
+ */
+
+import configManager from '../infrastructure/config-manager'
+import pathManager from '../infrastructure/path-manager'
+import authorDetector from '../infrastructure/author-detector'
+import * as fileHelper from '../utils/file-helper'
+import out from '../utils/output'
+import type { Author, CommandResult } from '../types'
+import { ProjectError } from '../errors'
+
+export class ProjectService {
+  private currentAuthor: Author | null = null
+
+  /**
+   * Ensure project is initialized
+   */
+  async ensureInit(projectPath: string): Promise<CommandResult> {
+    if (await configManager.isConfigured(projectPath)) {
+      return { success: true }
+    }
+
+    out.spin('initializing project...')
+    // Lazy import to avoid circular dependency
+    const { PlanningCommands } = await import('../commands/planning')
+    const planning = new PlanningCommands()
+    const initResult = await planning.init(null, projectPath)
+
+    if (!initResult.success) {
+      return initResult
+    }
+    return { success: true }
+  }
+
+  /**
+   * Get project ID for a path
+   */
+  async getProjectId(projectPath: string): Promise<string> {
+    const projectId = await configManager.getProjectId(projectPath)
+    if (!projectId) {
+      throw ProjectError.notInitialized()
+    }
+    return projectId
+  }
+
+  /**
+   * Get global storage path for a project
+   */
+  async getGlobalPath(projectPath: string): Promise<string> {
+    const projectId = await this.getProjectId(projectPath)
+    await pathManager.ensureProjectStructure(projectId)
+    return pathManager.getGlobalProjectPath(projectId)
+  }
+
+  /**
+   * Ensure author information is loaded
+   */
+  async ensureAuthor(): Promise<Author> {
+    if (this.currentAuthor) return this.currentAuthor
+
+    const authorObj = await authorDetector.detect()
+    this.currentAuthor = {
+      name: authorObj.name ?? undefined,
+      email: authorObj.email ?? undefined,
+      github: authorObj.github ?? undefined,
+    }
+    return this.currentAuthor
+  }
+
+  /**
+   * Get current author
+   */
+  getCurrentAuthor(): Author | null {
+    return this.currentAuthor
+  }
+
+  /**
+   * Clear cached author (useful for tests)
+   */
+  clearAuthorCache(): void {
+    this.currentAuthor = null
+  }
+
+  /**
+   * Check if directory is empty (excluding common files)
+   */
+  async isEmptyDirectory(projectPath: string): Promise<boolean> {
+    try {
+      const entries = await fileHelper.listFiles(projectPath)
+      const meaningfulFiles = entries.filter(
+        (name) =>
+          !name.startsWith('.') &&
+          name !== 'node_modules' &&
+          name !== 'package.json' &&
+          name !== 'package-lock.json' &&
+          name !== 'README.md'
+      )
+      return meaningfulFiles.length === 0
+    } catch {
+      return true
+    }
+  }
+
+  /**
+   * Check if directory has existing code
+   */
+  async hasExistingCode(projectPath: string): Promise<boolean> {
+    try {
+      const codePatterns = [
+        'src',
+        'lib',
+        'app',
+        'components',
+        'pages',
+        'api',
+        'main.go',
+        'main.rs',
+        'main.py',
+      ]
+      const entries = await fileHelper.listFiles(projectPath)
+      return entries.some((name) => codePatterns.includes(name))
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Check if project is configured
+   */
+  async isConfigured(projectPath: string): Promise<boolean> {
+    return await configManager.isConfigured(projectPath)
+  }
+
+  /**
+   * Check if project needs migration
+   */
+  async needsMigration(projectPath: string): Promise<boolean> {
+    return await configManager.needsMigration(projectPath)
+  }
+}
+
+export const projectService = new ProjectService()
+export default projectService

package/core/services/skill-service.ts

@@ -0,0 +1,253 @@
+/**
+ * Skill Service
+ *
+ * Manages discoverable skills from SKILL.md files.
+ * Skills are reusable prompts/instructions with metadata.
+ *
+ * Skill sources (in priority order):
+ * 1. Project: .prjct/skills/*.md
+ * 2. Global: ~/.prjct-cli/skills/*.md
+ * 3. Built-in: templates/skills/*.md
+ *
+ * @version 1.0.0
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import { glob } from 'glob'
+
+import type { SkillMetadata, Skill, SkillSearchResult } from '../types'
+
+/**
+ * Parse YAML-like frontmatter from markdown
+ */
+function parseFrontmatter(content: string): { metadata: Record<string, unknown>; body: string } {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/
+  const match = content.match(frontmatterRegex)
+
+  if (!match) {
+    return { metadata: {}, body: content }
+  }
+
+  const [, frontmatter, body] = match
+  const metadata: Record<string, unknown> = {}
+
+  // Simple YAML parsing (key: value)
+  for (const line of frontmatter.split('\n')) {
+    const colonIndex = line.indexOf(':')
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim()
+      let value: unknown = line.slice(colonIndex + 1).trim()
+
+      // Handle arrays [item1, item2]
+      if (typeof value === 'string' && value.startsWith('[') && value.endsWith(']')) {
+        value = value.slice(1, -1).split(',').map(s => s.trim().replace(/['"]/g, ''))
+      }
+      // Remove quotes
+      else if (typeof value === 'string' && (value.startsWith('"') || value.startsWith("'"))) {
+        value = value.slice(1, -1)
+      }
+
+      metadata[key] = value
+    }
+  }
+
+  return { metadata, body: body.trim() }
+}
+
+/**
+ * Convert filename to skill ID
+ */
+function fileToSkillId(filePath: string): string {
+  const basename = path.basename(filePath, '.md')
+  return basename.toLowerCase().replace(/[^a-z0-9]+/g, '-')
+}
+
+class SkillService {
+  private skills: Map<string, Skill> = new Map()
+  private loaded = false
+
+  /**
+   * Get all skill directories in order of priority
+   */
+  private getSkillDirs(projectPath?: string): Array<{ dir: string; source: Skill['source'] }> {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '~'
+    const dirs: Array<{ dir: string; source: Skill['source'] }> = []
+
+    // Project skills (highest priority)
+    if (projectPath) {
+      dirs.push({ dir: path.join(projectPath, '.prjct', 'skills'), source: 'project' })
+    }
+
+    // Global skills
+    dirs.push({ dir: path.join(homeDir, '.prjct-cli', 'skills'), source: 'global' })
+
+    // Built-in skills (lowest priority)
+    dirs.push({ dir: path.join(__dirname, '..', '..', 'templates', 'skills'), source: 'builtin' })
+
+    return dirs
+  }
+
+  /**
+   * Load a single skill from file
+   */
+  private async loadSkill(filePath: string, source: Skill['source']): Promise<Skill | null> {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8')
+      const { metadata, body } = parseFrontmatter(content)
+
+      const id = fileToSkillId(filePath)
+      const name = (metadata.name as string) || id
+
+      return {
+        id,
+        name,
+        description: (metadata.description as string) || '',
+        content: body,
+        source,
+        filePath,
+        metadata: {
+          name,
+          description: metadata.description as string,
+          agent: metadata.agent as string,
+          tags: metadata.tags as string[],
+          version: metadata.version as string,
+        },
+      }
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Load all skills from all sources
+   */
+  async loadSkills(projectPath?: string): Promise<void> {
+    this.skills.clear()
+    const dirs = this.getSkillDirs(projectPath)
+
+    for (const { dir, source } of dirs) {
+      try {
+        const files = await glob('*.md', { cwd: dir, absolute: true })
+
+        for (const file of files) {
+          const skill = await this.loadSkill(file, source)
+          if (skill && !this.skills.has(skill.id)) {
+            // Don't override higher priority skills
+            this.skills.set(skill.id, skill)
+          }
+        }
+      } catch {
+        // Directory doesn't exist, skip
+      }
+    }
+
+    this.loaded = true
+  }
+
+  /**
+   * Get all loaded skills
+   */
+  async getAll(projectPath?: string): Promise<Skill[]> {
+    if (!this.loaded) {
+      await this.loadSkills(projectPath)
+    }
+    return Array.from(this.skills.values())
+  }
+
+  /**
+   * Get a skill by ID
+   */
+  async get(id: string, projectPath?: string): Promise<Skill | null> {
+    if (!this.loaded) {
+      await this.loadSkills(projectPath)
+    }
+    return this.skills.get(id) || null
+  }
+
+  /**
+   * Search skills by query
+   */
+  async search(query: string, projectPath?: string): Promise<SkillSearchResult[]> {
+    const skills = await this.getAll(projectPath)
+    const queryLower = query.toLowerCase()
+
+    const results: SkillSearchResult[] = []
+
+    for (const skill of skills) {
+      let relevance = 0
+
+      // Name match (highest weight)
+      if (skill.name.toLowerCase().includes(queryLower)) {
+        relevance += 10
+      }
+      if (skill.id.includes(queryLower)) {
+        relevance += 8
+      }
+
+      // Description match
+      if (skill.description.toLowerCase().includes(queryLower)) {
+        relevance += 5
+      }
+
+      // Tag match
+      if (skill.metadata.tags?.some(t => t.toLowerCase().includes(queryLower))) {
+        relevance += 3
+      }
+
+      // Content match (lowest weight)
+      if (skill.content.toLowerCase().includes(queryLower)) {
+        relevance += 1
+      }
+
+      if (relevance > 0) {
+        results.push({ skill, relevance })
+      }
+    }
+
+    // Sort by relevance descending
+    return results.sort((a, b) => b.relevance - a.relevance)
+  }
+
+  /**
+   * List skills grouped by source
+   */
+  async listBySource(projectPath?: string): Promise<Record<Skill['source'], Skill[]>> {
+    const skills = await this.getAll(projectPath)
+
+    const grouped: Record<Skill['source'], Skill[]> = {
+      project: [],
+      global: [],
+      builtin: [],
+    }
+
+    for (const skill of skills) {
+      grouped[skill.source].push(skill)
+    }
+
+    return grouped
+  }
+
+  /**
+   * Force reload skills
+   */
+  async reload(projectPath?: string): Promise<void> {
+    this.loaded = false
+    await this.loadSkills(projectPath)
+  }
+
+  /**
+   * Get skill count
+   */
+  async count(projectPath?: string): Promise<number> {
+    const skills = await this.getAll(projectPath)
+    return skills.length
+  }
+}
+
+// Singleton instance
+const skillService = new SkillService()
+export default skillService
+
+// Export class for testing
+export { SkillService }

package/core/session/compaction.ts

@@ -0,0 +1,257 @@
+/**
+ * Context Compaction
+ *
+ * Compresses conversation context while preserving semantics.
+ * Useful for long sessions to prevent context overflow.
+ *
+ * Inspired by opencode's context management system.
+ *
+ * @version 1.0.0
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import { getTimestamp } from '../utils/date-helper'
+import type { ConversationTurn, CompactedContext, CompactionConfig } from '../types'
+
+export type { ConversationTurn, CompactedContext, CompactionConfig } from '../types'
+
+const DEFAULT_CONFIG: Required<CompactionConfig> = {
+  maxTurns: 50,
+  maxTokens: 100000,
+  preserveRecent: 10,
+  summaryMaxLength: 2000,
+}
+
+/**
+ * Estimate token count (rough approximation)
+ */
+function estimateTokens(text: string): number {
+  // Rough estimate: ~4 chars per token
+  return Math.ceil(text.length / 4)
+}
+
+/**
+ * Extract key information from conversation
+ */
+function extractKeyInfo(turns: ConversationTurn[]): {
+  decisions: string[]
+  filesModified: string[]
+  tasksCompleted: string[]
+} {
+  const decisions: string[] = []
+  const filesModified = new Set<string>()
+  const tasksCompleted: string[] = []
+
+  for (const turn of turns) {
+    const content = turn.content
+
+    // Extract decisions (patterns like "decided to", "will use", "choosing")
+    const decisionPatterns = [
+      /decided to ([^.]+)/gi,
+      /will use ([^.]+)/gi,
+      /choosing ([^.]+)/gi,
+      /going with ([^.]+)/gi,
+    ]
+
+    for (const pattern of decisionPatterns) {
+      const matches = content.matchAll(pattern)
+      for (const match of matches) {
+        decisions.push(match[1].trim())
+      }
+    }
+
+    // Extract file modifications
+    const filePatterns = [
+      /(?:created|modified|updated|edited|wrote to)\s+[`"]?([a-zA-Z0-9_\-./]+\.[a-zA-Z]+)[`"]?/gi,
+      /File (?:created|updated).*?:\s*([a-zA-Z0-9_\-./]+\.[a-zA-Z]+)/gi,
+    ]
+
+    for (const pattern of filePatterns) {
+      const matches = content.matchAll(pattern)
+      for (const match of matches) {
+        filesModified.add(match[1])
+      }
+    }
+
+    // Extract completed tasks
+    const taskPatterns = [
+      /✅\s*(.+)/g,
+      /completed[:\s]+(.+)/gi,
+      /finished[:\s]+(.+)/gi,
+    ]
+
+    for (const pattern of taskPatterns) {
+      const matches = content.matchAll(pattern)
+      for (const match of matches) {
+        const task = match[1].trim()
+        if (task.length < 100) { // Avoid capturing large blocks
+          tasksCompleted.push(task)
+        }
+      }
+    }
+  }
+
+  return {
+    decisions: [...new Set(decisions)].slice(0, 10),
+    filesModified: [...filesModified].slice(0, 20),
+    tasksCompleted: [...new Set(tasksCompleted)].slice(0, 10),
+  }
+}
+
+/**
+ * Generate summary from conversation turns
+ */
+function generateSummary(turns: ConversationTurn[], maxLength: number): string {
+  // Get key user requests
+  const userRequests = turns
+    .filter(t => t.role === 'user')
+    .map(t => t.content.slice(0, 200))
+    .slice(0, 5)
+
+  // Get key assistant actions
+  const assistantActions = turns
+    .filter(t => t.role === 'assistant')
+    .map(t => {
+      // Extract first meaningful sentence
+      const firstLine = t.content.split('\n')[0]
+      return firstLine.slice(0, 150)
+    })
+    .filter(a => a.length > 10)
+    .slice(0, 5)
+
+  const summary = [
+    '## Session Summary',
+    '',
+    '### User Requests:',
+    ...userRequests.map((r, i) => `${i + 1}. ${r.slice(0, 100)}...`),
+    '',
+    '### Key Actions:',
+    ...assistantActions.map((a, i) => `${i + 1}. ${a}`),
+  ].join('\n')
+
+  return summary.slice(0, maxLength)
+}
+
+/**
+ * Compact conversation context
+ */
+export function compactContext(
+  turns: ConversationTurn[],
+  config: CompactionConfig = {}
+): CompactedContext {
+  const cfg = { ...DEFAULT_CONFIG, ...config }
+
+  const { decisions, filesModified, tasksCompleted } = extractKeyInfo(turns)
+  const summary = generateSummary(turns, cfg.summaryMaxLength)
+
+  return {
+    summary,
+    keyPoints: decisions.slice(0, 5),
+    decisions,
+    filesModified,
+    tasksCompleted,
+    originalTurns: turns.length,
+    compactedAt: getTimestamp(),
+  }
+}
+
+/**
+ * Check if compaction is needed
+ */
+export function needsCompaction(
+  turns: ConversationTurn[],
+  config: CompactionConfig = {}
+): boolean {
+  const cfg = { ...DEFAULT_CONFIG, ...config }
+
+  // Check turn count
+  if (turns.length > cfg.maxTurns) {
+    return true
+  }
+
+  // Check token count
+  const totalTokens = turns.reduce((sum, t) => sum + estimateTokens(t.content), 0)
+  if (totalTokens > cfg.maxTokens) {
+    return true
+  }
+
+  return false
+}
+
+/**
+ * Save compacted context to file
+ */
+export async function saveCompactedContext(
+  projectId: string,
+  context: CompactedContext
+): Promise<string> {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '~'
+  const dirPath = path.join(homeDir, '.prjct-cli', 'projects', projectId, 'memory')
+  const filePath = path.join(dirPath, 'compacted.jsonl')
+
+  await fs.mkdir(dirPath, { recursive: true })
+
+  const line = JSON.stringify(context) + '\n'
+  await fs.appendFile(filePath, line, 'utf-8')
+
+  return filePath
+}
+
+/**
+ * Load recent compacted contexts
+ */
+export async function loadCompactedContexts(
+  projectId: string,
+  limit = 5
+): Promise<CompactedContext[]> {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '~'
+  const filePath = path.join(
+    homeDir, '.prjct-cli', 'projects', projectId, 'memory', 'compacted.jsonl'
+  )
+
+  try {
+    const content = await fs.readFile(filePath, 'utf-8')
+    const lines = content.trim().split('\n').filter(Boolean)
+    const contexts = lines.map(line => JSON.parse(line) as CompactedContext)
+
+    // Return most recent
+    return contexts.slice(-limit)
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Format compacted context for prompt injection
+ */
+export function formatCompactedForPrompt(context: CompactedContext): string {
+  const lines = [
+    '<compacted-context>',
+    context.summary,
+    '',
+  ]
+
+  if (context.filesModified.length > 0) {
+    lines.push('### Files Modified:')
+    lines.push(context.filesModified.map(f => `- ${f}`).join('\n'))
+    lines.push('')
+  }
+
+  if (context.tasksCompleted.length > 0) {
+    lines.push('### Tasks Completed:')
+    lines.push(context.tasksCompleted.map(t => `- ${t}`).join('\n'))
+    lines.push('')
+  }
+
+  if (context.decisions.length > 0) {
+    lines.push('### Decisions Made:')
+    lines.push(context.decisions.map(d => `- ${d}`).join('\n'))
+    lines.push('')
+  }
+
+  lines.push(`*Compacted from ${context.originalTurns} turns at ${context.compactedAt}*`)
+  lines.push('</compacted-context>')
+
+  return lines.join('\n')
+}

package/core/session/index.ts

@@ -1,17 +1,29 @@
 /**
- * SessionManager - Structured Session Tracking
+ * Session Management - Consolidated Module
  *
- * Tracks work sessions with metrics, timeline, and duration.
- * Inspired by OpenCode's session system but simplified.
+ * Two managers with distinct purposes:
+ * - TaskSessionManager: Task lifecycle (start, pause, complete)
+ * - SessionLogManager: Log fragmentation (JSONL temporal)
  *
  * Storage: ~/.prjct-cli/projects/{projectId}/sessions/
  *
- * @version 1.0.0
+ * @version 2.0.0
  */
 
-export type { Session, SessionMetrics, TimelineEvent } from './types'
+// Task session types and utilities
+export type { Session, SessionMetrics, TimelineEvent } from '../types'
 export { generateId, calculateDuration, formatDuration } from './utils'
-export { SessionManager } from './session-manager'
 
-import { SessionManager } from './session-manager'
-export default SessionManager
+// Log session types
+export type { SessionEntry, SessionLogMetadata, SessionStats, MigrationResult } from '../types'
+
+// Main exports
+export { TaskSessionManager } from './task-session-manager'
+export { SessionLogManager } from './session-log-manager'
+
+// Default: TaskSessionManager for backward compatibility
+import { TaskSessionManager } from './task-session-manager'
+export default TaskSessionManager
+
+// Alias for backward compatibility
+export { TaskSessionManager as SessionManager } from './task-session-manager'