prjct-cli 0.28.2 → 0.28.4

package/core/infrastructure/setup.ts

@@ -146,9 +146,34 @@ async function migrateProjectsCliVersion(): Promise<void> {
       .map(dirent => dirent.name)
 
     let migrated = 0
+    let configsCreated = 0
 
     for (const projectId of projectDirs) {
       const projectJsonPath = path.join(projectsDir, projectId, 'project.json')
+      const configDir = path.join(projectsDir, projectId, 'config')
+
+      // Ensure config directory exists for new config files
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true })
+      }
+
+      // Create slash-commands.json if missing (v0.28+ feature)
+      const slashCommandsPath = path.join(configDir, 'slash-commands.json')
+      if (!fs.existsSync(slashCommandsPath)) {
+        const slashCommandsConfig = {
+          version: '1.0.0',
+          generatedAt: new Date().toISOString(),
+          note: 'Run /p:sync to regenerate with full command list',
+          commands: {
+            'p:task': { description: 'Start any task', category: 'workflow' },
+            'p:done': { description: 'Complete subtask', category: 'workflow' },
+            'p:ship': { description: 'Ship feature', category: 'shipping' },
+            'p:sync': { description: 'Sync project', category: 'planning' },
+          }
+        }
+        fs.writeFileSync(slashCommandsPath, JSON.stringify(slashCommandsConfig, null, 2))
+        configsCreated++
+      }
 
       if (!fs.existsSync(projectJsonPath)) {
         continue
@@ -172,6 +197,9 @@ async function migrateProjectsCliVersion(): Promise<void> {
     if (migrated > 0) {
       console.log(`   ${GREEN}✓${NC} Updated ${migrated} project(s) to v${VERSION}`)
     }
+    if (configsCreated > 0) {
+      console.log(`   ${GREEN}✓${NC} Created ${configsCreated} new config file(s)`)
+    }
   } catch {
     // Silently fail - migration is optional
   }

package/core/infrastructure/slash-command-registry.ts

@@ -0,0 +1,176 @@
+/**
+ * Slash Command Registry
+ * Generates Claude Code native slash command configuration.
+ *
+ * This enables:
+ * - Native /p:* command autocomplete in Claude Code
+ * - Command validation before execution
+ * - Command discoverability in help systems
+ *
+ * @version 1.0.0
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+
+export interface SlashCommand {
+  name: string
+  description: string
+  args?: string
+  category: 'workflow' | 'planning' | 'shipping' | 'analytics' | 'maintenance'
+  requiresProject: boolean
+  deprecated?: boolean
+  replacedBy?: string
+}
+
+export interface SlashCommandRegistry {
+  version: string
+  generatedAt: string
+  commands: Record<string, SlashCommand>
+}
+
+/**
+ * Core prjct commands with metadata
+ */
+const PRJCT_COMMANDS: SlashCommand[] = [
+  // Workflow
+  { name: 'task', description: 'Start any task with intelligent classification', args: '<description>', category: 'workflow', requiresProject: true },
+  { name: 'done', description: 'Complete current subtask', category: 'workflow', requiresProject: true },
+  { name: 'pause', description: 'Pause current task', category: 'workflow', requiresProject: true },
+  { name: 'resume', description: 'Resume paused task', category: 'workflow', requiresProject: true },
+  { name: 'next', description: 'Show next tasks in queue', category: 'workflow', requiresProject: true },
+
+  // Planning
+  { name: 'init', description: 'Initialize prjct in current directory', args: '[description]', category: 'planning', requiresProject: false },
+  { name: 'sync', description: 'Deep sync - analyze project, generate agents', category: 'planning', requiresProject: true },
+  { name: 'idea', description: 'Capture an idea for later', args: '<idea>', category: 'planning', requiresProject: true },
+  { name: 'spec', description: 'Generate feature specification', args: '<feature>', category: 'planning', requiresProject: true },
+  { name: 'bug', description: 'Report a bug with auto-priority', args: '<description>', category: 'planning', requiresProject: true },
+
+  // Shipping
+  { name: 'ship', description: 'Ship feature with PR workflow', args: '[feature]', category: 'shipping', requiresProject: true },
+  { name: 'review', description: 'Run code review on changes', category: 'shipping', requiresProject: true },
+  { name: 'test', description: 'Run tests for current changes', category: 'shipping', requiresProject: true },
+  { name: 'verify', description: 'Verify deployment', category: 'shipping', requiresProject: true },
+
+  // Analytics
+  { name: 'dash', description: 'Show project dashboard', category: 'analytics', requiresProject: true },
+  { name: 'history', description: 'Show task history', category: 'analytics', requiresProject: true },
+  { name: 'analyze', description: 'Analyze codebase', category: 'analytics', requiresProject: true },
+
+  // Maintenance
+  { name: 'cleanup', description: 'Clean up project files', category: 'maintenance', requiresProject: true },
+  { name: 'undo', description: 'Undo last action', category: 'maintenance', requiresProject: true },
+  { name: 'redo', description: 'Redo undone action', category: 'maintenance', requiresProject: true },
+
+  // Deprecated
+  { name: 'now', description: 'Start task (deprecated)', args: '<task>', category: 'workflow', requiresProject: true, deprecated: true, replacedBy: 'task' },
+  { name: 'feature', description: 'Plan feature (deprecated)', args: '<feature>', category: 'planning', requiresProject: true, deprecated: true, replacedBy: 'task' },
+]
+
+/**
+ * Generate slash command registry for Claude Code
+ */
+export async function generateRegistry(): Promise<SlashCommandRegistry> {
+  const commands: Record<string, SlashCommand> = {}
+
+  for (const cmd of PRJCT_COMMANDS) {
+    commands[`p:${cmd.name}`] = cmd
+  }
+
+  return {
+    version: '1.0.0',
+    generatedAt: new Date().toISOString(),
+    commands,
+  }
+}
+
+/**
+ * Write registry to project's global path
+ */
+export async function writeRegistry(projectId: string): Promise<{ success: boolean; path?: string; error?: string }> {
+  try {
+    const globalPath = path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'config')
+    await fs.mkdir(globalPath, { recursive: true })
+
+    const registry = await generateRegistry()
+    const registryPath = path.join(globalPath, 'slash-commands.json')
+
+    await fs.writeFile(registryPath, JSON.stringify(registry, null, 2), 'utf-8')
+
+    return { success: true, path: registryPath }
+  } catch (error) {
+    return { success: false, error: (error as Error).message }
+  }
+}
+
+/**
+ * Get command by name
+ */
+export function getCommand(name: string): SlashCommand | undefined {
+  return PRJCT_COMMANDS.find(cmd => cmd.name === name)
+}
+
+/**
+ * Get all commands by category
+ */
+export function getCommandsByCategory(category: SlashCommand['category']): SlashCommand[] {
+  return PRJCT_COMMANDS.filter(cmd => cmd.category === category && !cmd.deprecated)
+}
+
+/**
+ * Validate command exists
+ */
+export function validateCommand(name: string): { valid: boolean; command?: SlashCommand; error?: string } {
+  const cmd = getCommand(name)
+
+  if (!cmd) {
+    return { valid: false, error: `Unknown command: ${name}` }
+  }
+
+  if (cmd.deprecated) {
+    return {
+      valid: true,
+      command: cmd,
+      error: `Command '${name}' is deprecated. Use '${cmd.replacedBy}' instead.`,
+    }
+  }
+
+  return { valid: true, command: cmd }
+}
+
+/**
+ * Format commands for help display
+ */
+export function formatHelpText(): string {
+  const categories = ['workflow', 'planning', 'shipping', 'analytics', 'maintenance'] as const
+  const lines: string[] = ['# prjct Commands', '']
+
+  for (const category of categories) {
+    const cmds = getCommandsByCategory(category)
+    if (cmds.length === 0) continue
+
+    lines.push(`## ${category.charAt(0).toUpperCase() + category.slice(1)}`)
+    lines.push('')
+
+    for (const cmd of cmds) {
+      const args = cmd.args ? ` ${cmd.args}` : ''
+      lines.push(`- \`/p:${cmd.name}${args}\` - ${cmd.description}`)
+    }
+
+    lines.push('')
+  }
+
+  return lines.join('\n')
+}
+
+export default {
+  generateRegistry,
+  writeRegistry,
+  getCommand,
+  getCommandsByCategory,
+  validateCommand,
+  formatHelpText,
+  PRJCT_COMMANDS,
+}

package/core/types/integrations.ts

@@ -3,10 +3,37 @@
  * Types for external service integrations
  */
 
+/**
+ * MCP Server Configuration
+ */
+export interface McpServerConfig {
+  name: string
+  description?: string
+  command: string
+  args: string[]
+  enabled: boolean
+  linkedAgents?: string[]
+  autoLoad?: boolean
+  setupAt?: string
+}
+
+/**
+ * MCP Servers Configuration for a project
+ */
+export interface McpServersConfig {
+  projectId: string
+  version: string
+  servers: Record<string, McpServerConfig>
+  agentMcpMap: Record<string, string[]>
+}
+
 /**
  * Integrations Config
  * Container for all external integrations
  */
 export interface IntegrationsConfig {
-  // Future integrations can be added here
+  mcp?: {
+    enabled: boolean
+    configPath: string
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.28.2",
+  "version": "0.28.4",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.ts",
   "bin": {

package/templates/agentic/subagent-generation.md

@@ -1,17 +1,20 @@
-# Sub-Agent Generation
+# Sub-Agent Generation (AGENTIC)
 
-Generate Claude Code sub-agents for this project based on detected stack.
+Generate Claude Code sub-agents dynamically based on ACTUAL project analysis.
+
+**CRITICAL**: There are NO hardcoded templates. You MUST analyze the project and GENERATE agents from scratch.
 
 ## Input Context
 
 You have access to:
-- `{analysis}` - repo-summary.md with detected technologies
+- `{analysis}` - repo-analysis.json with detected technologies
 - `{projectPath}` - Path to project root
 - `{projectId}` - Project identifier
+- `{globalPath}` - ~/.prjct-cli/projects/{projectId}
 
 ## Output Location
 
-Write sub-agents to: `{globalPath}/agents/` (global storage, NOT local project)
+Write sub-agents to: `{globalPath}/agents/`
 
 ## Sub-Agent Format (Claude Code)
 
@@ -20,121 +23,265 @@ Write sub-agents to: `{globalPath}/agents/` (global storage, NOT local project)
 name: agent-name
 agentId: p.agent.{name}
 description: When to use this agent. Include "Use PROACTIVELY" for auto-invocation.
-tools: Read, Write, Glob, Grep, Bash
 model: sonnet
-skills: [skill-name]
+temperature: {0.1-0.4}
+maxSteps: {50-100}
+tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+permissions:
+  Bash: ask
+  Write: allow
+  Edit: allow
+  "rm *": deny
+skills: [{detected-skill}]
+mcp: [{detected-mcp-servers}]
 projectId: {projectId}
 projectPath: {projectPath}
 ---
 
-Agent system prompt here...
+# {Agent Name}
+
+## Stack Detected
+{ACTUAL technologies found in THIS project}
+
+## Project Structure
+{ACTUAL directory structure for this domain}
+
+## Code Patterns (EXTRACTED FROM PROJECT)
+{REAL patterns found by reading actual files}
+
+## Quality Checklist
+{Based on project conventions}
+
+## Commands
+{ACTUAL commands from package.json/Makefile/etc}
+```
+
+---
+
+## Generation Process (AGENTIC)
+
+### Step 1: Analyze Project Deeply
+
+DO NOT use templates. Instead:
+
+```
+1. READ package.json, go.mod, Cargo.toml, requirements.txt, etc.
+2. GLOB for source files: **/*.ts, **/*.tsx, **/*.py, **/*.go, etc.
+3. READ 3-5 representative files from each domain
+4. EXTRACT actual patterns, conventions, naming
+5. CHECK for linter/formatter configs
 ```
 
-**Required fields:**
-- `agentId`: Unique identifier for mentions. Format: `p.agent.{name}` (e.g., `p.agent.backend`, `p.agent.frontend`)
-- `skills`: Links the agent to Claude Code skills from claude-plugins.dev
-- `projectId`: Links agent to specific project
-- `projectPath`: Path to project root
+### Step 2: Determine Domains Present
+
+Based on your analysis, identify which domains exist:
+
+| Domain | Detection Method |
+|--------|------------------|
+| frontend | React/Vue/Angular/Svelte in deps, .tsx/.vue files |
+| backend | Express/Fastify/Hono/Gin/Flask in deps, API routes |
+| database | Prisma/Drizzle/TypeORM schemas, SQL files |
+| testing | Jest/Vitest/Pytest configs, *.test.* files |
+| devops | Dockerfile, .github/workflows, k8s/ |
+| uxui | UI components + design tokens/theme |
+| mobile | React Native/Flutter/SwiftUI |
+| cli | Command definitions, arg parsing |
+| ml | Model files, training scripts |
+
+### Step 3: Generate Each Agent FROM SCRATCH
+
+For EACH detected domain:
 
-**Agent ID Convention:**
-- All prjct agents use prefix `p.agent.`
-- The `{name}` is derived from the agent filename without `.md`
-- Examples: `p.agent.backend`, `p.agent.frontend`, `p.agent.workflow`, `p.agent.planner`
-- Users can mention agents in prompts using this ID
+1. **Analyze domain-specific files**
+   ```
+   READ actual source files in that domain
+   EXTRACT: imports, exports, naming, structure
+   ```
+
+2. **Determine configuration**
+   - `temperature`: 0.1 for DB, 0.2 for backend/testing, 0.3 for frontend, 0.4 for uxui
+   - `maxSteps`: 50 for simple, 75 for medium, 100 for complex
+   - `tools`: Based on what the domain needs
+   - `permissions`: Deny destructive commands
 
-## Generation Rules
+3. **Discover skills and MCP**
+   - Search claude-plugins.dev for relevant skills
+   - Determine if context7 MCP is needed (library docs)
 
-### 1. ALWAYS Generate Workflow Agents
+4. **Write agent with REAL patterns**
+   ```
+   Include ACTUAL code examples from the project
+   Include ACTUAL commands from package.json
+   Include ACTUAL file structure
+   ```
 
-These are REQUIRED for every prjct project:
+### Step 4: Generate Workflow Agents (ALWAYS)
+
+These 3 agents are always generated but STILL need project context:
 
 #### prjct-workflow.md
 - Commands: /p:now, /p:done, /p:next, /p:pause, /p:resume
-- Tools: Read, Write, Glob
-- Purpose: Task lifecycle management
+- Adapt with: project paths, detected commands
 
 #### prjct-planner.md
 - Commands: /p:feature, /p:idea, /p:spec, /p:bug
-- Tools: Read, Write, Glob, Grep
-- Purpose: Feature planning and breakdown
+- Adapt with: detected stack for planning context
 
 #### prjct-shipper.md
 - Commands: /p:ship
-- Tools: Read, Write, Bash, Glob
-- Purpose: Git operations, testing, deployment
+- Adapt with: actual test/build/lint commands from project
+
+---
 
-### 2. Generate Domain Agents Based on Stack
+## MCP Integration
 
-Analyze `{analysis}` and create ONLY relevant domain agents:
+Determine which agents need MCP servers:
 
-| If Detected | Generate | Tools | Skill |
-|-------------|----------|-------|-------|
-| React, Vue, Angular, Svelte, CSS, HTML | `frontend.md` | Read, Write, Glob, Grep | `frontend-design` |
-| Node.js, Express, Go, Python API, REST, GraphQL | `backend.md` | Read, Write, Bash, Glob, Grep | `javascript-typescript` or `python-development` |
-| PostgreSQL, MySQL, MongoDB, Redis, Prisma | `database.md` | Read, Write, Bash | (none) |
-| Docker, Kubernetes, CI/CD, GitHub Actions | `devops.md` | Read, Bash, Glob | `developer-kit` |
-| Bun test, Jest, Pytest, Testing Library | `testing.md` | Read, Write, Bash | `developer-kit` |
-| ANY frontend UI (web or mobile) | `uxui.md` | Read, Write, Glob, Grep | `frontend-design` |
+```
+IF agent works with libraries/frameworks:
+  ADD mcp: [context7]
 
-### 3. Adapt to Project Context
+Agents that typically need context7:
+- frontend (React, Vue docs)
+- backend (Express, Hono docs)
+- database (Prisma, Drizzle docs)
+- uxui (component library docs)
+- prjct-planner (framework docs for planning)
+```
 
-Each generated agent should include:
-- Project-specific paths from analysis
-- Detected frameworks and versions
-- Relevant patterns found in codebase
+---
 
-## Execution Steps
+## Skill Discovery
 
-1. **Read Analysis**
-   ```
-   Read("{globalPath}/analysis/repo-summary.md")
-   ```
+For each agent, search for relevant skills:
 
-2. **Create Directory**
-   ```
-   Bash("mkdir -p {globalPath}/agents")
-   ```
+```
+WebFetch: https://claude-plugins.dev/skills?q={domain}+{stack}
 
-3. **Generate Workflow Agents** (always)
-   - Read template from `templates/subagents/workflow/prjct-workflow.md`
-   - Adapt with project context
-   - Write to `{globalPath}/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 `{globalPath}/agents/`
-
-5. **Link Skills to Agents**
-   - Read `templates/config/skill-mappings.json`
-   - For each generated agent, add the corresponding skill to frontmatter
-   - Skill mappings:
-     - `frontend.md` → `skills: [frontend-design]`
-     - `uxui.md` → `skills: [frontend-design]`
-     - `backend.md` → `skills: [javascript-typescript]` (or `python-development` for Python)
-     - `testing.md` → `skills: [developer-kit]`
-     - `devops.md` → `skills: [developer-kit]`
-     - `prjct-planner.md` → `skills: [feature-dev]`
-     - `prjct-shipper.md` → `skills: [code-review]`
-
-6. **Report Generated Agents**
-   ```
-   Generated sub-agents in {globalPath}/agents/:
-   - prjct-workflow.md (workflow)
-   - prjct-planner.md (workflow) → /feature-dev
-   - prjct-shipper.md (workflow) → /code-review
-   - frontend.md (detected: React) → /frontend-design
-   - backend.md (detected: Node.js) → /javascript-typescript
-   ```
+Examples:
+- frontend + React → search "react frontend"
+- backend + TypeScript → search "typescript backend"
+- testing + Bun → search "bun testing"
+```
+
+If no skill found, leave skills empty or create minimal custom skill.
+
+---
+
+## Output Format
+
+After generating each agent:
+
+```
+Generated: {agent}.md
+  Stack: {detected technologies}
+  Patterns: {count} extracted from {files analyzed}
+  Skills: {linked skills}
+  MCP: {linked mcp servers}
+  Path: {globalPath}/agents/{agent}.md
+```
+
+---
+
+## Critical Rules
+
+1. **NO TEMPLATES** - Generate everything from project analysis
+2. **NO HARDCODING** - Every value comes from detection
+3. **REAL PATTERNS** - Include actual code examples from the project
+4. **ACTUAL COMMANDS** - Use real commands from package.json/Makefile
+5. **PROJECT-SPECIFIC** - Each agent is unique to this project
+6. **GLOBAL STORAGE** - Write to `{globalPath}/agents/`, never local
+
+---
+
+## Example: Generated Backend Agent
+
+This is an EXAMPLE of what a generated agent might look like (NOT a template to copy):
+
+```markdown
+---
+name: backend
+agentId: p.agent.backend
+description: Backend specialist for Hono + Bun. Use PROACTIVELY for API routes and server logic.
+model: sonnet
+temperature: 0.2
+maxSteps: 75
+tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+permissions:
+  Bash: ask
+  Write: allow
+  Edit: allow
+  "rm *": deny
+skills: [javascript-typescript]
+mcp: [context7]
+projectId: abc123
+projectPath: /Users/dev/my-project
+---
+
+# Backend Agent for my-project
+
+## Stack Detected
+- Runtime: Bun 1.0
+- Framework: Hono 4.x
+- Validation: Zod
+- Database: Drizzle + SQLite
+
+## Project Structure
+```
+core/
+├── routes/       # API endpoints
+├── services/     # Business logic
+├── middleware/   # Auth, logging
+└── types/        # TypeScript types
+```
+
+## Code Patterns (FROM THIS PROJECT)
+
+### Route Structure
+```typescript
+// Extracted from core/routes/users.ts
+app.get('/users/:id', async (c) => {
+  const { id } = c.req.param()
+  const user = await userService.findById(id)
+  return c.json(user)
+})
+```
+
+### Error Handling
+```typescript
+// Extracted from core/middleware/error.ts
+app.onError((err, c) => {
+  console.error(err)
+  return c.json({ error: err.message }, 500)
+})
+```
+
+## Commands
+
+| Action | Command |
+|--------|---------|
+| Dev | `bun run dev` |
+| Test | `bun test` |
+| Build | `bun run build` |
+| Lint | `bun run lint` |
 
 ## Critical Rules
+- Use Hono's context (c) pattern
+- Validate with Zod before processing
+- Return proper HTTP status codes
+- Use existing service layer pattern
+```
 
-- **NEVER write agents to local project directories** (`.claude/`, `.prjct/`)
-- **ALWAYS write agents to `{globalPath}/agents/`** (global storage)
-- 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
+This agent was GENERATED by analyzing the actual project, not copied from a template.