prjct-cli 0.13.2 → 0.15.0

package/core/data/md-state-manager.ts

@@ -7,6 +7,7 @@
 
 import { MdBaseManager } from './md-base-manager'
 import { parseState, serializeState } from '../serializers'
+import { generateUUID } from '../schemas'
 import type { StateJson, CurrentTask, PreviousTask } from '../schemas/state'
 
 class MdStateManager extends MdBaseManager<StateJson> {
@@ -71,7 +72,7 @@ class MdStateManager extends MdBaseManager<StateJson> {
     }))
   }
 
-  async pauseTask(projectId: string): Promise<StateJson> {
+  async pauseTask(projectId: string, reason?: string): Promise<StateJson> {
     const state = await this.read(projectId)
     if (!state.currentTask) {
       throw new Error('No active task to pause')
@@ -82,7 +83,8 @@ class MdStateManager extends MdBaseManager<StateJson> {
       description: state.currentTask.description,
       status: 'paused',
       startedAt: state.currentTask.startedAt,
-      pausedAt: new Date().toISOString()
+      pausedAt: new Date().toISOString(),
+      pauseReason: reason
     }
 
     return this.update(projectId, () => ({
@@ -92,24 +94,26 @@ class MdStateManager extends MdBaseManager<StateJson> {
     }))
   }
 
-  async resumeTask(projectId: string): Promise<StateJson> {
+  async resumeTask(projectId: string, _taskId?: string): Promise<CurrentTask | null> {
     const state = await this.read(projectId)
     if (!state.previousTask) {
-      throw new Error('No paused task to resume')
+      return null
     }
 
     const currentTask: CurrentTask = {
       id: state.previousTask.id,
       description: state.previousTask.description,
-      startedAt: new Date().toISOString(), // Reset start time
-      sessionId: `sess_${Date.now()}`
+      startedAt: new Date().toISOString(),
+      sessionId: generateUUID()
     }
 
-    return this.update(projectId, () => ({
+    await this.update(projectId, () => ({
       currentTask,
       previousTask: null,
       lastUpdated: new Date().toISOString()
     }))
+
+    return currentTask
   }
 
   async clearTask(projectId: string): Promise<StateJson> {

package/core/domain/agent-generator.ts

@@ -18,21 +18,8 @@ interface AgentConfig {
   contextFilter?: string
 }
 
-interface TechSummary {
-  languages: string[]
-  frameworks: string[]
-  buildTools: string[]
-  testFrameworks: string[]
-  databases: string[]
-  tools: string[]
-  allDependencies: string[]
-}
-
-interface GenerateContext {
-  detectedTech: TechSummary
-  analysisSummary?: string
-  projectPath?: string
-}
+// TechSummary and GenerateContext interfaces REMOVED.
+// Agent generation is AGENTIC - Claude reads raw data and decides.
 
 interface Agent {
   name: string
@@ -51,8 +38,9 @@ class AgentGenerator {
 
   constructor(projectId: string | null = null) {
     this.projectId = projectId
+    // NEW: Write to data/agents/ for JSON storage (OpenCode-style)
     this.outputDir = projectId
-      ? path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'agents')
+      ? path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'data', 'agents')
       : path.join(os.homedir(), '.prjct-cli', 'agents')
     this.loader = new AgentLoader(projectId)
   }
@@ -60,61 +48,33 @@ class AgentGenerator {
   /**
    * Generate specialized agent with deep expertise
    * Universal - works with ANY technology stack
+   * Writes JSON to data/agents/{name}.json
    */
   async generateDynamicAgent(agentName: string, config: AgentConfig): Promise<{ name: string }> {
     log.debug(`Generating ${agentName} agent...`)
     await fs.mkdir(this.outputDir, { recursive: true })
 
-    // Generate concise, actionable agent prompt
-    const content = this.buildAgentPrompt(agentName, config)
+    // Write as JSON (OpenCode-style storage)
+    const agent = {
+      name: agentName,
+      role: config.role || agentName,
+      domain: config.domain || 'general',
+      expertise: config.expertise || '',
+      contextFilter: config.contextFilter || 'Only relevant files',
+      createdAt: new Date().toISOString()
+    }
 
-    const outputPath = path.join(this.outputDir, `${agentName}.md`)
-    await fs.writeFile(outputPath, content, 'utf-8')
+    const outputPath = path.join(this.outputDir, `${agentName}.json`)
+    await fs.writeFile(outputPath, JSON.stringify(agent, null, 2), 'utf-8')
     log.debug(`${agentName} agent created`)
 
     return { name: agentName }
   }
 
-  /**
-   * Generate agents from tech analysis - 100% AGENTIC
-   * Claude decides what agents are needed based on actual project tech
-   * NO HARDCODED LISTS - reads analysis and decides
-   */
-  async generateAgentsFromTech(context: GenerateContext): Promise<Array<{ name: string }>> {
-    const { detectedTech } = context
-    const agents: string[] = []
-
-    // Read agent generation template - Claude will use this to decide
-    const templatePath = path.join(__dirname, '../../templates/agents/AGENTS.md')
-    try {
-      await fs.readFile(templatePath, 'utf-8')
-    } catch {
-      // Fallback if template doesn't exist
-    }
-
-    // Build context for Claude to decide
-    const techSummary: TechSummary = {
-      languages: detectedTech.languages || [],
-      frameworks: detectedTech.frameworks || [],
-      buildTools: detectedTech.buildTools || [],
-      testFrameworks: detectedTech.testFrameworks || [],
-      databases: detectedTech.databases || [],
-      tools: detectedTech.tools || [],
-      allDependencies: detectedTech.allDependencies || [],
-    }
-
-    // Generate agents for detected domains
-    if (techSummary.languages.length > 0 || techSummary.frameworks.length > 0) {
-      await this.generateDynamicAgent('developer', {
-        role: 'Development Specialist',
-        domain: 'general',
-        projectContext: techSummary,
-      })
-      agents.push('developer')
-    }
-
-    return agents.map((name) => ({ name }))
-  }
+  // NOTE: generateAgentsFromTech() was REMOVED intentionally.
+  // Agent generation is AGENTIC - Claude reads analysis/repo-summary.md
+  // and DECIDES what specialists to create by calling generateDynamicAgent().
+  // DO NOT add any automatic agent generation logic here.
 
   /**
    * Build comprehensive agent prompt
@@ -175,10 +135,10 @@ ${config.contextFilter || 'Only relevant files'}
 
     try {
       const files = await fs.readdir(this.outputDir)
-      const agentFiles = files.filter((f) => f.endsWith('.md') && !f.startsWith('.'))
+      const agentFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'))
 
       for (const file of agentFiles) {
-        const type = file.replace('.md', '')
+        const type = file.replace('.json', '')
 
         if (!requiredAgents.includes(type)) {
           const filePath = path.join(this.outputDir, file)
@@ -200,7 +160,7 @@ ${config.contextFilter || 'Only relevant files'}
   async listAgents(): Promise<string[]> {
     try {
       const files = await fs.readdir(this.outputDir)
-      return files.filter((f) => f.endsWith('.md') && !f.startsWith('.')).map((f) => f.replace('.md', ''))
+      return files.filter((f) => f.endsWith('.json') && !f.startsWith('.')).map((f) => f.replace('.json', ''))
     } catch {
       return []
     }

package/core/events/index.ts

@@ -0,0 +1,143 @@
+/**
+ * Event Bus for Sync
+ *
+ * Events are published on every Storage write/delete.
+ * Events accumulate in sync/pending.json until /p:ship or /p:sync.
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+
+export interface SyncEvent {
+  type: string
+  path: string[]
+  data: unknown
+  timestamp: string
+  projectId: string
+}
+
+export type EventType =
+  | 'task.created'
+  | 'task.updated'
+  | 'task.completed'
+  | 'task.deleted'
+  | 'feature.created'
+  | 'feature.updated'
+  | 'feature.shipped'
+  | 'feature.deleted'
+  | 'idea.created'
+  | 'idea.updated'
+  | 'idea.deleted'
+  | 'session.started'
+  | 'session.completed'
+  | 'shipped.created'
+  | 'agent.created'
+  | 'agent.updated'
+  | 'agent.deleted'
+  | 'project.updated'
+
+/**
+ * Infer event type from path and action
+ */
+export function inferEventType(pathArray: string[], action: 'write' | 'delete'): EventType {
+  const entity = pathArray[0]
+
+  if (action === 'delete') {
+    return `${entity}.deleted` as EventType
+  }
+
+  // For writes, we'd need to check if it's new or update
+  // For simplicity, use 'updated' (can be refined later)
+  return `${entity}.updated` as EventType
+}
+
+class EventBus {
+  private pendingPath(projectId: string): string {
+    return path.join(os.homedir(), '.prjct-cli/projects', projectId, 'sync/pending.json')
+  }
+
+  /**
+   * Publish event to pending queue
+   */
+  async publish(event: SyncEvent): Promise<void> {
+    const filePath = this.pendingPath(event.projectId)
+
+    // Read existing pending events
+    let pending: SyncEvent[] = []
+    try {
+      const content = await fs.readFile(filePath, 'utf-8')
+      pending = JSON.parse(content)
+    } catch {
+      // File doesn't exist yet
+    }
+
+    // Add new event
+    pending.push(event)
+
+    // Ensure directory exists
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+
+    // Write back
+    await fs.writeFile(filePath, JSON.stringify(pending, null, 2), 'utf-8')
+  }
+
+  /**
+   * Get all pending events for a project
+   */
+  async getPending(projectId: string): Promise<SyncEvent[]> {
+    const filePath = this.pendingPath(projectId)
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8')
+      return JSON.parse(content)
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Clear pending events after successful sync
+   */
+  async clearPending(projectId: string): Promise<void> {
+    const filePath = this.pendingPath(projectId)
+
+    try {
+      await fs.writeFile(filePath, '[]', 'utf-8')
+    } catch {
+      // Ignore
+    }
+  }
+
+  /**
+   * Update last sync timestamp
+   */
+  async updateLastSync(projectId: string): Promise<void> {
+    const filePath = path.join(os.homedir(), '.prjct-cli/projects', projectId, 'sync/last-sync.json')
+
+    const data = {
+      timestamp: new Date().toISOString(),
+      success: true
+    }
+
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
+  }
+
+  /**
+   * Get last sync info
+   */
+  async getLastSync(projectId: string): Promise<{ timestamp: string; success: boolean } | null> {
+    const filePath = path.join(os.homedir(), '.prjct-cli/projects', projectId, 'sync/last-sync.json')
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8')
+      return JSON.parse(content)
+    } catch {
+      return null
+    }
+  }
+}
+
+export const eventBus = new EventBus()
+export default eventBus

package/core/index.ts

@@ -39,7 +39,7 @@ async function main(): Promise<void> {
     process.exit(0)
   }
 
-  if (['-h', '--help', 'help', undefined].includes(commandName)) {
+  if (['-h', '--help', undefined].includes(commandName)) {
     displayHelp()
     process.exit(0)
   }
@@ -100,29 +100,32 @@ async function main(): Promise<void> {
       result = await commands.setup(options)
     } else if (commandName === 'migrate-all') {
       result = await commands.migrateAll(options)
-    } else if (commandName === 'progress') {
-      const period = parsedArgs[0] || 'week'
-      result = await commands.progress(period)
-    } else if (commandName === 'build') {
-      const taskOrNumber = parsedArgs.join(' ')
-      result = await commands.build(taskOrNumber)
     } else {
       // Standard commands - type-safe invocation
       const param = parsedArgs.join(' ') || null
       const standardCommands: Record<string, (p: string | null) => Promise<CommandResult>> = {
-        now: (p) => commands.now(p),
+        // Core workflow
+        work: (p) => commands.work(p),
         done: () => commands.done(),
         next: () => commands.next(),
+        pause: (p) => commands.pause(p || ''),
+        resume: (p) => commands.resume(p),
+        // Planning
         init: (p) => commands.init(p),
         feature: (p) => commands.feature(p || ''),
         bug: (p) => commands.bug(p || ''),
-        architect: (p) => commands.architect(p || 'execute'),
+        idea: (p) => commands.idea(p || ''),
+        spec: (p) => commands.spec(p),
         ship: (p) => commands.ship(p),
-        context: () => commands.context(),
-        recap: () => commands.recap(),
-        stuck: (p) => commands.stuck(p || ''),
-        roadmap: () => commands.roadmap(),
-        status: () => commands.status(),
+        // Analytics
+        dash: (p) => commands.dash(p || 'default'),
+        help: (p) => commands.help(p || ''),
+        // Maintenance
+        recover: () => commands.recover(),
+        undo: () => commands.undo(),
+        redo: () => commands.redo(),
+        history: () => commands.history(),
+        // Setup
         sync: () => commands.sync(),
         start: () => commands.start(),
       }

package/core/infrastructure/capability-installer.ts

@@ -1,13 +1,15 @@
 /**
  * Capability Installer
- * Handles installation of missing tools and tracks them as workflow tasks
+ *
+ * AGENTIC: This module provides TOOLS, not DECISIONS.
+ * Claude reads project context and decides what to install/configure.
+ *
+ * NO hardcoded configurations for specific frameworks.
+ * Configuration should be template-driven, not code-driven.
  */
 
 import { exec } from 'child_process'
 import { promisify } from 'util'
-import fs from 'fs/promises'
-import path from 'path'
-import projectCapabilities from '../utils/project-capabilities'
 
 const execAsync = promisify(exec)
 
@@ -25,20 +27,12 @@ interface InstallResult {
   error?: string
 }
 
-interface ConfigureResult {
-  configured: boolean
-  framework?: string
-  tool?: string
-}
-
-interface PackageJson {
-  devDependencies?: Record<string, string>
-  scripts?: Record<string, string>
-}
-
 class CapabilityInstaller {
   /**
-   * Install capability and create tracking task
+   * Install capability using provided command
+   *
+   * AGENTIC: Claude provides the install command based on analysis.
+   * This is just the executor - no hardcoded logic.
    */
   async install(
     capability: string,
@@ -49,7 +43,6 @@ class CapabilityInstaller {
     const startTime = Date.now()
 
     try {
-      // Execute installation command
       const { stdout, stderr } = await execAsync(command)
 
       const duration = Date.now() - startTime
@@ -73,138 +66,9 @@ class CapabilityInstaller {
     }
   }
 
-  /**
-   * Create configuration for installed tool
-   */
-  async configure(capability: string, projectPath: string): Promise<ConfigureResult> {
-    const configs: Record<string, () => Promise<ConfigureResult>> = {
-      test: () => this.configureTest(projectPath),
-      design: () => this.configureDesign(projectPath),
-      docs: () => this.configureDocs(projectPath),
-    }
-
-    if (configs[capability]) {
-      return await configs[capability]()
-    }
-
-    return { configured: false }
-  }
-
-  /**
-   * Configure test framework
-   */
-  async configureTest(projectPath: string): Promise<ConfigureResult> {
-    // Check if package.json exists
-    const pkgPath = path.join(projectPath, 'package.json')
-    const pkg: PackageJson = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
-
-    const hasVitest = pkg.devDependencies?.vitest
-    const hasJest = pkg.devDependencies?.jest
-
-    if (hasVitest) {
-      // Create vitest.config.js
-      const config = `import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'jsdom',
-    setupFiles: './test/setup.js'
-  }
-})
-`
-      await fs.writeFile(path.join(projectPath, 'vitest.config.js'), config)
-
-      // Add test script
-      pkg.scripts = pkg.scripts || {}
-      pkg.scripts.test = 'vitest'
-      pkg.scripts['test:ui'] = 'vitest --ui'
-      await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2))
-
-      return { configured: true, framework: 'vitest' }
-    }
-
-    if (hasJest) {
-      // Create jest.config.js
-      const config = `module.exports = {
-  testEnvironment: 'jsdom',
-  setupFilesAfterEnv: ['<rootDir>/test/setup.js'],
-  moduleNameMapper: {
-    '\\\\.(css|less|scss|sass)$': 'identity-obj-proxy'
-  }
-}
-`
-      await fs.writeFile(path.join(projectPath, 'jest.config.js'), config)
-
-      // Add test script
-      pkg.scripts = pkg.scripts || {}
-      pkg.scripts.test = 'jest'
-      pkg.scripts['test:watch'] = 'jest --watch'
-      await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2))
-
-      return { configured: true, framework: 'jest' }
-    }
-
-    return { configured: false }
-  }
-
-  /**
-   * Configure design system
-   */
-  async configureDesign(projectPath: string): Promise<ConfigureResult> {
-    const pkgPath = path.join(projectPath, 'package.json')
-    const pkg: PackageJson = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
-
-    if (pkg.devDependencies?.storybook) {
-      // Storybook auto-configures itself during init
-      return { configured: true, tool: 'storybook' }
-    }
-
-    return { configured: false }
-  }
-
-  /**
-   * Configure documentation
-   */
-  async configureDocs(projectPath: string): Promise<ConfigureResult> {
-    const pkgPath = path.join(projectPath, 'package.json')
-    const pkg: PackageJson = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
-
-    if (pkg.devDependencies?.jsdoc) {
-      // Create jsdoc.json
-      const config = {
-        source: {
-          include: ['src'],
-          includePattern: '.+\\.js(doc|x)?$',
-          excludePattern: '(node_modules|docs)',
-        },
-        opts: {
-          destination: './docs',
-          recurse: true,
-        },
-      }
-
-      await fs.writeFile(path.join(projectPath, 'jsdoc.json'), JSON.stringify(config, null, 2))
-
-      // Add docs script
-      pkg.scripts = pkg.scripts || {}
-      pkg.scripts.docs = 'jsdoc -c jsdoc.json'
-      await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2))
-
-      return { configured: true, tool: 'jsdoc' }
-    }
-
-    return { configured: false }
-  }
-
-  /**
-   * Verify installation succeeded
-   */
-  async verify(capability: string, projectPath: string): Promise<boolean> {
-    const detected = await projectCapabilities.detect(projectPath)
-
-    return detected[capability as keyof typeof detected] === true
-  }
+  // NOTE: configure() and hardcoded framework configs REMOVED.
+  // Configuration is AGENTIC - Claude reads templates and generates configs.
+  // See templates/workflows/ for configuration guidance.
 }
 
 const capabilityInstaller = new CapabilityInstaller()

package/core/infrastructure/migrator/project-scanner.ts

@@ -4,6 +4,7 @@
  */
 
 import fs from 'fs/promises'
+import { accessSync } from 'fs'
 import path from 'path'
 import os from 'os'
 import type { FindProjectsOptions } from './types'
@@ -34,7 +35,7 @@ export async function findAllProjects(options: FindProjectsOptions = {}): Promis
       .map((dir) => path.join(os.homedir(), dir))
       .filter((dirPath) => {
         try {
-          require('fs').accessSync(dirPath)
+          accessSync(dirPath)
           return true
         } catch {
           return false

package/core/infrastructure/path-manager.ts

@@ -36,13 +36,11 @@ class PathManager {
   }
 
   /**
-   * Generate a unique project ID from the absolute project path
-   * Uses SHA-256 hash of the absolute path for consistency
+   * Generate a unique project ID using UUID.
+   * Standard UUID format for PostgreSQL consistency.
    */
-  generateProjectId(projectPath: string): string {
-    const absolutePath = path.resolve(projectPath)
-    const hash = crypto.createHash('sha256').update(absolutePath).digest('hex')
-    return hash.substring(0, 12) // Use first 12 chars for readability
+  generateProjectId(_projectPath: string): string {
+    return crypto.randomUUID()
   }
 
   /**

package/core/infrastructure/setup.ts

@@ -145,6 +145,9 @@ export async function run(): Promise<SetupResults> {
   return results
 }
 
+// Default export for CommonJS require
+export default { run }
+
 /**
  * Show setup results
  */