prjct-cli 0.4.8 → 0.5.0

package/core/commands.js

@@ -389,23 +389,9 @@ class PrjctCommands {
       const hasExistingCode = await this.detectExistingCode(projectPath)
 
       if (hasExistingCode) {
-        try {
-          console.log('🔍 Analyzing existing codebase...')
-          const analysisResult = await this.analyze({
-            sync: true,
-            silent: true,
-          }, projectPath)
-
-          if (analysisResult.success && analysisResult.syncResults) {
-            const sync = analysisResult.syncResults
-            analysisMessage = '\n\n📊 Analysis Complete:\n' +
-              `✅ Found ${analysisResult.analysis.commands.length} commands, ${analysisResult.analysis.features.length} features\n` +
-              (sync.tasksMarkedComplete > 0 ? `✅ Synced ${sync.tasksMarkedComplete} completed tasks\n` : '') +
-              (sync.featuresAdded > 0 ? `✅ Added ${sync.featuresAdded} features to shipped.md\n` : '')
-          }
-        } catch (error) {
-          console.error('[prjct] Analysis warning:', error.message)
-        }
+        // Instead of silently analyzing, prompt the AI agent to run /p:analyze workflow
+        analysisMessage = '\n\n📊 Existing codebase detected!\n' +
+          `\n💡 Run ${this.agentInfo.config.commandPrefix}analyze to analyze your project and sync tasks`
       }
 
       const displayPath = pathManager.getDisplayPath(globalPath)
@@ -2220,25 +2206,10 @@ ${diagram}
     try {
       await this.initializeAgent()
 
-      // Check if already configured
-      const editorsConfig = require('./editors-config')
-      const configExists = await editorsConfig.configExists()
-
-      if (configExists) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            'prjct is already set up!\n\nTo reconfigure editors: prjct setup',
-            'warning'
-          ),
-        }
-      }
-
       // ASCII Art
       const chalk = require('chalk')
       console.log('')
       console.log('')
-      console.log(chalk.bold.magenta('   (ﾉ◕ヮ◕)ﾉ*:･ﾟ✧'))
       console.log(chalk.bold.cyan('   ██████╗ ██████╗      ██╗ ██████╗████████╗'))
       console.log(chalk.bold.cyan('   ██╔══██╗██╔══██╗     ██║██╔════╝╚══██╔══╝'))
       console.log(chalk.bold.blue('   ██████╔╝██████╔╝     ██║██║        ██║'))
@@ -2277,8 +2248,8 @@ ${diagram}
       })
       console.log('')
 
-      // Interactive selection
-      const installResult = await commandInstaller.interactiveInstall(false)
+      // Interactive selection (allow uninstall = true)
+      const installResult = await commandInstaller.interactiveInstall(true)
 
       if (!installResult.success) {
         return {

package/core/editors-config.js

@@ -3,14 +3,14 @@ const path = require('path')
 const os = require('os')
 
 /**
- * EditorsConfig - Manages installed editors tracking configuration
+ * EditorsConfig - Manages Claude installation tracking
  *
- * Tracks which AI editors user has installed prjct commands to,
+ * Tracks prjct commands installation in Claude (Code + Desktop),
  * enabling automatic updates when npm package is updated.
  *
  * Config location: ~/.prjct-cli/config/installed-editors.json
  *
- * @version 0.4.2
+ * @version 0.5.0
  */
 class EditorsConfig {
   constructor() {
@@ -31,7 +31,7 @@ class EditorsConfig {
   }
 
   /**
-   * Load installed editors configuration
+   * Load installation configuration
    * @returns {Promise<Object|null>} Configuration object or null if not found
    */
   async loadConfig() {
@@ -48,21 +48,20 @@ class EditorsConfig {
   }
 
   /**
-   * Save installed editors configuration
-   * @param {string[]} editors - Array of editor keys (e.g., ['claude', 'cursor'])
-   * @param {Object} paths - Object mapping editor keys to installation paths
+   * Save installation configuration
    * @param {string} version - Current prjct-cli version
+   * @param {string} claudePath - Path to Claude commands directory
    * @returns {Promise<boolean>} Success status
    */
-  async saveConfig(editors, paths, version) {
+  async saveConfig(version, claudePath) {
     try {
       await this.ensureConfigDir()
 
       const config = {
         version,
-        editors,
+        editor: 'claude',
         lastInstall: new Date().toISOString(),
-        paths,
+        path: claudePath,
       }
 
       await fs.writeFile(
@@ -78,24 +77,6 @@ class EditorsConfig {
     }
   }
 
-  /**
-   * Get tracked editors from configuration
-   * @returns {Promise<string[]>} Array of editor keys
-   */
-  async getTrackedEditors() {
-    const config = await this.loadConfig()
-    return config ? config.editors : []
-  }
-
-  /**
-   * Get editor paths from configuration
-   * @returns {Promise<Object>} Object mapping editor keys to paths
-   */
-  async getEditorPaths() {
-    const config = await this.loadConfig()
-    return config ? config.paths : {}
-  }
-
   /**
    * Get last installed version
    * @returns {Promise<string|null>} Version string or null

package/core/git-integration.js

@@ -0,0 +1,401 @@
+const { execSync } = require('child_process')
+const fs = require('fs').promises
+
+/**
+ * GitIntegration - Git repository analysis and validation
+ *
+ * Provides git integration for prjct-cli to analyze repository state,
+ * validate user claims against actual commits, and track project progress.
+ *
+ * @version 0.5.0
+ */
+class GitIntegration {
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath
+  }
+
+  /**
+   * Check if current directory is a git repository
+   * @returns {Promise<boolean>} True if git repo exists
+   */
+  async isGitRepo() {
+    try {
+      execSync('git rev-parse --git-dir', {
+        cwd: this.projectPath,
+        stdio: 'ignore',
+      })
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get information about the last commit
+   * @returns {Promise<Object|null>} Commit info or null if no commits
+   */
+  async getLastCommit() {
+    if (!(await this.isGitRepo())) {
+      return null
+    }
+
+    try {
+      const output = execSync(
+        'git log -1 --format="%H|%s|%ar|%an"',
+        {
+          cwd: this.projectPath,
+          encoding: 'utf-8',
+        },
+      )
+
+      const [hash, message, timeAgo, author] = output.trim().split('|')
+
+      return {
+        hash: hash.substring(0, 7), // Short hash
+        fullHash: hash,
+        message,
+        timeAgo,
+        author,
+      }
+    } catch {
+      return null // No commits yet
+    }
+  }
+
+  /**
+   * Get working directory status
+   * @returns {Promise<Object|null>} Status info or null if not git repo
+   */
+  async getWorkingDirStatus() {
+    if (!(await this.isGitRepo())) {
+      return null
+    }
+
+    try {
+      const status = execSync('git status --porcelain', {
+        cwd: this.projectPath,
+        encoding: 'utf-8',
+      })
+
+      const lines = status.trim().split('\n').filter(Boolean)
+
+      const modified = lines.filter(
+        l => l.startsWith(' M') || l.startsWith('M'),
+      ).length
+      const added = lines.filter(
+        l => l.startsWith('A') || l.startsWith('??'),
+      ).length
+      const deleted = lines.filter(
+        l => l.startsWith(' D') || l.startsWith('D'),
+      ).length
+      const renamed = lines.filter(l => l.startsWith('R')).length
+
+      return {
+        modified,
+        added,
+        deleted,
+        renamed,
+        totalChanges: lines.length,
+        isClean: lines.length === 0,
+        files: lines.map(l => l.substring(3)), // Remove status prefix
+      }
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Get diff summary between HEAD and working directory
+   * @returns {Promise<Object|null>} Diff summary or null
+   */
+  async getDiffSummary() {
+    if (!(await this.isGitRepo())) {
+      return null
+    }
+
+    try {
+      const diff = execSync('git diff HEAD --name-only', {
+        cwd: this.projectPath,
+        encoding: 'utf-8',
+      })
+
+      const files = diff.trim().split('\n').filter(Boolean)
+
+      return {
+        files,
+        count: files.length,
+      }
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Get files changed since a specific time
+   * @param {Date|number} since - Timestamp or Date object
+   * @returns {Promise<Array>} Array of changed files
+   */
+  async getChangesSince(since) {
+    if (!(await this.isGitRepo())) {
+      return []
+    }
+
+    try {
+      const timestamp =
+        since instanceof Date ? since.toISOString() : new Date(since).toISOString()
+
+      const files = execSync(
+        `git log --since="${timestamp}" --name-only --pretty=format:`,
+        {
+          cwd: this.projectPath,
+          encoding: 'utf-8',
+        },
+      )
+
+      return [...new Set(files.trim().split('\n').filter(Boolean))]
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Validate user claim against git state
+   * @param {string} claim - User's claim (e.g., "login is complete")
+   * @returns {Promise<Object>} Validation result
+   */
+  async validateUserClaim(claim) {
+    if (!(await this.isGitRepo())) {
+      return {
+        valid: true,
+        warning: null,
+        note: 'Not a git repository - cannot validate against commits',
+      }
+    }
+
+    const lastCommit = await this.getLastCommit()
+    const workingStatus = await this.getWorkingDirStatus()
+
+    if (!lastCommit) {
+      return {
+        valid: true,
+        warning: null,
+        note: 'No commits yet - cannot validate',
+      }
+    }
+
+    // Extract keywords from claim
+    const keywords = this.extractKeywords(claim)
+    const completionClaimed = /complete|done|finished|ready|shipped/i.test(claim)
+
+    // Check if keywords appear in last commit
+    const inLastCommit = keywords.some(keyword =>
+      lastCommit.message.toLowerCase().includes(keyword),
+    )
+
+    // Check if there are uncommitted changes
+    const hasUncommittedChanges = !workingStatus.isClean
+
+    // Validation logic
+    if (completionClaimed && !inLastCommit && hasUncommittedChanges) {
+      return {
+        valid: false,
+        warning: `⚠️  Discrepancy detected: You claim "${claim}" but it's not in the last commit`,
+        details: {
+          lastCommit: lastCommit.message,
+          uncommittedFiles: workingStatus.totalChanges,
+          suggestion:
+            'Consider committing your changes if the work is truly complete',
+        },
+      }
+    }
+
+    if (completionClaimed && !inLastCommit && !hasUncommittedChanges) {
+      return {
+        valid: true,
+        warning: `ℹ️  Note: "${claim}" not mentioned in recent commits`,
+        details: {
+          lastCommit: lastCommit.message,
+          note: 'Work may have been completed in earlier commits',
+        },
+      }
+    }
+
+    return {
+      valid: true,
+      warning: null,
+      note: inLastCommit
+        ? `✅ Confirmed in last commit: "${lastCommit.message}"`
+        : null,
+    }
+  }
+
+  /**
+   * Extract meaningful keywords from a claim
+   * @param {string} claim - User's claim
+   * @returns {Array<string>} Extracted keywords
+   */
+  extractKeywords(claim) {
+    // Remove common words
+    const stopWords = new Set([
+      'the',
+      'is',
+      'are',
+      'was',
+      'were',
+      'a',
+      'an',
+      'and',
+      'or',
+      'but',
+      'in',
+      'on',
+      'at',
+      'to',
+      'for',
+      'of',
+      'with',
+      'by',
+      'from',
+      'up',
+      'about',
+      'into',
+      'through',
+      'during',
+      'before',
+      'after',
+      'above',
+      'below',
+      'between',
+      'under',
+      'complete',
+      'done',
+      'finished',
+      'ready',
+      'shipped',
+    ])
+
+    return claim
+      .toLowerCase()
+      .split(/\s+/)
+      .filter(word => word.length > 2 && !stopWords.has(word))
+  }
+
+  /**
+   * Get git statistics for analysis
+   * @returns {Promise<Object>} Git statistics
+   */
+  async getGitStats() {
+    if (!(await this.isGitRepo())) {
+      return {
+        isGitRepo: false,
+        hasCommits: false,
+        totalCommits: 0,
+        contributors: [],
+        lastCommit: null,
+        workingStatus: null,
+      }
+    }
+
+    try {
+      // Total commits
+      const totalCommits = parseInt(
+        execSync('git rev-list --count HEAD', {
+          cwd: this.projectPath,
+          encoding: 'utf-8',
+        }).trim(),
+      )
+
+      // Contributors
+      const contributorsOutput = execSync(
+        'git log --format="%an" | sort -u',
+        {
+          cwd: this.projectPath,
+          encoding: 'utf-8',
+        },
+      )
+      const contributors = contributorsOutput.trim().split('\n').filter(Boolean)
+
+      const lastCommit = await this.getLastCommit()
+      const workingStatus = await this.getWorkingDirStatus()
+
+      return {
+        isGitRepo: true,
+        hasCommits: totalCommits > 0,
+        totalCommits,
+        contributors,
+        lastCommit,
+        workingStatus,
+      }
+    } catch (error) {
+      return {
+        isGitRepo: true,
+        hasCommits: false,
+        totalCommits: 0,
+        contributors: [],
+        lastCommit: null,
+        workingStatus: null,
+        error: error.message,
+      }
+    }
+  }
+
+  /**
+   * Check if a specific feature/file is in git history
+   * @param {string} searchTerm - Term to search for
+   * @returns {Promise<boolean>} True if found in history
+   */
+  async isInGitHistory(searchTerm) {
+    if (!(await this.isGitRepo())) {
+      return false
+    }
+
+    try {
+      const result = execSync(
+        `git log --all --grep="${searchTerm}" --oneline`,
+        {
+          cwd: this.projectPath,
+          encoding: 'utf-8',
+        },
+      )
+
+      return result.trim().length > 0
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get branch information
+   * @returns {Promise<Object|null>} Branch info or null
+   */
+  async getBranchInfo() {
+    if (!(await this.isGitRepo())) {
+      return null
+    }
+
+    try {
+      const currentBranch = execSync('git branch --show-current', {
+        cwd: this.projectPath,
+        encoding: 'utf-8',
+      }).trim()
+
+      const allBranches = execSync('git branch --list', {
+        cwd: this.projectPath,
+        encoding: 'utf-8',
+      })
+        .trim()
+        .split('\n')
+        .map(b => b.trim().replace('* ', ''))
+
+      return {
+        current: currentBranch,
+        all: allBranches,
+        count: allBranches.length,
+      }
+    } catch {
+      return null
+    }
+  }
+}
+
+module.exports = new GitIntegration()

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prjct-cli",
-  "version": "0.4.8",
-  "description": "AI-integrated project management for indie hackers - works with Claude Code, Cursor, and Warp",
+  "version": "0.5.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"
@@ -25,13 +25,16 @@
     "website:install": "cd website && npm install"
   },
   "keywords": [
-    "project-management",
+    "claude-code",
+    "claude-desktop",
+    "developer-momentum",
     "indie-hacker",
+    "ship-fast",
     "ai-assistant",
-    "claude-code",
-    "cursor",
-    "warp",
-    "productivity"
+    "productivity",
+    "developer-tools",
+    "no-bs",
+    "focus"
   ],
   "author": "prjct.dev",
   "license": "MIT",

package/scripts/install.sh

@@ -99,7 +99,6 @@ clear
 # Clean header with Catppuccin colors
 echo ""
 echo ""
-echo -e "   ${BOLD}${CYAN}(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧${NC}"
 echo -e "   ${BOLD}${CYAN}██████╗ ██████╗      ██╗ ██████╗████████╗${NC}"
 echo -e "   ${BOLD}${CYAN}██╔══██╗██╔══██╗     ██║██╔════╝╚══██╔══╝${NC}"
 echo -e "   ${BOLD}${CYAN}██████╔╝██████╔╝     ██║██║        ██║${NC}"

package/templates/agents/be.template.md

@@ -0,0 +1,42 @@
+---
+name: p_agent_be
+description: Backend Engineer for [PROJECT_NAME]. Expert in [FRAMEWORK]. Triggers on: "backend", "API", "database", "server", "authentication", "microservice".
+tools: str_replace_editor, create_file, delete_file, find_files, list_dir, search_files, view_file, run_terminal_command
+model: opus
+color: yellow
+---
+
+You are a Senior Backend Engineer for **[PROJECT_NAME]**.
+
+## Project Context
+- **Stack**: [DETECTED_STACK]
+- **Architecture**: [DETECTED_PATTERN]
+- **Primary Language**: [PRIMARY_LANGUAGE]
+
+## Core Expertise
+- **API Design**: RESTful, GraphQL, efficient endpoints
+- **Database**: Schema design, queries, optimization
+- **Authentication**: JWT, OAuth, session management
+- **Architecture**: Clean code, SOLID principles, DRY
+- **Performance**: Caching, query optimization, scalability
+
+## NOT Your Expertise
+- Frontend UI implementation
+- DevOps infrastructure (defer to DevOps)
+- UX design decisions
+
+## Development Principles
+1. **SOLID Principles**: Single responsibility, dependency inversion
+2. **Security First**: Validate inputs, protect endpoints
+3. **Scalability**: Design for growth
+4. **Testing**: Unit tests, integration tests
+5. **Documentation**: Clear API docs
+
+## Focus Areas
+- API endpoints and business logic
+- Database schema and queries
+- Authentication and authorization
+- Data validation and error handling
+- Performance optimization
+
+Remember: You build the server layer. Collaborate with Frontend for API contracts and Security for hardening.

package/templates/agents/data.template.md

@@ -0,0 +1,41 @@
+---
+name: p_agent_data
+description: Data Science Engineer for [PROJECT_NAME]. Expert in ML, data analysis, and pipelines. Triggers on: "ML", "machine learning", "data", "model", "training", "analysis", "pipeline".
+tools: str_replace_editor, create_file, delete_file, find_files, list_dir, search_files, view_file, run_terminal_command
+model: opus
+color: teal
+---
+
+You are a Data Science Engineer for **[PROJECT_NAME]**.
+
+## Project Context
+- **Stack**: [DETECTED_STACK]
+- **Type**: [PROJECT_TYPE]
+
+## Core Expertise
+- **Machine Learning**: Model training, evaluation, deployment
+- **Data Pipelines**: ETL, data processing
+- **Analysis**: Statistical analysis, visualization
+- **Optimization**: Model performance, inference speed
+- **MLOps**: Model versioning, monitoring
+
+## NOT Your Expertise
+- Frontend UI implementation
+- Infrastructure (defer to DevOps)
+- Non-ML backend logic
+
+## Data Science Principles
+1. **Data Quality**: Garbage in, garbage out
+2. **Reproducibility**: Version everything
+3. **Validation**: Always validate models
+4. **Monitoring**: Track model performance
+5. **Ethics**: Consider bias and fairness
+
+## Focus Areas
+- Model development and training
+- Data preprocessing and feature engineering
+- Model evaluation and validation
+- Deployment and monitoring
+- Data visualization
+
+Remember: Models are only as good as the data and evaluation. Prioritize data quality and proper validation.