prjct-cli 0.6.0 → 0.7.0

package/core/utils/session-helper.js

@@ -0,0 +1,277 @@
+const path = require('path')
+const dateHelper = require('./date-helper')
+const jsonlHelper = require('./jsonl-helper')
+const fileHelper = require('./file-helper')
+
+/**
+ * Session Helper - High-level session operations
+ *
+ * Simplifies common session workflows by combining:
+ * - date-helper (date formatting)
+ * - jsonl-helper (JSONL parsing)
+ * - file-helper (file operations)
+ * - path-manager (path construction)
+ *
+ * @module session-helper
+ */
+
+/**
+ * Build session file path for today
+ *
+ * @param {string} projectGlobalPath - Global project path
+ * @param {string} layer - Layer (planning/progress/memory)
+ * @param {string} filename - Filename (e.g., '2025-10-04.jsonl')
+ * @returns {string} - Full path to session file
+ */
+function getTodaySessionFilePath(projectGlobalPath, layer, filename = null) {
+  const today = dateHelper.getTodayKey()
+  const yearMonth = dateHelper.formatMonth(new Date())
+  const [year, month] = yearMonth.split('-')
+
+  const sessionDir = path.join(projectGlobalPath, layer, 'sessions', year, month)
+
+  if (filename) {
+    return path.join(sessionDir, filename)
+  }
+
+  return path.join(sessionDir, `${today}.jsonl`)
+}
+
+/**
+ * Ensure today's session directory exists
+ *
+ * @param {string} projectGlobalPath - Global project path
+ * @param {string} layer - Layer (planning/progress/memory)
+ * @returns {Promise<string>} - Path to session directory
+ */
+async function ensureTodaySessionDir(projectGlobalPath, layer) {
+  const yearMonth = dateHelper.formatMonth(new Date())
+  const [year, month] = yearMonth.split('-')
+
+  const sessionDir = path.join(projectGlobalPath, layer, 'sessions', year, month)
+  await fileHelper.ensureDir(sessionDir)
+
+  return sessionDir
+}
+
+/**
+ * Write log entry to today's session
+ *
+ * @param {string} projectGlobalPath - Global project path
+ * @param {string} layer - Layer (planning/progress/memory)
+ * @param {Object} entry - Log entry to write
+ * @param {string} filename - Optional custom filename (defaults to YYYY-MM-DD.jsonl)
+ * @returns {Promise<void>}
+ */
+async function writeToSession(projectGlobalPath, layer, entry, filename = null) {
+  await ensureTodaySessionDir(projectGlobalPath, layer)
+
+  const filePath = getTodaySessionFilePath(projectGlobalPath, layer, filename)
+
+  // Add timestamp if not present
+  if (!entry.ts && !entry.timestamp) {
+    entry.ts = dateHelper.getTimestamp()
+  }
+
+  await jsonlHelper.appendJsonLine(filePath, entry)
+}
+
+/**
+ * Read today's session logs
+ *
+ * @param {string} projectGlobalPath - Global project path
+ * @param {string} layer - Layer (planning/progress/memory)
+ * @param {string} filename - Optional custom filename
+ * @returns {Promise<Array<Object>>} - Array of log entries
+ */
+async function readTodaySession(projectGlobalPath, layer, filename = null) {
+  const filePath = getTodaySessionFilePath(projectGlobalPath, layer, filename)
+  return await jsonlHelper.readJsonLines(filePath)
+}
+
+/**
+ * Read session logs for a date range
+ *
+ * @param {string} projectGlobalPath - Global project path
+ * @param {string} layer - Layer (planning/progress/memory)
+ * @param {number} daysBack - Number of days to look back
+ * @returns {Promise<Array<Object>>} - Array of all log entries
+ */
+async function readRecentSessions(projectGlobalPath, layer, daysBack = 7) {
+  const fromDate = dateHelper.getDaysAgo(daysBack)
+  const toDate = new Date()
+
+  const dates = dateHelper.getDateRange(fromDate, toDate)
+  const allEntries = []
+
+  for (const date of dates) {
+    const yearMonth = dateHelper.formatMonth(date)
+    const dateKey = dateHelper.getDateKey(date)
+    const [year, month] = yearMonth.split('-')
+
+    const filePath = path.join(
+      projectGlobalPath,
+      layer,
+      'sessions',
+      year,
+      month,
+      `${dateKey}.jsonl`
+    )
+
+    const entries = await jsonlHelper.readJsonLines(filePath)
+    allEntries.push(...entries)
+  }
+
+  return allEntries
+}
+
+/**
+ * Get session statistics for a layer
+ *
+ * @param {string} projectGlobalPath - Global project path
+ * @param {string} layer - Layer (planning/progress/memory)
+ * @param {number} daysBack - Number of days to analyze
+ * @returns {Promise<Object>} - Statistics object
+ */
+async function getSessionStats(projectGlobalPath, layer, daysBack = 30) {
+  const entries = await readRecentSessions(projectGlobalPath, layer, daysBack)
+
+  // Group by type
+  const byType = {}
+  for (const entry of entries) {
+    const type = entry.type || 'unknown'
+    byType[type] = (byType[type] || 0) + 1
+  }
+
+  // Group by date
+  const byDate = {}
+  for (const entry of entries) {
+    const timestamp = entry.ts || entry.timestamp
+    if (timestamp) {
+      const date = dateHelper.getDateKey(new Date(timestamp))
+      byDate[date] = (byDate[date] || 0) + 1
+    }
+  }
+
+  return {
+    totalEntries: entries.length,
+    byType,
+    byDate,
+    activeDays: Object.keys(byDate).length,
+    averagePerDay: entries.length / Math.max(daysBack, 1),
+  }
+}
+
+/**
+ * Archive old session data (move sessions older than N days)
+ *
+ * @param {string} projectGlobalPath - Global project path
+ * @param {string} layer - Layer (planning/progress/memory)
+ * @param {number} daysToKeep - Keep sessions newer than this (default: 30)
+ * @returns {Promise<Object>} - Archive result
+ */
+async function archiveOldSessions(projectGlobalPath, layer, daysToKeep = 30) {
+  const cutoffDate = dateHelper.getDaysAgo(daysToKeep)
+  const archiveDir = path.join(projectGlobalPath, layer, 'archive')
+  await fileHelper.ensureDir(archiveDir)
+
+  const sessionsDir = path.join(projectGlobalPath, layer, 'sessions')
+
+  // Find all session files older than cutoff
+  const archived = []
+  const errors = []
+
+  try {
+    const years = await fileHelper.listFiles(sessionsDir, { dirsOnly: true })
+
+    for (const year of years) {
+      const yearPath = path.join(sessionsDir, year)
+      const months = await fileHelper.listFiles(yearPath, { dirsOnly: true })
+
+      for (const month of months) {
+        const monthPath = path.join(yearPath, month)
+        const sessionFiles = await fileHelper.listFiles(monthPath, { filesOnly: true })
+
+        for (const filename of sessionFiles) {
+          // Parse date from filename (YYYY-MM-DD.jsonl)
+          const dateMatch = filename.match(/(\d{4}-\d{2}-\d{2})/)
+          if (!dateMatch) continue
+
+          const sessionDate = new Date(dateMatch[1])
+          if (sessionDate < cutoffDate) {
+            const sourcePath = path.join(monthPath, filename)
+            const destPath = path.join(archiveDir, filename)
+
+            try {
+              await fileHelper.moveFile(sourcePath, destPath)
+              archived.push(filename)
+            } catch (error) {
+              errors.push({ filename, error: error.message })
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    // Sessions directory might not exist yet
+  }
+
+  return {
+    archived: archived.length,
+    files: archived,
+    errors,
+  }
+}
+
+/**
+ * Clean empty session directories
+ *
+ * @param {string} projectGlobalPath - Global project path
+ * @param {string} layer - Layer (planning/progress/memory)
+ * @returns {Promise<number>} - Number of directories removed
+ */
+async function cleanEmptySessionDirs(projectGlobalPath, layer) {
+  const sessionsDir = path.join(projectGlobalPath, layer, 'sessions')
+  let cleaned = 0
+
+  try {
+    const years = await fileHelper.listFiles(sessionsDir, { dirsOnly: true })
+
+    for (const year of years) {
+      const yearPath = path.join(sessionsDir, year)
+      const months = await fileHelper.listFiles(yearPath, { dirsOnly: true })
+
+      for (const month of months) {
+        const monthPath = path.join(yearPath, month)
+        const files = await fileHelper.listFiles(monthPath)
+
+        if (files.length === 0) {
+          await fileHelper.deleteDir(monthPath)
+          cleaned++
+        }
+      }
+
+      // Check if year directory is now empty
+      const remainingMonths = await fileHelper.listFiles(yearPath, { dirsOnly: true })
+      if (remainingMonths.length === 0) {
+        await fileHelper.deleteDir(yearPath)
+        cleaned++
+      }
+    }
+  } catch (error) {
+    // Sessions directory might not exist
+  }
+
+  return cleaned
+}
+
+module.exports = {
+  getTodaySessionFilePath,
+  ensureTodaySessionDir,
+  writeToSession,
+  readTodaySession,
+  readRecentSessions,
+  getSessionStats,
+  archiveOldSessions,
+  cleanEmptySessionDirs,
+}

package/core/{version.js → utils/version.js}

@@ -24,7 +24,7 @@ function getVersion() {
   }
 
   try {
-    const packageJsonPath = path.join(__dirname, '..', 'package.json')
+    const packageJsonPath = path.join(__dirname, '..', '..', 'package.json')
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
     cachedVersion = packageJson.version
     cachedPackageJson = packageJson

package/package.json

@@ -1,18 +1,16 @@
 {
   "name": "prjct-cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.js",
   "bin": {
-    "prjct": "./bin/prjct"
+    "prjct": "bin/prjct"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
   "scripts": {
-    "postinstall": "node scripts/post-install.js",
-    "preuninstall": "node scripts/preuninstall.js",
     "install-global": "./scripts/install.sh",
     "test": "echo 'No tests configured'",
     "validate": "node scripts/validate-commands.js",
@@ -41,13 +39,12 @@
   "license": "MIT",
   "dependencies": {
     "chalk": "^4.1.2",
-    "commander": "^11.0.0",
-    "ora": "^5.4.1",
     "prompts": "^2.4.2"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.8",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-n": "^16.6.2",
@@ -58,7 +55,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jlopezlira/prjct-cli"
+    "url": "git+https://github.com/jlopezlira/prjct-cli.git"
   },
   "bugs": {
     "url": "https://github.com/jlopezlira/prjct-cli/issues"
@@ -72,9 +69,6 @@
     "core/",
     "templates/",
     "scripts/install.sh",
-    "scripts/verify-installation.sh",
-    "scripts/post-install.js",
-    "scripts/preuninstall.js",
     "LICENSE",
     "README.md",
     "CHANGELOG.md",
@@ -82,8 +76,6 @@
   ],
   "trustedDependencies": [
     "chalk",
-    "commander",
-    "ora",
     "prompts"
   ]
 }

package/templates/agents/AGENTS.md

@@ -8,6 +8,74 @@ AI assistant guidance for **prjct-cli** - developer momentum tool for solo build
 
 **IS** frictionless progress tracking. Talk naturally, ship features, celebrate wins.
 
+---
+
+## Dynamic Agent Generation
+
+**YOU decide** what specialists to generate based on project analysis. No predetermined lists.
+
+### When to Generate Agents
+
+From commands that analyze the project:
+
+- `/p:sync` - Sync and generate agents
+- `/p:init` - Initialize with existing code
+- `/p:architect` - After generating project plan
+
+### How to Generate
+
+```javascript
+const generator = new AgentGenerator(projectId)
+
+await generator.generateDynamicAgent('agent-name', {
+  role: 'Clear Role Description',
+  expertise: 'Specific technologies, versions, tools',
+  responsibilities: 'What they handle in this project',
+  projectContext: {
+    /* optional context */
+  },
+})
+```
+
+### Example Usage
+
+**1. Read the analysis first:**
+
+```javascript
+// Read analysis/repo-summary.md to understand the stack
+const analysis = await readAnalysis('analysis/repo-summary.md')
+```
+
+**2. Generate specialists for technologies YOU find:**
+
+```javascript
+// For EACH major technology found in the analysis, create a specialist
+// Use descriptive names and specific details from the analysis
+
+await generator.generateDynamicAgent('descriptive-name', {
+  role: 'Clear role based on what you found',
+  expertise: 'Specific versions, frameworks, tools from analysis',
+  responsibilities: 'What this agent handles in THIS specific project',
+  projectContext: {
+    /* any relevant context from analysis */
+  },
+})
+```
+
+**You decide everything** - read the analysis, understand the stack, generate appropriate specialists. No predetermined lists, no assumptions, no limitations.
+
+### Guidelines
+
+1. **Read analysis** - Understand full stack from analysis/repo-summary.md
+2. **Create specialists** - For each major technology found
+3. **Name descriptively** - `go-backend` not `be`, `vuejs-frontend` not `fe`
+4. **Be specific** - Include versions, frameworks, tools
+5. **No predetermined list** - ANY stack works (Elixir, Phoenix, Svelte, etc.)
+6. **Follow project plan** - Only generate agents for technologies found in project plan and related to your role
+7. **Best practices** - Allways use best practices for your role
+
+---
+
 ## Talk Naturally
 
 **Zero memorization** - just describe what you want!
@@ -15,14 +83,14 @@ AI assistant guidance for **prjct-cli** - developer momentum tool for solo build
 Works in **any language** via semantic understanding.
 
 **Examples:**
+
 ```
 Start working:
 → "I want to build the login page"
-→ "Voy a hacer el dashboard"
 → Command: /p:now
 
 Finished:
-→ "I'm done" | "terminé" | "completed"
+→ "I'm done" | "completed"
 → Command: /p:done
 
 Ship:
@@ -31,12 +99,14 @@ Ship:
 ```
 
 **Both work:**
+
 - Natural: "I want to start building auth"
 - Direct: `/p:now "building auth"`
 
 ## Architecture
 
 **Global**: `~/.prjct-cli/projects/{id}/`
+
 ```
 core/        # now.md, next.md, context.md
 progress/    # shipped.md, metrics.md
@@ -57,32 +127,34 @@ memory/      # context.jsonl
 
 **💡 Tip**: `/p:help` for interactive guide
 
-| Command | Say This | Action |
-|---------|----------|--------|
-| `/p:help` | "help" | Interactive guide |
-| `/p:init` | - | Create structure |
-| `/p:now [task]` | "start [task]" | Set current task |
-| `/p:done` | "I'm done" | Complete & next |
-| `/p:ship <feature>` | "ship [feature]" | Celebrate win |
-| `/p:next` | "what's next?" | Show queue |
-| `/p:idea <text>` | "idea about [x]" | Capture ideas |
-| `/p:recap` | "show progress" | Overview |
-| `/p:progress [period]` | "how am I doing?" | Metrics |
-| `/p:stuck <issue>` | "I'm stuck" | Get help |
-| `/p:context` | "show context" | Display state |
-| `/p:analyze` | "analyze repo" | Generate summary |
-| `/p:design` | "design [x]" | Generate specs |
-| `/p:cleanup` | "clean up" | Remove dead code |
+| Command                | Say This          | Action            |
+| ---------------------- | ----------------- | ----------------- |
+| `/p:help`              | "help"            | Interactive guide |
+| `/p:init`              | -                 | Create structure  |
+| `/p:now [task]`        | "start [task]"    | Set current task  |
+| `/p:done`              | "I'm done"        | Complete & next   |
+| `/p:ship <feature>`    | "ship [feature]"  | Celebrate win     |
+| `/p:next`              | "what's next?"    | Show queue        |
+| `/p:idea <text>`       | "idea about [x]"  | Capture ideas     |
+| `/p:recap`             | "show progress"   | Overview          |
+| `/p:progress [period]` | "how am I doing?" | Metrics           |
+| `/p:stuck <issue>`     | "I'm stuck"       | Get help          |
+| `/p:context`           | "show context"    | Display state     |
+| `/p:analyze`           | "analyze repo"    | Generate summary  |
+| `/p:design`            | "design [x]"      | Generate specs    |
+| `/p:cleanup`           | "clean up"        | Remove dead code  |
 
 ## How It Works
 
 **Natural conversation:**
+
 - Detect intent
 - Map to command
 - Respond with options
 - Suggest next steps
 
 **Every response:**
+
 - What you did
 - Natural options
 - Command alternatives
@@ -93,15 +165,15 @@ memory/      # context.jsonl
 
 Semantic understanding, not pattern matching.
 
-| Intent | Command | Examples |
-|--------|---------|----------|
-| Start task | `/p:now` | "work on X", "starting API", "voy a hacer X" |
-| Finish | `/p:done` | "done", "finished", "terminé", "listo" |
-| Ship | `/p:ship` | "ship this", "deploy X", "it's ready" |
-| Idea | `/p:idea` | "I have an idea", "what if we..." |
-| Progress | `/p:recap` | "show progress", "how am I doing" |
-| Stuck | `/p:stuck` | "I'm stuck", "help with X" |
-| Next | `/p:next` | "what's next", "qué sigue" |
+| Intent     | Command    | Examples                                     |
+| ---------- | ---------- | -------------------------------------------- |
+| Start task | `/p:now`   | "work on X", "starting API", "voy a hacer X" |
+| Finish     | `/p:done`  | "done", "finished", "terminé", "listo"       |
+| Ship       | `/p:ship`  | "ship this", "deploy X", "it's ready"        |
+| Idea       | `/p:idea`  | "I have an idea", "what if we..."            |
+| Progress   | `/p:recap` | "show progress", "how am I doing"            |
+| Stuck      | `/p:stuck` | "I'm stuck", "help with X"                   |
+| Next       | `/p:next`  | "what's next", "qué sigue"                   |
 
 **Any language works** - if you understand intent, execute the command.
 
@@ -110,11 +182,13 @@ Semantic understanding, not pattern matching.
 **User:** "I want to start building the login page"
 
 **Your reasoning:**
+
 - Intent: Start working
 - Command: `/p:now`
 - Param: "building the login page"
 
 **Response:**
+
 ```
 💬 Understood: "start building the login page"
 ⚡ Executing: /p:now "building the login page"

package/templates/analysis/analyze.md

@@ -0,0 +1,84 @@
+---
+allowed-tools: [Read, Bash]
+description: 'Analyze codebase and generate comprehensive summary'
+---
+
+# /p:analyze
+
+## Instructions for Claude
+
+You are analyzing a codebase to generate a comprehensive summary. **NO predetermined patterns** - analyze based on what you actually find.
+
+## Your Task
+
+1. **Read project files** using the analyzer helpers:
+   - package.json, Cargo.toml, go.mod, requirements.txt, etc.
+   - Directory structure
+   - Git history and stats
+   - Key source files
+
+2. **Understand the stack** - DON'T use predetermined lists:
+   - What language(s) are used?
+   - What frameworks are used?
+   - What tools and libraries are important?
+   - What's the architecture?
+
+3. **Identify features** - based on actual code, not assumptions:
+   - What has been built?
+   - What's the current state?
+   - What patterns do you see?
+
+4. **Generate agents** - create specialists for THIS project:
+   - Read the stack you identified
+   - Create agents for each major technology
+   - Use descriptive names (e.g., 'express-backend', 'react-frontend', 'postgres-db')
+   - Include specific versions and tools found
+
+## Guidelines
+
+- **No assumptions** - only report what you find
+- **No predefined maps** - don't assume express = "REST API server"
+- **Read and understand** - look at actual code structure
+- **Any stack works** - Elixir, Rust, Go, Python, Ruby, whatever exists
+- **Be specific** - include versions, specific tools, actual patterns
+
+## Output Format
+
+Generate `analysis/repo-summary.md` with:
+
+```markdown
+# Project Analysis
+
+## Stack
+
+[What you found - languages, frameworks, tools with versions]
+
+## Architecture
+
+[How it's organized - based on actual structure]
+
+## Features
+
+[What has been built - based on code and git history]
+
+## Statistics
+
+- Total files: [count]
+- Contributors: [count]
+- Age: [age]
+- Last activity: [date]
+
+## Recommendations
+
+[What agents to generate, what's next, etc.]
+```
+
+## After Analysis
+
+1. Save summary to `analysis/repo-summary.md`
+2. Generate agents using `generator.generateDynamicAgent()`
+3. Report what was found
+
+---
+
+**Remember**: You decide EVERYTHING based on analysis. No if/else, no predetermined patterns.

package/templates/commands/analyze.md

@@ -1,11 +1,12 @@
 ---
 allowed-tools: [Read, Grep, Glob, Bash, TodoWrite]
-description: "Analyze repository and generate summary"
+description: 'Analyze repository and generate summary'
 ---
 
 # /p:analyze
 
 ## Flow
+
 1. Scan: project structure (Glob)
 2. Detect: technologies (package.json, requirements.txt, etc.)
 3. Analyze: architecture patterns
@@ -14,28 +15,34 @@ description: "Analyze repository and generate summary"
 6. Save: `analysis/repo-summary.md`
 
 ## Report Format
+
 ```markdown
 # Repository Analysis
 
 ## Overview
+
 - Type: {type}
 - Language: {lang}
 - Framework: {framework}
 
 ## Git Status
+
 - Last commit: {hash} "{msg}" ({time_ago})
 - Status: {clean/has_changes}
 
 ## Stack
+
 - Languages: {list}
 - Frameworks: {list}
 - Dependencies: {count}
 
 ## Architecture
+
 - Pattern: {pattern}
 - Entry points: {files}
 
 ## Recommended Agents
+
 Base (6): PM, UX, FE, BE, QA, Scribe
 Additional: {conditional_agents}
 
@@ -43,6 +50,7 @@ Generated: {timestamp}
 ```
 
 ## Response
+
 ```
 🔍 Analysis complete!
 
@@ -53,4 +61,3 @@ Stack: {stack}
 
 /p:roadmap | /p:now
 ```
-