prjct-cli 0.10.3 → 0.10.5

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [0.10.5] - 2025-11-27
+
+### Enhanced
+
+- **Rich Project Context** - CLAUDE.md now includes comprehensive project info
+  - Quick reference table (project, stack, files, commits, contributors)
+  - Full tech stack details (languages, frameworks, dependencies)
+  - Project structure (directories)
+  - Agent summaries with roles and expertise
+  - Current task and priority queue (top 5)
+  - Active roadmap features
+  - Recent ideas (top 3)
+  - Git activity (last 5 commits)
+  - Deep dive section with file paths for detailed info
+
+- **Reduced LLM Context Overhead** - Claude gets all key info in one file instead of reading multiple
+
+## [0.10.4] - 2025-11-27
+
+### Fixed
+
+- **Commands Module Export** - Fixed `require('./commands').sync is not a function` error
+  - Module now exports singleton instance for direct use
+  - Class still available via `require('./commands').PrjctCommands`
+  - Enables Claude to call commands directly: `require('./commands').sync()`
+
 ## [0.10.3] - 2025-11-27
 
 ### Fixed

package/core/commands.js

@@ -3014,4 +3014,10 @@ Agent: ${agent}
   }
 }
 
-module.exports = PrjctCommands
+// Export both class and singleton instance
+// Class for CLI (new PrjctCommands())
+// Instance for direct use (require('./commands').sync())
+const instance = new PrjctCommands()
+
+module.exports = instance
+module.exports.PrjctCommands = PrjctCommands

package/core/context-sync.js

@@ -1,11 +1,14 @@
 /**
- * Context Sync - Generates dynamic project context for Claude
+ * Context Sync - Generates RICH dynamic project context for Claude
  *
  * Creates ~/.prjct-cli/projects/{id}/CLAUDE.md with:
- * - Stack info
- * - Available agents (dynamic, varies per project)
- * - Current task
- * - Priority queue
+ * - Full stack info (languages, frameworks, dependencies)
+ * - Project structure and stats
+ * - Agent expertise summaries
+ * - Current task and priority queue
+ * - Active features from roadmap
+ *
+ * GOAL: Give Claude ALL the context it needs WITHOUT extra file reads
  *
  * Called by: /p:sync, /p:analyze, /p:init
  */
@@ -15,17 +18,27 @@ const path = require('path')
 const os = require('os')
 
 /**
- * Generate project context file for Claude
- * 100% DYNAMIC - reads whatever agents exist
+ * Generate RICH project context file for Claude
+ * Embeds key information so Claude doesn't need to read multiple files
  *
  * @param {string} projectPath - Local project path
  * @param {string} projectId - Project ID from config
- * @returns {Promise<{agents: string[], stack: string|null, currentTask: string|null}>}
+ * @returns {Promise<{agents: string[], stack: object, currentTask: string|null}>}
  */
 async function generateLocalContext(projectPath, projectId) {
   const globalPath = path.join(os.homedir(), '.prjct-cli/projects', projectId)
+  const projectName = path.basename(projectPath)
+
+  // Helper to read files safely
+  const readSafe = async (p) => {
+    try {
+      return await fs.readFile(p, 'utf-8')
+    } catch {
+      return null
+    }
+  }
 
-  // 1. Read ALL agents that exist (dynamic - varies per project)
+  // 1. Read ALL data sources in parallel
   const agentsDir = path.join(globalPath, 'agents')
   let agentFiles = []
   try {
@@ -35,91 +48,210 @@ async function generateLocalContext(projectPath, projectId) {
     // No agents directory yet
   }
 
-  // 2. Read core files (may not exist)
-  const readSafe = async (p) => {
-    try {
-      return await fs.readFile(p, 'utf-8')
-    } catch {
-      return null
-    }
-  }
-
-  const [repoSummary, now, next, roadmap] = await Promise.all([
+  const [repoSummary, now, next, roadmap, ideas] = await Promise.all([
     readSafe(path.join(globalPath, 'analysis/repo-summary.md')),
     readSafe(path.join(globalPath, 'core/now.md')),
     readSafe(path.join(globalPath, 'core/next.md')),
-    readSafe(path.join(globalPath, 'planning/roadmap.md'))
+    readSafe(path.join(globalPath, 'planning/roadmap.md')),
+    readSafe(path.join(globalPath, 'planning/ideas.md'))
   ])
 
-  // 3. Extract stack from repo-summary
-  const stack = extractStack(repoSummary)
+  // 2. Extract RICH stack info from repo-summary
+  const stackInfo = extractFullStack(repoSummary)
+
+  // 3. Extract project structure from repo-summary
+  const projectStructure = extractProjectStructure(repoSummary)
+
+  // 4. Extract git stats
+  const gitStats = extractGitStats(repoSummary)
 
-  // 4. Generate agent list with clean names
-  const agents = agentFiles.map(f => f.replace('.md', ''))
+  // 5. Read agent expertise (just the key parts, not full templates)
+  const agentExpertise = await extractAgentExpertise(agentsDir, agentFiles)
 
-  // 5. Extract current task
+  // 6. Extract current task
   const currentTask = extractCurrentTask(now)
 
-  // 6. Extract top 3 from next.md
-  const nextTasks = extractTopTasks(next, 3)
+  // 7. Extract priority queue (top 5)
+  const nextTasks = extractTopTasks(next, 5)
 
-  // 7. Extract active features from roadmap
+  // 8. Extract active features from roadmap
   const activeFeatures = extractActiveFeatures(roadmap)
 
-  // 8. Generate CLAUDE.md content
-  const content = `# Project Context
-<!-- Auto-generated by /p:sync - DO NOT EDIT -->
+  // 9. Extract recent ideas
+  const recentIdeas = extractRecentIdeas(ideas)
+
+  // 10. Generate RICH CLAUDE.md content
+  const content = `# ${projectName} - Project Context
+<!-- Auto-generated by /p:sync - DO NOT EDIT MANUALLY -->
 <!-- projectId: ${projectId} -->
 <!-- Last sync: ${new Date().toISOString()} -->
 
-## Stack
-${stack || 'Run /p:analyze to detect stack'}
+## Quick Reference
+
+| Attribute | Value |
+|-----------|-------|
+| **Project** | ${projectName} |
+| **Stack** | ${stackInfo.primary || 'Not detected'} |
+| **Files** | ${projectStructure.fileCount || '?'} |
+| **Commits** | ${gitStats.commits || '?'} |
+| **Contributors** | ${gitStats.contributors || '?'} |
+
+## Tech Stack
+
+${stackInfo.full || 'Run /p:analyze to detect stack'}
+
+## Project Structure
+
+${projectStructure.directories?.length ? projectStructure.directories.map(d => `- \`${d}/\``).join('\n') : 'Run /p:analyze to detect structure'}
 
 ## Available Agents
-${agents.length ? agents.map(a => `- ${a}`).join('\n') : 'None. Run /p:sync to generate.'}
 
-## Current Task
-${currentTask || 'None. Use /p:now to start.'}
+${agentExpertise.length ? agentExpertise.map(a => `### ${a.name}
+- **Role**: ${a.role}
+- **Expertise**: ${a.expertise}
+`).join('\n') : 'None. Run /p:sync to generate agents.'}
+
+## Current Focus
+
+${currentTask ? `**Active Task**: ${currentTask}` : 'No active task. Use /p:now to start.'}
+
+## Priority Queue
+
+${nextTasks.length ? nextTasks.map((t, i) => `${i + 1}. ${t}`).join('\n') : 'Empty queue. Use /p:next to add tasks.'}
 
-## Next Up
-${nextTasks.length ? nextTasks.map((t, i) => `${i + 1}. ${t}`).join('\n') : 'Empty queue.'}
+## Active Features (Roadmap)
 
-## Active Features
-${activeFeatures.length ? activeFeatures.map(f => `- ${f}`).join('\n') : 'None in progress.'}
+${activeFeatures.length ? activeFeatures.map(f => `- [ ] ${f}`).join('\n') : 'No features in progress.'}
 
-## Data Location
-All project data: ~/.prjct-cli/projects/${projectId}/
-- agents/ - Read for detailed patterns and code examples
-- analysis/repo-summary.md - Full technical analysis
-- planning/roadmap.md - Features and roadmap
+## Recent Ideas
+
+${recentIdeas.length ? recentIdeas.map(i => `- ${i}`).join('\n') : 'No recent ideas.'}
+
+## Git Activity
+
+${gitStats.recentCommits?.length ? gitStats.recentCommits.map(c => `- \`${c.hash}\` ${c.message}`).join('\n') : 'No recent commits.'}
+
+---
+
+## Deep Dive (Read When Needed)
+
+For detailed information, read these files:
+- \`~/.prjct-cli/projects/${projectId}/agents/*.md\` - Full agent templates with code patterns
+- \`~/.prjct-cli/projects/${projectId}/analysis/repo-summary.md\` - Complete technical analysis
+- \`~/.prjct-cli/projects/${projectId}/planning/roadmap.md\` - Full feature roadmap
+- \`~/.prjct-cli/projects/${projectId}/memory/context.jsonl\` - Decision history
 `
 
-  // 9. Write to global storage (NOT in repo)
+  // 11. Write to global storage
   const contextPath = path.join(globalPath, 'CLAUDE.md')
   await fs.writeFile(contextPath, content, 'utf-8')
 
-  return { agents, stack, currentTask }
+  return { agents: agentFiles.map(f => f.replace('.md', '')), stack: stackInfo, currentTask }
 }
 
 /**
- * Extract stack from repo-summary
+ * Extract FULL stack info from repo-summary
  */
-function extractStack(summary) {
-  if (!summary) return null
-
-  // Try multiple patterns
-  const patterns = [
-    /\*\*(?:Stack|Framework|Language)\*\*[:\s|]+([^\n|]+)/i,
-    /\| \*\*Type\*\* \| ([^\|]+) \|/i,
-    /## Tech Stack[\s\S]*?### (?:Frontend|Backend)\n- \*\*([^*]+)\*\*/i
-  ]
-
-  for (const pattern of patterns) {
-    const match = summary.match(pattern)
-    if (match) return match[1].trim()
+function extractFullStack(summary) {
+  if (!summary) return { primary: null, full: null }
+
+  const result = { primary: null, full: null, languages: [], frameworks: [], dependencies: [] }
+
+  // Extract languages (e.g., "### JavaScript/TypeScript")
+  const langMatch = summary.match(/###\s*(JavaScript|TypeScript|Python|Go|Rust|Ruby|Java|C#|PHP)/i)
+  if (langMatch) result.primary = langMatch[1]
+
+  // Extract dependencies
+  const depsMatch = summary.match(/\*\*Dependencies\*\*:\s*([^\n]+)/i)
+  if (depsMatch) result.dependencies = depsMatch[1].split(',').map(d => d.trim())
+
+  // Extract full stack section (between ## Stack Detected and next ##)
+  const stackSection = summary.match(/## Stack Detected\n([\s\S]*?)(?=\n## |$)/i)
+  if (stackSection && stackSection[1]) {
+    result.full = stackSection[1].trim()
   }
 
-  return null
+  return result
+}
+
+/**
+ * Extract project structure from repo-summary
+ */
+function extractProjectStructure(summary) {
+  if (!summary) return { fileCount: null, directories: [] }
+
+  const result = { fileCount: null, directories: [] }
+
+  // Extract file count
+  const fileMatch = summary.match(/\*\*Total Files\*\*:\s*(\d+)/i)
+  if (fileMatch) result.fileCount = parseInt(fileMatch[1])
+
+  // Extract directories
+  const dirMatch = summary.match(/\*\*Directories\*\*:\s*([^\n]+)/i)
+  if (dirMatch) result.directories = dirMatch[1].split(',').map(d => d.trim())
+
+  return result
+}
+
+/**
+ * Extract git stats from repo-summary
+ */
+function extractGitStats(summary) {
+  if (!summary) return { commits: null, contributors: null, recentCommits: [] }
+
+  const result = { commits: null, contributors: null, recentCommits: [] }
+
+  // Extract commit count
+  const commitMatch = summary.match(/\*\*Total Commits\*\*:\s*(\d+)/i)
+  if (commitMatch) result.commits = parseInt(commitMatch[1])
+
+  // Extract contributors
+  const contribMatch = summary.match(/\*\*Contributors\*\*:\s*(\d+)/i)
+  if (contribMatch) result.contributors = parseInt(contribMatch[1])
+
+  // Extract recent commits
+  const recentSection = summary.match(/## Recent Activity[\s\S]*?(?=##|$)/i)
+  if (recentSection) {
+    const commitLines = recentSection[0].match(/- `([a-f0-9]+)` (.+?) \(/g)
+    if (commitLines) {
+      result.recentCommits = commitLines.slice(0, 5).map(line => {
+        const match = line.match(/- `([a-f0-9]+)` (.+?) \(/)
+        return match ? { hash: match[1], message: match[2] } : null
+      }).filter(Boolean)
+    }
+  }
+
+  return result
+}
+
+/**
+ * Extract agent expertise from agent files
+ */
+async function extractAgentExpertise(agentsDir, agentFiles) {
+  const expertise = []
+
+  for (const file of agentFiles.slice(0, 6)) { // Max 6 agents to keep context small
+    try {
+      const content = await fs.readFile(path.join(agentsDir, file), 'utf-8')
+      const name = file.replace('.md', '')
+
+      // Extract role
+      const roleMatch = content.match(/Role:\s*([^\n]+)/i)
+      const role = roleMatch ? roleMatch[1].trim() : 'Specialist'
+
+      // Extract domain or expertise
+      const domainMatch = content.match(/domain[:\s]+([^\n]+)/i) ||
+                          content.match(/expertise[:\s]+([^\n]+)/i) ||
+                          content.match(/owner of the ([^\n.]+)/i)
+      const expertiseText = domainMatch ? domainMatch[1].trim() : 'General'
+
+      expertise.push({ name, role, expertise: expertiseText })
+    } catch {
+      // Skip unreadable agents
+    }
+  }
+
+  return expertise
 }
 
 /**
@@ -128,11 +260,10 @@ function extractStack(summary) {
 function extractCurrentTask(now) {
   if (!now) return null
 
-  // Skip headers and empty lines, get first content line
   const lines = now.split('\n')
   for (const line of lines) {
     const trimmed = line.trim()
-    if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('<!--')) {
+    if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('<!--') && !trimmed.startsWith('No current')) {
       return trimmed
     }
   }
@@ -164,20 +295,34 @@ function extractActiveFeatures(roadmap) {
   let inActive = false
 
   for (const line of lines) {
-    if (line.includes('Active') || line.includes('In Progress')) {
+    if (line.includes('Active') || line.includes('In Progress') || line.includes('Current')) {
       inActive = true
       continue
     }
     if (line.startsWith('## ') && inActive) {
-      break // End of active section
+      break
     }
-    if (inActive && line.match(/^- \[ \]/)) {
-      const feature = line.replace(/^- \[ \]\s*\*\*/, '').replace(/\*\*.*$/, '').trim()
+    if (inActive && line.match(/^[-*]\s*\[[ x]\]/i)) {
+      const feature = line.replace(/^[-*]\s*\[[ x]\]\s*/, '').replace(/\*\*/g, '').trim()
       if (feature) features.push(feature)
     }
   }
 
-  return features.slice(0, 3) // Max 3
+  return features.slice(0, 5)
+}
+
+/**
+ * Extract recent ideas from ideas.md
+ */
+function extractRecentIdeas(ideas) {
+  if (!ideas) return []
+
+  return ideas
+    .split('\n')
+    .filter(l => l.match(/^[-*]\s/))
+    .slice(0, 3)
+    .map(l => l.replace(/^[-*]\s+/, '').trim())
+    .filter(Boolean)
 }
 
 module.exports = { generateLocalContext }

package/core/index.js

@@ -4,7 +4,7 @@
  * This file is required by bin/prjct after setup verification
  */
 
-const PrjctCommands = require('./commands')
+const { PrjctCommands } = require('./commands')
 const registry = require('./command-registry')
 
 async function main() {

package/package.json

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