prjct-cli 1.22.0 → 1.24.0

package/core/session/utils.ts

@@ -1,51 +0,0 @@
-/**
- * Session Utilities
- */
-
-import { generateUUID } from '../schemas'
-import type { Session } from '../types'
-
-/**
- * Generate unique session ID (re-export from schemas)
- */
-export const generateId = generateUUID
-
-/**
- * Calculate total duration in seconds
- */
-export function calculateDuration(session: Session): number {
-  let totalMs = 0
-  let lastStart: Date | null = null
-
-  for (const event of session.timeline) {
-    if (event.type === 'start' || event.type === 'resume') {
-      lastStart = new Date(event.at)
-    } else if (event.type === 'pause' || event.type === 'complete') {
-      if (lastStart) {
-        totalMs += new Date(event.at).getTime() - lastStart.getTime()
-        lastStart = null
-      }
-    }
-  }
-
-  // If still active, count from last start to now
-  if (lastStart && session.status === 'active') {
-    totalMs += Date.now() - lastStart.getTime()
-  }
-
-  return Math.round(totalMs / 1000)
-}
-
-/**
- * Format duration as human readable
- */
-export function formatDuration(seconds: number): string {
-  if (seconds < 60) return `${seconds}s`
-  if (seconds < 3600) return `${Math.round(seconds / 60)}m`
-
-  const hours = Math.floor(seconds / 3600)
-  const minutes = Math.round((seconds % 3600) / 60)
-
-  if (minutes === 0) return `${hours}h`
-  return `${hours}h ${minutes}m`
-}

package/core/storage/analysis-storage.ts

@@ -1,373 +0,0 @@
-/**
- * Analysis Storage (PRJ-263)
- *
- * Manages sealable analysis with dual storage:
- * - storage/analysis.json       (current draft)
- * - storage/analysis-sealed.json (locked sealed version)
- *
- * Lifecycle: DRAFT → VERIFIED → SEALED
- * Re-sync creates a new draft WITHOUT destroying the sealed version.
- * Only sealed analysis feeds task context.
- */
-
-import { createHash } from 'node:crypto'
-import type { AnalysisSchema } from '../schemas/analysis'
-import {
-  AnalysisItemSchema,
-  type SemanticVerificationReport,
-  semanticVerify,
-} from '../schemas/analysis'
-import { getTimestamp } from '../utils/date-helper'
-import { StorageManager } from './storage-manager'
-
-// =============================================================================
-// Types
-// =============================================================================
-
-interface AnalysisStoreData {
-  draft: AnalysisSchema | null
-  sealed: AnalysisSchema | null
-  lastUpdated: string
-}
-
-interface SealResult {
-  success: boolean
-  signature?: string
-  error?: string
-}
-
-interface StalenessCheck {
-  isStale: boolean
-  sealedCommit: string | null
-  currentCommit: string | null
-  message: string
-}
-
-// =============================================================================
-// Analysis Storage
-// =============================================================================
-
-class AnalysisStorage extends StorageManager<AnalysisStoreData> {
-  constructor() {
-    super('analysis.json')
-  }
-
-  protected getDefault(): AnalysisStoreData {
-    return {
-      draft: null,
-      sealed: null,
-      lastUpdated: '',
-    }
-  }
-
-  protected getMdFilename(): string {
-    return 'analysis.md'
-  }
-
-  protected getLayer(): string {
-    return 'analysis'
-  }
-
-  protected getEventType(action: 'update' | 'create' | 'delete'): string {
-    return `analysis.${action}d`
-  }
-
-  protected toMarkdown(data: AnalysisStoreData): string {
-    const lines = ['# Analysis Status', '']
-
-    // Show sealed analysis if available
-    if (data.sealed) {
-      lines.push('## Sealed Analysis')
-      lines.push(`- **Status**: sealed`)
-      lines.push(`- **Commit**: \`${data.sealed.commitHash || 'unknown'}\``)
-      lines.push(`- **Sealed at**: ${data.sealed.sealedAt || 'unknown'}`)
-      lines.push(`- **Languages**: ${data.sealed.languages.join(', ') || 'none'}`)
-      lines.push(`- **Frameworks**: ${data.sealed.frameworks.join(', ') || 'none'}`)
-      lines.push(`- **Files**: ${data.sealed.fileCount}`)
-      if (data.sealed.patterns.length > 0) {
-        lines.push(`- **Patterns**: ${data.sealed.patterns.map((p) => p.name).join(', ')}`)
-      }
-      lines.push('')
-    }
-
-    // Show draft if different from sealed
-    if (data.draft && data.draft.status === 'draft') {
-      lines.push('## Draft Analysis')
-      lines.push(`- **Status**: draft (not yet sealed)`)
-      lines.push(`- **Commit**: \`${data.draft.commitHash || 'unknown'}\``)
-      lines.push(`- **Analyzed at**: ${data.draft.analyzedAt}`)
-      lines.push(`- **Languages**: ${data.draft.languages.join(', ') || 'none'}`)
-      lines.push(`- **Frameworks**: ${data.draft.frameworks.join(', ') || 'none'}`)
-      lines.push(`- **Files**: ${data.draft.fileCount}`)
-      lines.push('')
-    }
-
-    if (!data.sealed && !data.draft) {
-      lines.push('_No analysis available. Run `p. sync` to generate._')
-      lines.push('')
-    }
-
-    return lines.join('\n')
-  }
-
-  // ===========================================================================
-  // Domain Methods
-  // ===========================================================================
-
-  /**
-   * Save a new draft analysis (called by sync-service).
-   * Preserves existing sealed analysis.
-   */
-  async saveDraft(projectId: string, analysis: AnalysisSchema): Promise<void> {
-    const draft: AnalysisSchema = {
-      ...analysis,
-      status: 'draft',
-    }
-
-    // Validate with Zod
-    AnalysisItemSchema.parse(draft)
-
-    await this.update(projectId, (data) => ({
-      ...data,
-      draft,
-      lastUpdated: getTimestamp(),
-    }))
-
-    await this.publishEntityEvent(projectId, 'analysis', 'drafted', {
-      commitHash: draft.commitHash,
-      fileCount: draft.fileCount,
-    })
-  }
-
-  /**
-   * Seal the current draft analysis.
-   * Computes SHA-256 signature and locks the analysis.
-   */
-  async seal(projectId: string): Promise<SealResult> {
-    const data = await this.read(projectId)
-
-    if (!data.draft) {
-      return { success: false, error: 'No draft analysis to seal. Run `p. sync` first.' }
-    }
-
-    if (data.draft.status === 'sealed') {
-      return { success: false, error: 'Draft is already sealed.' }
-    }
-
-    // Compute signature
-    const signature = this.computeSignature(data.draft)
-    const now = getTimestamp()
-
-    const sealed: AnalysisSchema = {
-      ...data.draft,
-      status: 'sealed',
-      signature,
-      sealedAt: now,
-    }
-
-    // Validate
-    AnalysisItemSchema.parse(sealed)
-
-    await this.write(projectId, {
-      draft: null, // Clear draft — it's now sealed
-      sealed,
-      lastUpdated: now,
-    })
-
-    await this.publishEntityEvent(projectId, 'analysis', 'sealed', {
-      commitHash: sealed.commitHash,
-      signature,
-    })
-
-    return { success: true, signature }
-  }
-
-  /**
-   * Get the sealed analysis (for task context injection).
-   * Returns null if no sealed analysis exists.
-   */
-  async getSealed(projectId: string): Promise<AnalysisSchema | null> {
-    const data = await this.read(projectId)
-    return data.sealed
-  }
-
-  /**
-   * Get the current draft analysis.
-   */
-  async getDraft(projectId: string): Promise<AnalysisSchema | null> {
-    const data = await this.read(projectId)
-    return data.draft
-  }
-
-  /**
-   * Get the active analysis (sealed if available, otherwise draft).
-   * This is what tasks should consume.
-   */
-  async getActive(projectId: string): Promise<AnalysisSchema | null> {
-    const data = await this.read(projectId)
-    return data.sealed ?? data.draft
-  }
-
-  /**
-   * Get the current analysis status.
-   */
-  async getStatus(projectId: string): Promise<{
-    hasSealed: boolean
-    hasDraft: boolean
-    sealedCommit: string | null
-    draftCommit: string | null
-    sealedAt: string | null
-  }> {
-    const data = await this.read(projectId)
-    return {
-      hasSealed: data.sealed !== null,
-      hasDraft: data.draft !== null,
-      sealedCommit: data.sealed?.commitHash ?? null,
-      draftCommit: data.draft?.commitHash ?? null,
-      sealedAt: data.sealed?.sealedAt ?? null,
-    }
-  }
-
-  /**
-   * Check if sealed analysis is stale (commit hash differs from current HEAD).
-   */
-  checkStaleness(sealedCommit: string | null, currentCommit: string | null): StalenessCheck {
-    if (!sealedCommit) {
-      return {
-        isStale: false,
-        sealedCommit: null,
-        currentCommit,
-        message: 'No sealed analysis. Run `p. sync` then `p. seal`.',
-      }
-    }
-
-    if (!currentCommit) {
-      return {
-        isStale: true,
-        sealedCommit,
-        currentCommit: null,
-        message: 'Cannot determine current commit. Analysis may be stale.',
-      }
-    }
-
-    if (sealedCommit !== currentCommit) {
-      return {
-        isStale: true,
-        sealedCommit,
-        currentCommit,
-        message: `Analysis is stale: sealed at ${sealedCommit}, HEAD is ${currentCommit}. Run \`p. sync\` + \`p. seal\` to update.`,
-      }
-    }
-
-    return {
-      isStale: false,
-      sealedCommit,
-      currentCommit,
-      message: 'Analysis is current.',
-    }
-  }
-
-  /**
-   * Verify the integrity of a sealed analysis by recomputing its signature.
-   */
-  async verify(projectId: string): Promise<{ valid: boolean; message: string }> {
-    const data = await this.read(projectId)
-
-    if (!data.sealed) {
-      return { valid: false, message: 'No sealed analysis to verify.' }
-    }
-
-    if (!data.sealed.signature) {
-      return { valid: false, message: 'Sealed analysis has no signature.' }
-    }
-
-    const expected = this.computeSignature({
-      ...data.sealed,
-      // Strip signature and sealedAt before recomputing — they weren't part of the original hash
-      signature: undefined,
-      sealedAt: undefined,
-    })
-
-    if (expected === data.sealed.signature) {
-      return { valid: true, message: 'Signature verified. Analysis integrity confirmed.' }
-    }
-
-    return {
-      valid: false,
-      message: `Signature mismatch. Expected ${expected}, got ${data.sealed.signature}. Analysis may have been modified.`,
-    }
-  }
-
-  /**
-   * Perform semantic verification on analysis results (PRJ-270).
-   * Validates that analysis data matches actual project state:
-   * - Frameworks exist in package.json
-   * - Languages match file extensions
-   * - Pattern locations reference real files
-   * - File count is accurate
-   * - Anti-pattern files exist
-   */
-  async semanticVerify(
-    projectId: string,
-    projectPath: string
-  ): Promise<SemanticVerificationReport> {
-    const data = await this.read(projectId)
-
-    // Get the active analysis (sealed if available, otherwise draft)
-    const analysis = data.sealed ?? data.draft
-
-    if (!analysis) {
-      // No analysis to verify - return empty report
-      return {
-        passed: false,
-        checks: [
-          {
-            name: 'Analysis availability',
-            passed: false,
-            error: 'No analysis available. Run `p. sync` to generate.',
-            durationMs: 0,
-          },
-        ],
-        totalMs: 0,
-        failedCount: 1,
-        passedCount: 0,
-      }
-    }
-
-    // Run semantic verification
-    return await semanticVerify(analysis, projectPath)
-  }
-
-  // ===========================================================================
-  // Private Helpers
-  // ===========================================================================
-
-  /**
-   * Compute SHA-256 signature for analysis data.
-   * Deterministic: same input always produces same hash.
-   */
-  private computeSignature(analysis: AnalysisSchema): string {
-    // Build a canonical representation (exclude volatile fields)
-    const canonical = {
-      projectId: analysis.projectId,
-      languages: analysis.languages,
-      frameworks: analysis.frameworks,
-      packageManager: analysis.packageManager,
-      sourceDir: analysis.sourceDir,
-      testDir: analysis.testDir,
-      configFiles: analysis.configFiles,
-      fileCount: analysis.fileCount,
-      patterns: analysis.patterns,
-      antiPatterns: analysis.antiPatterns,
-      analyzedAt: analysis.analyzedAt,
-      commitHash: analysis.commitHash,
-    }
-
-    return createHash('sha256').update(JSON.stringify(canonical)).digest('hex')
-  }
-}
-
-export const analysisStorage = new AnalysisStorage()
-export default analysisStorage
-export type { AnalysisStoreData, SealResult, StalenessCheck }
-export type { SemanticVerificationReport } from '../schemas/analysis'

package/core/storage/archive-storage.ts

@@ -1,205 +0,0 @@
-/**
- * Archive Storage (PRJ-267)
- *
- * Manages archival of stale data from active storage.
- * Works directly with the `archives` SQLite table (not kv_store).
- *
- * Archived data is accessible via explicit queries but never
- * loaded into LLM context files.
- */
-
-import { generateUUID } from '../schemas'
-import { getTimestamp } from '../utils/date-helper'
-import { prjctDb } from './database'
-
-// =============================================================================
-// Archival Policy Constants
-// =============================================================================
-
-export const ARCHIVE_POLICIES = {
-  SHIPPED_RETENTION_DAYS: 90,
-  IDEA_DORMANT_DAYS: 180,
-  QUEUE_COMPLETED_DAYS: 7,
-  PAUSED_TASK_DAYS: 30,
-  MEMORY_MAX_ENTRIES: 500,
-} as const
-
-// =============================================================================
-// Types
-// =============================================================================
-
-export type ArchiveEntityType = 'shipped' | 'idea' | 'queue_task' | 'paused_task' | 'memory_entry'
-
-export interface ArchiveRecord {
-  id: string
-  entity_type: ArchiveEntityType
-  entity_id: string
-  entity_data: string
-  summary: string | null
-  archived_at: string
-  reason: string
-}
-
-export interface ArchiveItem {
-  entityType: ArchiveEntityType
-  entityId: string
-  entityData: unknown
-  summary?: string
-  reason: string
-}
-
-export interface ArchiveStats {
-  shipped: number
-  idea: number
-  queue_task: number
-  paused_task: number
-  memory_entry: number
-  total: number
-}
-
-// =============================================================================
-// Archive Storage
-// =============================================================================
-
-class ArchiveStorage {
-  /**
-   * Archive a single item
-   */
-  archive(projectId: string, item: ArchiveItem): string {
-    const id = generateUUID()
-    const now = getTimestamp()
-
-    prjctDb.run(
-      projectId,
-      'INSERT INTO archives (id, entity_type, entity_id, entity_data, summary, archived_at, reason) VALUES (?, ?, ?, ?, ?, ?, ?)',
-      id,
-      item.entityType,
-      item.entityId,
-      JSON.stringify(item.entityData),
-      item.summary ?? null,
-      now,
-      item.reason
-    )
-
-    return id
-  }
-
-  /**
-   * Archive multiple items in a transaction
-   */
-  archiveMany(projectId: string, items: ArchiveItem[]): number {
-    if (items.length === 0) return 0
-
-    const now = getTimestamp()
-
-    prjctDb.transaction(projectId, (db) => {
-      const stmt = db.prepare(
-        'INSERT INTO archives (id, entity_type, entity_id, entity_data, summary, archived_at, reason) VALUES (?, ?, ?, ?, ?, ?, ?)'
-      )
-
-      for (const item of items) {
-        stmt.run(
-          generateUUID(),
-          item.entityType,
-          item.entityId,
-          JSON.stringify(item.entityData),
-          item.summary ?? null,
-          now,
-          item.reason
-        )
-      }
-    })
-
-    return items.length
-  }
-
-  /**
-   * Query archived items by type
-   */
-  getArchived(projectId: string, entityType?: ArchiveEntityType, limit = 50): ArchiveRecord[] {
-    if (entityType) {
-      return prjctDb.query<ArchiveRecord>(
-        projectId,
-        'SELECT * FROM archives WHERE entity_type = ? ORDER BY archived_at DESC LIMIT ?',
-        entityType,
-        limit
-      )
-    }
-    return prjctDb.query<ArchiveRecord>(
-      projectId,
-      'SELECT * FROM archives ORDER BY archived_at DESC LIMIT ?',
-      limit
-    )
-  }
-
-  /**
-   * Get count of archived items by type
-   */
-  getStats(projectId: string): ArchiveStats {
-    const rows = prjctDb.query<{ entity_type: string; count: number }>(
-      projectId,
-      'SELECT entity_type, COUNT(*) as count FROM archives GROUP BY entity_type'
-    )
-
-    const stats: ArchiveStats = {
-      shipped: 0,
-      idea: 0,
-      queue_task: 0,
-      paused_task: 0,
-      memory_entry: 0,
-      total: 0,
-    }
-
-    for (const row of rows) {
-      const type = row.entity_type as ArchiveEntityType
-      if (type in stats) {
-        stats[type] = row.count
-      }
-      stats.total += row.count
-    }
-
-    return stats
-  }
-
-  /**
-   * Restore an item from archive (removes from archive table)
-   * Returns the entity data for the caller to re-insert into active storage.
-   */
-  restore(projectId: string, archiveId: string): unknown | null {
-    const record = prjctDb.get<ArchiveRecord>(
-      projectId,
-      'SELECT * FROM archives WHERE id = ?',
-      archiveId
-    )
-
-    if (!record) return null
-
-    prjctDb.run(projectId, 'DELETE FROM archives WHERE id = ?', archiveId)
-
-    return JSON.parse(record.entity_data)
-  }
-
-  /**
-   * Permanently delete archives older than N days
-   */
-  pruneOldArchives(projectId: string, olderThanDays: number): number {
-    const threshold = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000).toISOString()
-
-    const before = this.getTotalCount(projectId)
-    prjctDb.run(projectId, 'DELETE FROM archives WHERE archived_at < ?', threshold)
-    const after = this.getTotalCount(projectId)
-
-    return before - after
-  }
-
-  /**
-   * Get total count of archived items
-   */
-  private getTotalCount(projectId: string): number {
-    const row = prjctDb.get<{ count: number }>(projectId, 'SELECT COUNT(*) as count FROM archives')
-    return row?.count ?? 0
-  }
-}
-
-export const archiveStorage = new ArchiveStorage()
-export default archiveStorage