prjct-cli 0.54.0 → 0.54.2

package/CHANGELOG.md

@@ -1,12 +1,39 @@
 # Changelog
 
-## [0.54.0] - 2026-01-30
+## [0.54.2] - 2026-01-30
 
-### Features
+### Bug Fixes
+
+- LLM debe manejar los prompts, no el CLI - PRJ-149 (#84)
+
+
+## [0.55.3] - 2026-01-30
+
+### Fixed
+
+- **LLM debe manejar los prompts, no el CLI** (PRJ-149)
+  - Added `--json` flag to `prjct sync` for non-interactive mode
+  - CLI now detects non-TTY mode and outputs structured JSON instead of interactive prompts
+  - Updated `sync.md` template so LLM uses AskUserQuestion for confirmation
+  - Enables proper flow: `prjct sync --json` → show diff → AskUserQuestion → `prjct sync --yes`
+
+
+## [0.54.1] - 2026-01-30
+
+### Bug Fixes
+
+- Claude over-plans simple commands like p. sync - PRJ-148 (#83)
+
+
+## [0.55.2] - 2026-01-30
+
+### Fixed
 
-- Add showMetrics config option - PRJ-70 (#82)
-- Selective memory retrieval based on task relevance - PRJ-107 (#81)
-- Add session stats to p. stats command - PRJ-89 (#80)
+- **Claude over-plans simple commands** (PRJ-148)
+  - Added "⚡ FAST vs 🧠 SMART COMMANDS" section to CLAUDE.md
+  - FAST commands (sync, next, dash, pause, resume) now execute immediately without exploration/planning
+  - SMART commands (task, ship, bug, done) continue to use intelligent behavior
+  - Clarified that "Key Intelligence Rules" only apply to SMART commands
 
 
 ## [0.55.1] - 2026-01-30

package/core/commands/analysis.ts

@@ -213,6 +213,13 @@ export class AnalysisCommands extends PrjctCommandsBase {
    * Options:
    * - --preview: Show what would change without applying
    * - --yes: Skip confirmation prompt
+   * - --json: Output structured JSON for LLM consumption (non-interactive)
+   *
+   * When running in non-TTY mode (e.g., from an LLM), the CLI outputs
+   * structured JSON instead of interactive prompts. The LLM should:
+   * 1. Run `prjct sync --preview --json` to get diff data
+   * 2. Show diff to user and use AskUserQuestion for confirmation
+   * 3. Run `prjct sync --yes` if user confirms
    *
    * This eliminates the need for Claude to make 50+ individual tool calls.
    *
@@ -220,7 +227,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
    */
   async sync(
     projectPath: string = process.cwd(),
-    options: { aiTools?: string[]; preview?: boolean; yes?: boolean } = {}
+    options: { aiTools?: string[]; preview?: boolean; yes?: boolean; json?: boolean } = {}
   ): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
@@ -244,14 +251,23 @@ export class AnalysisCommands extends PrjctCommandsBase {
         // No existing file - first sync
       }
 
+      // Detect non-interactive mode (LLM or piped input)
+      const isNonInteractive = !process.stdin.isTTY || options.json
+
       // For preview mode or when we have existing content, show diff first
       if (existingContent && !options.yes) {
-        out.spin('Analyzing changes...')
+        if (!isNonInteractive) {
+          out.spin('Analyzing changes...')
+        }
 
         // Do a dry-run sync to see what would change
         const result = await syncService.sync(projectPath, { aiTools: options.aiTools })
 
         if (!result.success) {
+          if (isNonInteractive) {
+            console.log(JSON.stringify({ success: false, error: result.error || 'Sync failed' }))
+            return { success: false, error: result.error }
+          }
           out.fail(result.error || 'Sync failed')
           return { success: false, error: result.error }
         }
@@ -267,14 +283,64 @@ export class AnalysisCommands extends PrjctCommandsBase {
         // Generate diff
         const diff = generateSyncDiff(existingContent, newContent)
 
-        out.stop()
+        if (!isNonInteractive) {
+          out.stop()
+        }
 
         if (!diff.hasChanges) {
+          if (isNonInteractive) {
+            console.log(
+              JSON.stringify({
+                success: true,
+                action: 'no_changes',
+                message: 'No changes detected (context is up to date)',
+              })
+            )
+            return { success: true, message: 'No changes' }
+          }
           out.done('No changes detected (context is up to date)')
           return { success: true, message: 'No changes' }
         }
 
-        // Show diff preview
+        // Non-interactive mode: return JSON for LLM to handle
+        if (isNonInteractive) {
+          // Build a plain-text diff summary for LLM to show user
+          const diffSummary = {
+            added: diff.added.map((s) => ({ name: s.name, lineCount: s.lineCount })),
+            modified: diff.modified.map((s) => ({ name: s.name, lineCount: s.lineCount })),
+            removed: diff.removed.map((s) => ({ name: s.name, lineCount: s.lineCount })),
+            preserved: diff.preserved,
+            tokensBefore: diff.tokensBefore,
+            tokensAfter: diff.tokensAfter,
+            tokenDelta: diff.tokenDelta,
+          }
+
+          console.log(
+            JSON.stringify({
+              success: true,
+              action: 'confirm_required',
+              message: 'Changes detected. Confirmation required to apply.',
+              diff: diffSummary,
+              fullDiff: options.preview
+                ? {
+                    added: diff.added,
+                    modified: diff.modified,
+                    removed: diff.removed,
+                  }
+                : undefined,
+              hint: 'Run `prjct sync --yes` to apply changes',
+            })
+          )
+
+          return {
+            success: true,
+            isPreview: true,
+            diff,
+            message: 'Preview complete (awaiting confirmation)',
+          }
+        }
+
+        // Show diff preview (interactive mode)
         console.log(formatDiffPreview(diff))
 
         // Preview-only mode - don't apply
@@ -287,7 +353,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
           }
         }
 
-        // Interactive confirmation
+        // Interactive confirmation (TTY mode only)
         const response = await prompts({
           type: 'select',
           name: 'action',

package/core/commands/commands.ts

@@ -184,7 +184,7 @@ class PrjctCommands {
 
   async sync(
     projectPath: string = process.cwd(),
-    options: { aiTools?: string[] } = {}
+    options: { aiTools?: string[]; preview?: boolean; yes?: boolean; json?: boolean } = {}
   ): Promise<CommandResult> {
     return this.analysis.sync(projectPath, options)
   }

package/core/index.ts

@@ -126,6 +126,9 @@ async function main(): Promise<void> {
         sync: () =>
           commands.sync(process.cwd(), {
             aiTools: options.agents ? String(options.agents).split(',') : undefined,
+            preview: options.preview === true,
+            yes: options.yes === true,
+            json: options.json === true,
           }),
         start: () => commands.start(),
         // Context (for Claude templates)

package/dist/bin/prjct.mjs

@@ -16998,6 +16998,13 @@ var init_analysis2 = __esm({
        * Options:
        * - --preview: Show what would change without applying
        * - --yes: Skip confirmation prompt
+       * - --json: Output structured JSON for LLM consumption (non-interactive)
+       *
+       * When running in non-TTY mode (e.g., from an LLM), the CLI outputs
+       * structured JSON instead of interactive prompts. The LLM should:
+       * 1. Run `prjct sync --preview --json` to get diff data
+       * 2. Show diff to user and use AskUserQuestion for confirmation
+       * 3. Run `prjct sync --yes` if user confirms
        *
        * This eliminates the need for Claude to make 50+ individual tool calls.
        *
@@ -17020,10 +17027,17 @@ var init_analysis2 = __esm({
             existingContent = await fs34.readFile(claudeMdPath, "utf-8");
           } catch {
           }
+          const isNonInteractive = !process.stdin.isTTY || options.json;
           if (existingContent && !options.yes) {
-            output_default.spin("Analyzing changes...");
+            if (!isNonInteractive) {
+              output_default.spin("Analyzing changes...");
+            }
             const result2 = await syncService.sync(projectPath, { aiTools: options.aiTools });
             if (!result2.success) {
+              if (isNonInteractive) {
+                console.log(JSON.stringify({ success: false, error: result2.error || "Sync failed" }));
+                return { success: false, error: result2.error };
+              }
               output_default.fail(result2.error || "Sync failed");
               return { success: false, error: result2.error };
             }
@@ -17034,11 +17048,54 @@ var init_analysis2 = __esm({
               newContent = "";
             }
             const diff = generateSyncDiff(existingContent, newContent);
-            output_default.stop();
+            if (!isNonInteractive) {
+              output_default.stop();
+            }
             if (!diff.hasChanges) {
+              if (isNonInteractive) {
+                console.log(
+                  JSON.stringify({
+                    success: true,
+                    action: "no_changes",
+                    message: "No changes detected (context is up to date)"
+                  })
+                );
+                return { success: true, message: "No changes" };
+              }
               output_default.done("No changes detected (context is up to date)");
               return { success: true, message: "No changes" };
             }
+            if (isNonInteractive) {
+              const diffSummary = {
+                added: diff.added.map((s) => ({ name: s.name, lineCount: s.lineCount })),
+                modified: diff.modified.map((s) => ({ name: s.name, lineCount: s.lineCount })),
+                removed: diff.removed.map((s) => ({ name: s.name, lineCount: s.lineCount })),
+                preserved: diff.preserved,
+                tokensBefore: diff.tokensBefore,
+                tokensAfter: diff.tokensAfter,
+                tokenDelta: diff.tokenDelta
+              };
+              console.log(
+                JSON.stringify({
+                  success: true,
+                  action: "confirm_required",
+                  message: "Changes detected. Confirmation required to apply.",
+                  diff: diffSummary,
+                  fullDiff: options.preview ? {
+                    added: diff.added,
+                    modified: diff.modified,
+                    removed: diff.removed
+                  } : void 0,
+                  hint: "Run `prjct sync --yes` to apply changes"
+                })
+              );
+              return {
+                success: true,
+                isPreview: true,
+                diff,
+                message: "Preview complete (awaiting confirmation)"
+              };
+            }
             console.log(formatDiffPreview(diff));
             if (options.preview) {
               return {
@@ -25016,7 +25073,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.54.0",
+      version: "0.54.2",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -25201,7 +25258,10 @@ Use 'prjct --help' to see available commands.`);
         history: /* @__PURE__ */ __name(() => commands.history(), "history"),
         // Setup
         sync: /* @__PURE__ */ __name(() => commands.sync(process.cwd(), {
-          aiTools: options.agents ? String(options.agents).split(",") : void 0
+          aiTools: options.agents ? String(options.agents).split(",") : void 0,
+          preview: options.preview === true,
+          yes: options.yes === true,
+          json: options.json === true
         }), "sync"),
         start: /* @__PURE__ */ __name(() => commands.start(), "start"),
         // Context (for Claude templates)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.54.0",
+  "version": "0.54.2",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {

package/templates/commands/sync.md

@@ -1,14 +1,79 @@
 ---
-allowed-tools: [Bash, Read, Write]
+allowed-tools: [Bash, Read, Write, AskUserQuestion]
 ---
 
 # p. sync
 
+## Step 1: Run sync with JSON output
+
+```bash
+prjct sync --json
+```
+
+Parse the JSON output to determine next action.
+
+## Step 2: Handle response
+
+**If `action: "no_changes"`:**
+```
+Output: "✅ Context is up to date"
+```
+
+**If `action: "confirm_required"`:**
+
+Show the diff summary to the user:
+
+```
+📋 Changes to context files:
+
++ Added: {list added sections}
+~ Modified: {list modified sections}
+- Removed: {list removed sections}
+
+Tokens: {tokensBefore} → {tokensAfter} ({tokenDelta})
+```
+
+Then ask for confirmation:
+
+```
+AskUserQuestion:
+  question: "Apply these context changes?"
+  header: "Sync"
+  options:
+    - label: "Yes, apply changes"
+      description: "Update context files with the changes shown above"
+    - label: "No, cancel"
+      description: "Keep existing context files unchanged"
+    - label: "Show full diff"
+      description: "See detailed before/after for each section"
+```
+
+## Step 3: Apply based on response
+
+**If "Yes, apply changes":**
+```bash
+prjct sync --yes
+```
+
+**If "No, cancel":**
+```
+Output: "✅ Sync cancelled"
+```
+
+**If "Show full diff":**
+- Run `prjct sync --preview --json` to get full diff details
+- Display the full diff to user
+- Ask again with Yes/No options only
+
+## First sync (no existing files)
+
+When there's no existing context, the CLI will apply changes directly:
+
 ```bash
-prjct sync
+prjct sync --json
 ```
 
-CLI handles: git analysis, context generation, agents, skills.
+This returns success without needing confirmation.
 
 ## Linear Sync (when enabled)
 
@@ -21,8 +86,6 @@ IF integrations.linear.enabled:
   RUN: bun $PRJCT_CLI/core/cli/linear.ts --project {projectId} sync
 
   # Result stored in {globalPath}/storage/issues.json
-  # Contains all assigned issues from Linear
-
   OUTPUT: "Linear: {fetched} issues synced"
 ```
 
@@ -35,7 +98,8 @@ If `.cursor/` exists but `.cursor/rules/prjct.mdc` is missing:
 4. Copy commands: `{npmRoot}/prjct-cli/templates/cursor/p.md` → `.cursor/commands/p.md`
 5. Report: "Cursor routers regenerated"
 
-**Output**:
+## Output
+
 ```
 ✅ Synced: {projectName}
 

package/templates/global/CLAUDE.md

@@ -16,6 +16,50 @@ p. ship X   → templates/commands/ship.md
 
 ---
 
+## ⚡ FAST vs 🧠 SMART COMMANDS (CRITICAL)
+
+**Some commands just run a CLI. Others need intelligence. Know the difference.**
+
+### ⚡ FAST COMMANDS (Execute Immediately - NO planning, NO exploration)
+
+| Command | Action | Time |
+|---------|--------|------|
+| `p. sync` | Run `prjct sync` | <5s |
+| `p. next` | Run `prjct next` | <2s |
+| `p. dash` | Run `prjct dash` | <2s |
+| `p. pause` | Run `prjct pause` | <2s |
+| `p. resume` | Run `prjct resume` | <2s |
+
+**For these commands:**
+```
+1. Read template
+2. Run the CLI command shown
+3. Done
+```
+
+**⛔ DO NOT:** explore codebase, create plans, ask questions, read project files
+
+### 🧠 SMART COMMANDS (Require intelligence)
+
+| Command | Why it needs intelligence |
+|---------|--------------------------|
+| `p. task` | Must explore codebase, break down work |
+| `p. ship` | Must validate changes, create PR |
+| `p. bug` | Must classify severity, find affected files |
+| `p. done` | Must verify completion, update state |
+
+**For these commands:** Follow the full INTELLIGENT BEHAVIOR rules below.
+
+### Decision Rule
+```
+IF template just says "run CLI command":
+  → Execute immediately, no planning
+ELSE:
+  → Use intelligent behavior (explore, ask, plan)
+```
+
+---
+
 ## ⛔ CRITICAL RULES - READ BEFORE EVERY COMMAND
 
 ### 0. FOLLOW TEMPLATES STEP BY STEP (NON-NEGOTIABLE)
@@ -264,13 +308,15 @@ User Action → Storage (JSON) → Context (MD) → Sync Events
 4. Update CHANGELOG
 5. Create git tag
 
-### Key Intelligence Rules
+### Key Intelligence Rules (For 🧠 SMART commands only)
 - **Read before write** - Always read existing files before modifying
 - **Explore before coding** - Use Task(Explore) to understand codebase
 - **Ask when uncertain** - Use AskUserQuestion to clarify
-- **Adapt templates** - Templates are guidance, not rigid scripts
 - **Log everything** - Append to memory/events.jsonl
 
+**⚠️ These rules apply ONLY to 🧠 SMART commands (task, ship, bug, done).**
+**⚡ FAST commands skip all of this - just run the CLI.**
+
 ---
 
 ## OUTPUT FORMAT