prjct-cli 0.15.1 → 0.17.0

package/core/infrastructure/setup.ts

@@ -2,24 +2,18 @@
  * Setup Module - Core installation logic
  *
  * Executes ALL setup needed for prjct-cli:
- * 1. Detect and clean legacy installation (curl-based)
- * 2. Install Claude Code CLI if missing
- * 3. Sync commands to ~/.claude/commands/p/
- * 4. Install global config ~/.claude/CLAUDE.md
- * 5. Migrate legacy projects automatically
- * 6. Save version in editors-config
+ * 1. Install Claude Code CLI if missing
+ * 2. Sync commands to ~/.claude/commands/p/
+ * 3. Install global config ~/.claude/CLAUDE.md
+ * 4. Save version in editors-config
  *
  * This module is called from:
  * - core/index.js (on first CLI use)
  * - scripts/postinstall.js (if npm scripts are enabled)
- *
- * @version 0.8.8
  */
 
 import { execSync } from 'child_process'
 import installer from './command-installer'
-import migrator from './migrator'
-import legacyDetector from './legacy-installer-detector'
 import editorsConfig from './editors-config'
 import { VERSION } from '../utils/version'
 
@@ -30,13 +24,10 @@ const DIM = '\x1b[2m'
 const NC = '\x1b[0m'
 
 interface SetupResults {
-  legacyCleaned: boolean
-  legacyProjectsMigrated: number
   claudeInstalled: boolean
   commandsAdded: number
   commandsUpdated: number
   configAction: string | null
-  projectsMigrated: number
 }
 
 /**
@@ -76,21 +67,10 @@ async function installClaudeCode(): Promise<boolean> {
  */
 export async function run(): Promise<SetupResults> {
   const results: SetupResults = {
-    legacyCleaned: false,
-    legacyProjectsMigrated: 0,
     claudeInstalled: false,
     commandsAdded: 0,
     commandsUpdated: 0,
     configAction: null,
-    projectsMigrated: 0,
-  }
-
-  // Step 0: Detect and clean legacy curl installation
-  const needsLegacyCleanup = await legacyDetector.needsCleanup()
-  if (needsLegacyCleanup) {
-    const cleanupResult = await legacyDetector.performCleanup({ verbose: true })
-    results.legacyCleaned = cleanupResult.success
-    results.legacyProjectsMigrated = cleanupResult.steps.projectsMigrated
   }
 
   // Step 1: Ensure Claude Code CLI is installed
@@ -123,20 +103,9 @@ export async function run(): Promise<SetupResults> {
     if (configResult.success) {
       results.configAction = configResult.action
     }
-
-    // Step 5: Migrate legacy projects automatically
-    const migrationResult = await migrator.migrateAll({
-      deepScan: false,
-      cleanupLegacy: true,
-      dryRun: false,
-    })
-
-    if (migrationResult.successfullyMigrated > 0) {
-      results.projectsMigrated = migrationResult.successfullyMigrated
-    }
   }
 
-  // Step 6: Save version in editors-config
+  // Step 5: Save version in editors-config
   await editorsConfig.saveConfig(VERSION, installer.getInstallPath())
 
   // Show results
@@ -154,16 +123,6 @@ export default { run }
 function showResults(results: SetupResults): void {
   console.log('')
 
-  // Show what was done
-  if (results.legacyCleaned) {
-    console.log(`   ${GREEN}✓${NC} Legacy curl installation cleaned up`)
-    if (results.legacyProjectsMigrated > 0) {
-      console.log(
-        `   ${GREEN}✓${NC} ${results.legacyProjectsMigrated} project(s) migrated from legacy`
-      )
-    }
-  }
-
   if (results.claudeInstalled) {
     console.log(`   ${GREEN}✓${NC} Claude Code CLI installed`)
   } else {
@@ -188,9 +147,5 @@ function showResults(results: SetupResults): void {
     console.log(`   ${GREEN}✓${NC} Global config merged`)
   }
 
-  if (results.projectsMigrated > 0) {
-    console.log(`   ${GREEN}✓${NC} ${results.projectsMigrated} projects migrated to global storage`)
-  }
-
   console.log('')
 }

package/core/storage/storage-manager.ts

@@ -14,15 +14,44 @@ import path from 'path'
 import os from 'os'
 import { eventBus, type SyncEvent } from '../events'
 
+interface CacheEntry<T> {
+  data: T
+  timestamp: number
+}
+
 export abstract class StorageManager<T> {
   protected filename: string
-  protected cache: Map<string, T> = new Map()
+  protected cache: Map<string, CacheEntry<T>> = new Map()
   protected cacheTimeout = 5000 // 5 seconds
+  protected maxCacheSize = 50 // Max projects to cache
 
   constructor(filename: string) {
     this.filename = filename
   }
 
+  /**
+   * Check if cache entry is still valid
+   */
+  private isCacheValid(entry: CacheEntry<T>): boolean {
+    return Date.now() - entry.timestamp < this.cacheTimeout
+  }
+
+  /**
+   * Evict oldest entries if cache exceeds max size
+   */
+  private evictOldEntries(): void {
+    if (this.cache.size <= this.maxCacheSize) return
+
+    // Sort by timestamp and remove oldest
+    const entries = Array.from(this.cache.entries())
+      .sort((a, b) => a[1].timestamp - b[1].timestamp)
+
+    const toRemove = entries.slice(0, this.cache.size - this.maxCacheSize)
+    for (const [key] of toRemove) {
+      this.cache.delete(key)
+    }
+  }
+
   /**
    * Get file path for storage JSON
    */
@@ -73,10 +102,15 @@ export abstract class StorageManager<T> {
    * Read data from storage
    */
   async read(projectId: string): Promise<T> {
-    // Check cache first
+    // Check cache first (with expiration)
     const cached = this.cache.get(projectId)
+    if (cached && this.isCacheValid(cached)) {
+      return cached.data
+    }
+
+    // Remove expired entry
     if (cached) {
-      return cached
+      this.cache.delete(projectId)
     }
 
     const filePath = this.getStoragePath(projectId)
@@ -84,7 +118,8 @@ export abstract class StorageManager<T> {
     try {
       const content = await fs.readFile(filePath, 'utf-8')
       const data = JSON.parse(content) as T
-      this.cache.set(projectId, data)
+      this.cache.set(projectId, { data, timestamp: Date.now() })
+      this.evictOldEntries()
       return data
     } catch {
       // Return default if file doesn't exist
@@ -112,8 +147,9 @@ export abstract class StorageManager<T> {
     const md = this.toMarkdown(data)
     await fs.writeFile(contextPath, md, 'utf-8')
 
-    // 3. Update cache
-    this.cache.set(projectId, data)
+    // 3. Update cache with timestamp
+    this.cache.set(projectId, { data, timestamp: Date.now() })
+    this.evictOldEntries()
 
     // 4. Publish event for backend sync (NOT included in this call - subclass handles)
   }

package/core/utils/logger.ts

@@ -30,21 +30,28 @@ interface Logger {
 
 const LEVELS: Record<LogLevel, number> = { error: 0, warn: 1, info: 2, debug: 3 }
 
-const debugEnv = process.env.PRJCT_DEBUG || process.env.DEBUG || ''
-const isEnabled = debugEnv === '1' || debugEnv === 'true' || debugEnv.includes('prjct')
-
-// Determine log level
-let currentLevel = -1 // disabled by default
-if (isEnabled) {
-  if (debugEnv === '1' || debugEnv === 'true' || debugEnv === 'prjct') {
-    currentLevel = LEVELS.debug // all logs
-  } else if (LEVELS[debugEnv as LogLevel] !== undefined) {
-    currentLevel = LEVELS[debugEnv as LogLevel]
-  } else {
-    currentLevel = LEVELS.debug
+/**
+ * Determine log level from environment variables
+ * Returns -1 (disabled) or a level from LEVELS
+ */
+function getLogLevel(): number {
+  const debugEnv = process.env.PRJCT_DEBUG || process.env.DEBUG || ''
+
+  // Disabled if empty
+  if (!debugEnv) return -1
+
+  // Enable all logs for common truthy values
+  if (debugEnv === '1' || debugEnv === 'true' || debugEnv === 'prjct' || debugEnv.includes('prjct')) {
+    return LEVELS.debug
   }
+
+  // Check for specific level name (error, warn, info, debug)
+  const level = LEVELS[debugEnv as LogLevel]
+  return level !== undefined ? level : -1
 }
 
+const currentLevel = getLogLevel()
+
 // No-op function for disabled logs
 const noop: LogFunction = () => {}
 

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "prjct-cli",
-  "version": "0.15.1",
+  "version": "0.17.0",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.ts",
   "bin": {
     "prjct": "bin/prjct",
     "prjct-dev": "bin/dev.js",
-    "prjct-serve": "bin/serve.js",
-    "prjct-generate-views": "bin/generate-views.js",
-    "prjct-migrate": "bin/migrate-to-json.js"
+    "prjct-serve": "bin/serve.js"
   },
   "workspaces": [
     "packages/*"

package/templates/agentic/subagent-generation.md

@@ -0,0 +1,109 @@
+# Sub-Agent Generation
+
+Generate Claude Code sub-agents for this project based on detected stack.
+
+## Input Context
+
+You have access to:
+- `{analysis}` - repo-summary.md with detected technologies
+- `{projectPath}` - Path to project root
+- `{projectId}` - Project identifier
+
+## Output Location
+
+Write sub-agents to: `{projectPath}/.claude/agents/`
+
+## Sub-Agent Format (Claude Code)
+
+```markdown
+---
+name: agent-name
+description: When to use this agent. Include "Use PROACTIVELY" for auto-invocation.
+tools: Read, Write, Glob, Grep, Bash
+model: sonnet
+---
+
+Agent system prompt here...
+```
+
+## Generation Rules
+
+### 1. ALWAYS Generate Workflow Agents
+
+These are REQUIRED for every prjct project:
+
+#### prjct-workflow.md
+- Commands: /p:now, /p:done, /p:next, /p:pause, /p:resume
+- Tools: Read, Write, Glob
+- Purpose: Task lifecycle management
+
+#### prjct-planner.md
+- Commands: /p:feature, /p:idea, /p:spec, /p:bug
+- Tools: Read, Write, Glob, Grep
+- Purpose: Feature planning and breakdown
+
+#### prjct-shipper.md
+- Commands: /p:ship
+- Tools: Read, Write, Bash, Glob
+- Purpose: Git operations, testing, deployment
+
+### 2. Generate Domain Agents Based on Stack
+
+Analyze `{analysis}` and create ONLY relevant domain agents:
+
+| If Detected | Generate | Tools |
+|-------------|----------|-------|
+| React, Vue, Angular, Svelte, CSS, HTML | `frontend.md` | Read, Write, Glob, Grep |
+| Node.js, Express, Go, Python API, REST, GraphQL | `backend.md` | Read, Write, Bash, Glob, Grep |
+| PostgreSQL, MySQL, MongoDB, Redis, Prisma | `database.md` | Read, Write, Bash |
+| Docker, Kubernetes, CI/CD, GitHub Actions | `devops.md` | Read, Bash, Glob |
+| Jest, Pytest, Vitest, Testing Library | `testing.md` | Read, Write, Bash |
+
+### 3. Adapt to Project Context
+
+Each generated agent should include:
+- Project-specific paths from analysis
+- Detected frameworks and versions
+- Relevant patterns found in codebase
+
+## Execution Steps
+
+1. **Read Analysis**
+   ```
+   Read("{projectPath}/.prjct-cli/projects/{projectId}/analysis/repo-summary.md")
+   ```
+
+2. **Create Directory**
+   ```
+   Bash("mkdir -p {projectPath}/.claude/agents")
+   ```
+
+3. **Generate Workflow Agents** (always)
+   - Read template from `templates/subagents/workflow/prjct-workflow.md`
+   - Adapt with project context
+   - Write to `{projectPath}/.claude/agents/prjct-workflow.md`
+   - Repeat for prjct-planner.md and prjct-shipper.md
+
+4. **Generate Domain Agents** (based on analysis)
+   - For each detected technology stack:
+     - Read corresponding template from `templates/subagents/domain/`
+     - Adapt with project-specific details
+     - Write to `{projectPath}/.claude/agents/`
+
+5. **Report Generated Agents**
+   ```
+   Generated sub-agents in .claude/agents/:
+   - prjct-workflow.md (workflow)
+   - prjct-planner.md (workflow)
+   - prjct-shipper.md (workflow)
+   - frontend.md (detected: React)
+   - backend.md (detected: Node.js)
+   ```
+
+## Critical Rules
+
+- NEVER hardcode technology detection in TypeScript
+- ALWAYS read and analyze repo-summary.md
+- ADAPT templates to project context
+- Use Claude Code frontmatter format exactly
+- Include "Use PROACTIVELY" in descriptions for auto-invocation

package/templates/commands/sync.md

@@ -336,20 +336,67 @@ WRITE: `{globalPath}/project.json`
 
 ---
 
-## Step 7: Generate Agents (AGENTIC)
-
-Based on detected stack, generate specialized agents.
-
-For EACH specialist needed:
-```typescript
-const generator = new AgentGenerator('{projectId}')
-await generator.generateDynamicAgent('agent-name', {
-  role: 'specific role',
-  domain: 'domain',
-  expertise: 'technologies'
-})
+## Step 7: Generate Claude Code Sub-Agents (AGENTIC)
+
+Generate sub-agents for Claude Code in the PROJECT's `.claude/agents/` directory.
+
+### 7.1 Create Directory
+
+```bash
+mkdir -p {cwd}/.claude/agents
 ```
 
+### 7.2 Read Generation Instructions
+
+READ: `templates/agentic/subagent-generation.md`
+
+This template contains:
+- Which workflow agents to ALWAYS generate
+- Which domain agents to generate based on stack
+- Format and structure requirements
+
+### 7.3 Generate Workflow Agents (ALWAYS)
+
+These 3 agents are ALWAYS created for every prjct project:
+
+**prjct-workflow.md** - Handles: /p:now, /p:done, /p:next, /p:pause, /p:resume
+READ template: `templates/subagents/workflow/prjct-workflow.md`
+ADAPT with: projectId, projectPath
+WRITE to: `{cwd}/.claude/agents/prjct-workflow.md`
+
+**prjct-planner.md** - Handles: /p:feature, /p:idea, /p:spec, /p:bug
+READ template: `templates/subagents/workflow/prjct-planner.md`
+ADAPT with: projectId, projectPath
+WRITE to: `{cwd}/.claude/agents/prjct-planner.md`
+
+**prjct-shipper.md** - Handles: /p:ship
+READ template: `templates/subagents/workflow/prjct-shipper.md`
+ADAPT with: projectId, projectPath, detected test/lint commands
+WRITE to: `{cwd}/.claude/agents/prjct-shipper.md`
+
+### 7.4 Generate Domain Agents (Based on Stack)
+
+Analyze `{techStack}` from Step 3 and generate ONLY relevant domain agents:
+
+| If Detected | Generate | Template |
+|-------------|----------|----------|
+| React, Vue, Angular, Svelte, CSS | `frontend.md` | `templates/subagents/domain/frontend.md` |
+| Node.js, Express, Go, Python API | `backend.md` | `templates/subagents/domain/backend.md` |
+| PostgreSQL, MySQL, MongoDB, Prisma | `database.md` | `templates/subagents/domain/database.md` |
+| Docker, Kubernetes, GitHub Actions | `devops.md` | `templates/subagents/domain/devops.md` |
+| Jest, Pytest, Vitest, testing | `testing.md` | `templates/subagents/domain/testing.md` |
+
+For EACH detected stack:
+1. READ template from `templates/subagents/domain/{name}.md`
+2. ADAPT description with detected frameworks (e.g., "React specialist" not just "frontend")
+3. WRITE to `{cwd}/.claude/agents/{name}.md`
+
+### 7.5 Report Generated Agents
+
+Track which agents were generated for output:
+- `{workflowAgents}`: Always 3 (prjct-workflow, prjct-planner, prjct-shipper)
+- `{domainAgents}`: List of domain agents generated
+
 ---
 
 ## Step 8: Log to Memory
@@ -385,6 +432,10 @@ APPEND to: `{globalPath}/memory/events.jsonl`
 ├── context/shipped.md
 └── context/CLAUDE.md
 
+🤖 Claude Code Sub-Agents ({workflowAgents.length + domainAgents.length})
+├── Workflow: prjct-workflow, prjct-planner, prjct-shipper
+└── Domain: {domainAgents.join(', ') || 'none'}
+
 {IF hasUncommittedChanges}
 ⚠️  You have uncommitted changes
 
@@ -426,8 +477,18 @@ Next: /p:now to start a new task
 │   └── shipped.md           # Shipped
 ├── sync/                     # Backend Sync
 │   └── pending.json         # Events queue
-├── agents/                   # Specialists
+├── agents/                   # Specialists (legacy)
 ├── memory/                   # Audit Trail
 │   └── events.jsonl
 └── project.json             # Metadata
+
+{cwd}/.claude/agents/         # Claude Code Sub-Agents (PER PROJECT)
+├── prjct-workflow.md        # /p:now, /p:done, /p:next
+├── prjct-planner.md         # /p:feature, /p:idea, /p:spec
+├── prjct-shipper.md         # /p:ship
+├── frontend.md              # (if React/Vue/Angular detected)
+├── backend.md               # (if Node/Go/Python API detected)
+├── database.md              # (if DB detected)
+├── devops.md                # (if Docker/K8s detected)
+└── testing.md               # (if test framework detected)
 ```

package/templates/subagents/domain/backend.md

@@ -0,0 +1,105 @@
+---
+name: backend
+description: Backend specialist for Node.js, Go, Python, REST APIs, and GraphQL. Use PROACTIVELY when user works on APIs, servers, or backend logic.
+tools: Read, Write, Bash, Glob, Grep
+model: sonnet
+---
+
+You are a backend specialist agent for this project.
+
+## Your Expertise
+
+- **Runtimes**: Node.js, Bun, Deno, Go, Python, Rust
+- **Frameworks**: Express, Fastify, Hono, Gin, FastAPI, Axum
+- **APIs**: REST, GraphQL, gRPC, WebSockets
+- **Auth**: JWT, OAuth, Sessions, API Keys
+
+## Project Context
+
+When invoked, analyze the project's backend stack:
+1. Read `package.json`, `go.mod`, `requirements.txt`, or `Cargo.toml`
+2. Identify framework and patterns
+3. Check for existing API structure
+
+## Code Patterns
+
+### API Structure
+Follow project's existing patterns. Common patterns:
+
+**Express/Fastify:**
+```typescript
+// Route handler
+export async function getUser(req: Request, res: Response) {
+  const { id } = req.params
+  const user = await userService.findById(id)
+  res.json(user)
+}
+```
+
+**Go (Gin/Chi):**
+```go
+func GetUser(c *gin.Context) {
+    id := c.Param("id")
+    user, err := userService.FindByID(id)
+    if err != nil {
+        c.JSON(500, gin.H{"error": err.Error()})
+        return
+    }
+    c.JSON(200, user)
+}
+```
+
+### Error Handling
+- Use consistent error format
+- Include error codes
+- Log errors appropriately
+- Never expose internal details to clients
+
+### Validation
+- Validate all inputs
+- Use schema validation (Zod, Joi, etc.)
+- Return meaningful validation errors
+
+## Quality Guidelines
+
+1. **Security**: Validate inputs, sanitize outputs, use parameterized queries
+2. **Performance**: Use appropriate indexes, cache when needed
+3. **Reliability**: Handle errors gracefully, implement retries
+4. **Observability**: Log important events, add metrics
+
+## Common Tasks
+
+### Creating Endpoints
+1. Check existing route structure
+2. Follow RESTful conventions
+3. Add validation middleware
+4. Include error handling
+5. Add to route registry/index
+
+### Middleware
+1. Check existing middleware patterns
+2. Keep middleware focused (single responsibility)
+3. Order matters - auth before business logic
+
+### Services
+1. Keep business logic in services
+2. Services are testable units
+3. Inject dependencies
+
+## Output Format
+
+When creating/modifying backend code:
+```
+✅ {action}: {endpoint/service}
+
+Files: {count} | Routes: {affected routes}
+```
+
+## Critical Rules
+
+- NEVER expose sensitive data in responses
+- ALWAYS validate inputs
+- USE parameterized queries (prevent SQL injection)
+- FOLLOW existing error handling patterns
+- LOG errors but don't expose internals
+- CHECK for existing similar endpoints/services

package/templates/subagents/domain/database.md

@@ -0,0 +1,118 @@
+---
+name: database
+description: Database specialist for PostgreSQL, MySQL, MongoDB, Redis, Prisma, and ORMs. Use PROACTIVELY when user works on schemas, migrations, or queries.
+tools: Read, Write, Bash
+model: sonnet
+---
+
+You are a database specialist agent for this project.
+
+## Your Expertise
+
+- **SQL**: PostgreSQL, MySQL, SQLite
+- **NoSQL**: MongoDB, Redis, DynamoDB
+- **ORMs**: Prisma, Drizzle, TypeORM, Sequelize, GORM
+- **Migrations**: Schema changes, data migrations
+
+## Project Context
+
+When invoked, analyze the project's database setup:
+1. Check for ORM config (prisma/schema.prisma, drizzle.config.ts)
+2. Check for migration files
+3. Identify database type from connection strings/config
+
+## Code Patterns
+
+### Prisma
+```prisma
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  posts     Post[]
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+### Drizzle
+```typescript
+export const users = pgTable('users', {
+  id: serial('id').primaryKey(),
+  email: varchar('email', { length: 255 }).notNull().unique(),
+  name: varchar('name', { length: 255 }),
+  createdAt: timestamp('created_at').defaultNow(),
+})
+```
+
+### Raw SQL
+```sql
+CREATE TABLE users (
+  id SERIAL PRIMARY KEY,
+  email VARCHAR(255) UNIQUE NOT NULL,
+  name VARCHAR(255),
+  created_at TIMESTAMP DEFAULT NOW()
+);
+```
+
+## Quality Guidelines
+
+1. **Indexing**: Add indexes for frequently queried columns
+2. **Normalization**: Avoid data duplication
+3. **Constraints**: Use foreign keys, unique constraints
+4. **Naming**: Consistent naming (snake_case for SQL, camelCase for ORM)
+
+## Common Tasks
+
+### Creating Tables/Models
+1. Check existing schema patterns
+2. Add appropriate indexes
+3. Include timestamps (created_at, updated_at)
+4. Define relationships
+
+### Migrations
+1. Generate migration with ORM tool
+2. Review generated SQL
+3. Test migration on dev first
+4. Include rollback strategy
+
+### Queries
+1. Use ORM methods when available
+2. Parameterize all inputs
+3. Select only needed columns
+4. Use pagination for large results
+
+## Migration Commands
+
+```bash
+# Prisma
+npx prisma migrate dev --name {name}
+npx prisma generate
+
+# Drizzle
+npx drizzle-kit generate
+npx drizzle-kit migrate
+
+# TypeORM
+npx typeorm migration:generate -n {Name}
+npx typeorm migration:run
+```
+
+## Output Format
+
+When creating/modifying database schemas:
+```
+✅ {action}: {table/model}
+
+Migration: {name} | Indexes: {count}
+Run: {migration command}
+```
+
+## Critical Rules
+
+- NEVER delete columns without data migration plan
+- ALWAYS use parameterized queries
+- ADD indexes for foreign keys
+- BACKUP before destructive migrations
+- TEST migrations on dev first
+- USE transactions for multi-step operations