prjct-cli 1.21.0 → 1.23.0

package/CHANGELOG.md

@@ -1,10 +1,254 @@
 # Changelog
 
+## [1.23.0] - 2026-02-11
+
+### Features
+
+- compile and ship dist/ instead of raw TypeScript source (PRJ-294) (#168)
+- add outcome-to-memory auto-learning (PRJ-283) (#166)
+
+### Refactoring
+
+- consolidate core modules from 27 to 20 directories (PRJ-292) (#167)
+
+
+## [1.25.0] - 2026-02-10
+
+### Infrastructure
+
+- **Compile and ship dist/** (PRJ-294): Package no longer ships raw TypeScript source. Compiled, minified JavaScript with source maps instead.
+  - Rewrote `scripts/build.js` v3.0: produces minified ESM bundles via esbuild with source maps
+  - Bundled 127 template files into single `dist/templates.json` (408KB)
+  - Main CLI compiled to `dist/bin/prjct.mjs` (600KB minified), Linear CLI to `dist/cli/linear.mjs` (27KB)
+  - Package reduced from 1.1MB/480 files to 971KB/27 files
+  - All template consumers use bundle-first pattern via `getTemplateContent()` and `listTemplates()` helpers
+  - Dual-mode operation: dev mode (raw TS via bun) and production mode (compiled dist/) both work
+  - Updated `bin/prjct` shell script for dev vs production detection
+  - Updated 8 modules to use template bundle: command-installer, setup, setup-cursor, setup-windsurf, prompt-builder, sync-agent-gen, template-loader, bin/prjct.ts
+
+### Implementation Details
+
+Rewrote the build system to produce compiled JavaScript output instead of shipping raw TypeScript. The key innovation is the bundle-first pattern: `getTemplateContent()` tries the bundled JSON first, falls back to filesystem for dev mode. This unified API replaced scattered `fs.readFile` calls across 8 modules. The shell script (`bin/prjct`) detects dev vs production by checking if `prjct.ts` exists.
+
+### Learnings
+
+- Bundle-first pattern (try JSON bundle, fall back to filesystem) provides clean dev/prod abstraction
+- ESM requires banner injection for `__dirname`/`__filename` since they don't exist in ESM scope
+- npm auto-includes `main` field target in package even when not in `files` array
+- `packages: 'external'` in esbuild avoids bundling node_modules into dist/
+- `keepNames: true` preserves function names despite minification, helpful for debugging
+
+### Test Plan
+
+#### For QA
+1. `npm pack` — verify tarball contains only dist/, bin/prjct, assets/, scripts, README, LICENSE, CHANGELOG
+2. `bun dist/bin/prjct.mjs version` — CLI runs from compiled output
+3. `bun dist/bin/prjct.mjs sync --json` — full sync works with bundled templates
+4. `prjct linear list` — linear CLI subprocess resolves correctly
+5. Verify `dist/templates.json` contains all 127 template files
+6. Dev mode: `bun bin/prjct.ts version` still runs raw TypeScript
+
+#### For Users
+**What changed:** Package is now smaller and ships compiled JavaScript instead of raw TypeScript source.
+**How to use:** No changes — all `prjct` commands work identically.
+**Breaking changes:** None
+
+## [1.24.0] - 2026-02-10
+
+### Refactor
+
+- **Consolidate core modules** (PRJ-292): Reduced `core/` from 27 to 20 directories by merging overlapping modules, splitting large files, and eliminating legacy duplicates
+  - Merged `bus/` + `events/` into `events/` (pub-sub.ts, sync-events.ts)
+  - Merged `ai-tools/` + `context-tools/` into `tools/` (ai/, context/ subdirs)
+  - Merged `plugin/` + `agents/` into `agentic/` (hooks, plugin-loader, plugin-registry, performance)
+  - Merged `wizard/` + `outcomes/` into `workflows/` (onboarding, outcome-analyzer/recorder/learner/storage)
+  - Absorbed `context/` into `agentic/` and `constants/` into `utils/`
+  - Split 4 large files (5400+ lines total):
+    - `memory-system.ts` (1547 → 279) into memory-stores.ts, pattern-store.ts, semantic-memories.ts
+    - `sync-service.ts` (1562 → 837) into sync-analyzer.ts, sync-agent-gen.ts
+    - `setup.ts` (1061 → 775) into setup-cursor.ts, setup-windsurf.ts
+    - `analysis.ts` (1274 → 850) into analysis-helpers.ts
+  - Eliminated legacy `fs-helpers.ts` (16 importers migrated to `file-helper.ts`)
+  - Removed all type re-exports, duplicated code, and backward-compat shims
+  - 84 files changed, +2638/-3182, tsc clean, 1057 tests pass
+
+### Implementation Details
+
+Large-scale module consolidation to reduce cognitive load and improve maintainability. Each merge followed the pattern: move files, update relative imports across all importers, clean barrel index.ts files, verify with tsc + tests. Used parallel background agents for independent file splits.
+
+Key patterns: CachedStore<T> abstract base class for disk-backed stores, standalone helper function extraction for large command classes, editor-specific code isolation (Cursor/Windsurf).
+
+### Learnings
+
+- Parallel agents work well for independent file splits (3 simultaneous splits completed successfully)
+- Pre-existing circular deps in commands<->services chain (3 cycles) — not introduced by this refactor
+- Known flaky test (intermittent timing issue) — passes on re-run
+
+### Test Plan
+
+#### For QA
+1. `npx tsc -p core/tsconfig.json --noEmit` — zero errors
+2. `bun test` — 1057 tests pass
+3. `prjct sync` in any project — works identically
+4. Deleted dirs don't exist: bus/, ai-tools/, context-tools/, plugin/, agents/, wizard/, outcomes/, context/, constants/
+5. New dirs exist: tools/ai/, tools/context/, workflows/, events/
+
+#### For Users
+**What changed:** Internal module reorganization only
+**Breaking changes:** None for CLI users. Internal import paths changed (affects contributors).
+
+## [1.23.0] - 2026-02-10
+
+### Features
+
+- **Outcome-to-memory auto-learning** (PRJ-283): Completed tasks automatically extract patterns and inject high-confidence learnings into semantic memory
+  - `OutcomeStorage`: Unified storage for feature/task outcomes extending StorageManager, with migration from shipped.json, aggregation, and markdown generation
+  - `OutcomeMemoryLearner`: Extracts file co-change, tech stack, architecture, gotcha, and workflow patterns from task history and feature outcomes
+  - Confidence-gated injection: Only patterns with 3+ occurrences are auto-injected into memory
+  - Deduplication: Updates existing `[auto-learned]` memories instead of creating duplicates
+  - Non-blocking sync integration: Auto-learning runs during `p. sync` as step 9c (errors caught, don't block sync)
+  - `p. learnings` command template for viewing auto-learned patterns by confidence level
+  - 37 new tests (26 learner + 11 storage), 1057 total
+
+### Implementation Details
+
+Bridges the outcomes system to semantic memory. Previously, patterns from completed tasks were only available in task history JSON. Now, recurring patterns are automatically extracted and injected into the memory system for cross-session knowledge transfer.
+
+**Data flow:** `taskHistory[]` + `FeatureOutcome[]` → pattern extraction → confidence scoring → `SemanticMemories` injection
+
+**Pattern categories:** file_cochange (files modified together), tech_stack (confirmed technologies), architecture (discovered patterns), estimation (variance tracking), workflow (what works/doesn't), gotcha (recurring issues)
+
+**New modules:**
+- `core/outcomes/outcome-storage.ts` — OutcomeStorage extending StorageManager with CRUD, migration, aggregation, markdown
+- `core/outcomes/outcome-learner.ts` — OutcomeMemoryLearner with pattern extraction and memory injection
+- `core/outcomes/index.ts` — Updated exports
+- `core/services/sync-service.ts` — Added autoLearnFromHistory() in sync flow
+- `templates/commands/learnings.md` — Template for `p. learnings` command
+- `core/__tests__/outcomes/outcome-learner.test.ts` — 26 tests
+- `core/__tests__/outcomes/outcome-storage.test.ts` — 11 tests
+
+### Learnings
+
+- `StorageManager<T>` base class provides consistent pattern for all JSON storage with SQLite backing, cache, MD generation, and event publishing
+- Non-critical sync steps should always wrap in try/catch to prevent blocking the main sync flow
+- biome pre-commit hook checks ALL files, not just staged — run `biome check --write` on all new files before committing
+
+### Test Plan
+
+#### For QA
+1. Run `p. sync` on a project with task history — verify auto-learning runs without errors
+2. Check memories.json for `[auto-learned]` entries after sync with 3+ recurring patterns
+3. Run `p. learnings` — verify patterns display grouped by confidence level
+4. Complete 3+ tasks with the same stackConfirmed values — verify auto-injection
+5. Verify sync works when no task history exists
+
+#### For Users
+**What changed:** Completed tasks now automatically extract patterns and inject high-confidence learnings into the memory system.
+**How to use:** Patterns accumulate automatically. Run `p. learnings` to see what the system has learned.
+**Breaking changes:** None
+
+## [1.22.0] - 2026-02-10
+
+### Features
+
+- add task-to-analysis feedback loop (PRJ-272) (#165)
+- add task history array with FIFO eviction (PRJ-281) (#164)
+
+
+## [1.22.0] - 2026-02-10
+
+### Features
+
+- **Task-to-analysis feedback loop** (PRJ-272): Tasks report discoveries back into analysis and agent generation
+  - TaskFeedbackSchema: stackConfirmed, patternsDiscovered, agentAccuracy (with rating enum), issuesEncountered
+  - Optional `feedback` field on TaskHistoryEntry for backward compatibility
+  - `getAggregatedFeedback()` consolidates patterns, stack confirmations, and issues across task history
+  - Recurring issues (2+ occurrences) automatically promoted to "known gotchas"
+  - Sync incorporates feedback: patterns populate analysis draft, gotchas become anti-patterns
+  - Agent generator injects "Recent Learnings" section into domain agents with patterns, gotchas, and accuracy notes
+  - Workflow `done()` accepts and passes feedback through to storage
+  - 22 new tests covering schema validation, persistence, aggregation, gotcha promotion, and backward compatibility (1020 total)
+
+### Implementation Details
+
+Closes the knowledge loop between task execution and project analysis. Previously, discoveries made during tasks were lost when sessions ended. Now, structured feedback persists in task history and feeds into the next sync cycle.
+
+**Data flow:** `p. done` (feedback captured) → `taskHistory[].feedback` → `p. sync` → `analysis.patterns` + `agents/*.md` "Recent Learnings"
+
+**Modified modules:**
+- `core/schemas/state.ts` — Added TaskFeedbackSchema, extended TaskHistoryEntrySchema with optional feedback field
+- `core/storage/state-storage.ts` — completeTask() accepts feedback, createTaskHistoryEntry() attaches it, getAggregatedFeedback() provides read-side API, toMarkdown() shows feedback in context
+- `core/commands/workflow.ts` — done() passes feedback through options to completeTask()
+- `core/services/sync-service.ts` — saveDraftAnalysis() loads aggregated feedback, injectFeedbackSection() adds learnings to agents
+- `core/services/agent-generator.ts` — generate() accepts TaskFeedbackContext, injectFeedbackSection() appends learnings to domain agents
+- `core/__tests__/storage/state-storage-feedback.test.ts` — 22 comprehensive tests
+
+### Learnings
+
+- **SyncService duplicates AgentGenerator:** Both have their own `generateDomainAgent()` — feedback injection needed in both places
+- **Write-Through pattern:** All state flows JSON → MD → Event; feedback follows the same pattern
+- **Backward compatibility via optional fields:** Adding `feedback?: TaskFeedback` to existing schema requires zero migration
+
+### Test Plan
+
+#### For QA
+1. Complete a task with `p. done` — verify feedback stored in `taskHistory[0].feedback`
+2. Complete multiple tasks with same issue — verify gotcha promotion (2+ occurrences)
+3. Run `p. sync` after tasks with feedback — verify analysis draft has patterns
+4. Run `p. sync` with agent regeneration — verify "Recent Learnings" in domain agents
+5. Complete task WITHOUT feedback — verify backward compatibility
+6. Run `bun test` — all 1020 tests pass
+
+#### For Users
+**What changed:** Task discoveries now persist and improve future agent context automatically.
+**How to use:** Automatic via `p. done` template. No user action required.
+**Breaking changes:** None.
+
 ## [1.21.0] - 2026-02-10
 
 ### Features
 
 - add semantic verification for analysis results (PRJ-270) (#163)
+- **Task history array** (PRJ-281): Replace single previousTask with bounded task history for pattern learning
+  - TaskHistoryEntry schema captures completed task metadata: title, classification, timestamps, subtasks, outcome, branch, Linear IDs
+  - Automatic history push on task completion with FIFO eviction (max 20 entries)
+  - Context injection: shows 3 recent same-type tasks when active, 5 recent when idle
+  - Accessor methods: getTaskHistory(), getMostRecentTask(), getTaskHistoryByType()
+  - Backward compatible: undefined taskHistory initializes as empty array
+  - Comprehensive test suite with 20 test cases (998 tests total pass)
+
+### Implementation Details
+
+Replaced single previousTask field with bounded task history array to enable pattern learning and cross-task context for AI agents. When tasks complete, metadata is automatically captured and stored with FIFO eviction.
+
+**Modified modules:**
+- `core/schemas/state.ts` — Added TaskHistoryEntrySchema with 12 fields, updated StateJsonSchema, exported TaskHistoryEntry type, updated DEFAULT_STATE
+- `core/storage/state-storage.ts` — Updated completeTask() to push history entries, added createTaskHistoryEntry() helper, added 3 accessor methods, updated toMarkdown() for context injection, updated getDefault()
+- `core/__tests__/storage/state-storage-history.test.ts` (468 lines) — 20 comprehensive tests covering push, eviction, backward compatibility, accessors, and context injection
+- `README.md` — Added Task History section with usage documentation
+- `CHANGELOG.md` — Documented task history feature
+
+### Learnings
+
+- **Schema-first design:** Define Zod schemas before implementation ensures type safety and validation at runtime
+- **Type assertions for extended properties:** Use `taskAny = task as any` to access properties not in CurrentTask schema (type, branch, parentDescription)
+- **Context injection in toMarkdown():** The state-storage toMarkdown() method is where context is generated, not context-builder.ts
+- **pathManager mocking for test isolation:** Mock getGlobalProjectPath, getStoragePath, getFilePath to use temp directories in tests
+- **FIFO over LRU:** Simpler implementation with predictable behavior for bounded history
+
+### Test Plan
+
+#### For QA
+1. Complete a task with `p. done` — verify taskHistory entry appears in state.json with all metadata fields
+2. Complete 25+ tasks — verify only 20 entries remain (oldest dropped)
+3. Start a bug task — verify context markdown shows recent bug tasks only (not features)
+4. Test with existing state.json missing taskHistory field — verify backward compatibility
+5. Verify accessor methods return correct data: getTaskHistory(), getMostRecentTask(), getTaskHistoryByType()
+
+#### For Users
+**What changed:** Completed tasks are now tracked in a history array (max 20) instead of only storing the last paused task
+**How to use:** No action needed — task history is automatic on `p. done`
+**Breaking changes:** None — fully backward compatible
 
 
 ## [1.20.0] - 2026-02-10

package/README.md

@@ -123,6 +123,47 @@ All agents share the same project storage, so you can switch between them freely
 | `p. linear` | - | Linear integration |
 | `p. github` | - | GitHub Issues integration |
 
+## Task History
+
+prjct automatically tracks your completed tasks to help AI agents learn from patterns and make better decisions across sessions.
+
+### How It Works
+
+When you complete a task (`p. done` / `/done`), prjct stores:
+- Task description and classification (feature, bug, improvement, chore)
+- Start and completion timestamps
+- Number of subtasks and their summaries
+- Git branch name and Linear issue ID (if linked)
+- PR URL (if shipped)
+
+This history is:
+- **Bounded**: Maximum 20 entries with FIFO (First-In-First-Out) eviction
+- **Contextual**: Filtered by task type when starting similar work
+- **Persistent**: Survives across sessions and agent types
+
+### Context Injection
+
+Task history is automatically injected into the AI agent's context:
+- When **starting a task**: Shows 3 most recent tasks of the same type (e.g., recent bug fixes when starting a new bug)
+- When **idle**: Shows 5 most recent tasks across all types
+- **Purpose**: Helps agents identify patterns, avoid repeating mistakes, and build on previous solutions
+
+### Accessor Methods (for developers)
+
+```typescript
+import { stateStorage } from './storage/state-storage'
+
+// Get full task history (max 20 entries, newest first)
+const history = await stateStorage.getTaskHistory(projectId)
+
+// Get most recent completed task
+const recent = await stateStorage.getMostRecentTask(projectId)
+
+// Get tasks by classification
+const bugs = await stateStorage.getTaskHistoryByType(projectId, 'bug')
+const features = await stateStorage.getTaskHistoryByType(projectId, 'feature')
+```
+
 ## CLI Commands
 
 ```bash

package/bin/prjct

@@ -47,7 +47,6 @@ ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 # This runs EVERY time prjct is called, ensuring setup even if postinstall failed
 ensure_setup() {
   CLAUDE_COMMANDS="$HOME/.claude/commands"
-  PMD_SRC="$ROOT_DIR/templates/commands/p.md"
   PMD_DEST="$CLAUDE_COMMANDS/p.md"
 
   # Create dir if needed
@@ -55,14 +54,22 @@ ensure_setup() {
     mkdir -p "$CLAUDE_COMMANDS" 2>/dev/null
   fi
 
-  # Copy p.md if source exists and dest doesn't OR dest is older
+  # Try source template first (dev mode), then extract from bundle (production)
+  PMD_SRC="$ROOT_DIR/templates/commands/p.md"
+  BUNDLE="$ROOT_DIR/dist/templates.json"
+
   if [ -f "$PMD_SRC" ]; then
-    if [ ! -f "$PMD_DEST" ]; then
-      cp "$PMD_SRC" "$PMD_DEST" 2>/dev/null
-    elif [ "$PMD_SRC" -nt "$PMD_DEST" ]; then
-      # Source is newer, update
+    # Dev mode: copy from source templates
+    if [ ! -f "$PMD_DEST" ] || [ "$PMD_SRC" -nt "$PMD_DEST" ]; then
       cp "$PMD_SRC" "$PMD_DEST" 2>/dev/null
     fi
+  elif [ -f "$BUNDLE" ] && [ ! -f "$PMD_DEST" ]; then
+    # Production: extract from bundle using node
+    node -e "
+      const b=JSON.parse(require('fs').readFileSync('$BUNDLE','utf8'));
+      const c=b['commands/p.md'];
+      if(c)require('fs').writeFileSync('$PMD_DEST',c);
+    " 2>/dev/null
   fi
 
   # Also ensure statusline (best effort)
@@ -110,22 +117,32 @@ check_node() {
   command -v node >/dev/null 2>&1
 }
 
-# Run with bun (native TypeScript)
+# Run with bun (native TypeScript in dev, compiled in production)
 run_with_bun() {
-  exec bun "$SCRIPT_DIR/prjct.ts" "$@"
+  # Dev mode: raw TypeScript is faster
+  if [ -f "$SCRIPT_DIR/prjct.ts" ]; then
+    exec bun "$SCRIPT_DIR/prjct.ts" "$@"
+  fi
+  # Production: use compiled dist
+  exec bun "$ROOT_DIR/dist/bin/prjct.mjs" "$@"
 }
 
 # Run with node (compiled JavaScript)
 run_with_node() {
   DIST_BIN="$ROOT_DIR/dist/bin/prjct.mjs"
 
-  # Check if compiled version exists
   if [ ! -f "$DIST_BIN" ]; then
-    echo "Building for Node.js (first run)..."
-    node "$ROOT_DIR/scripts/build.js" || {
-      echo "Error: Build failed. Please ensure you have write permissions."
+    # Dev mode: try to build
+    if [ -f "$ROOT_DIR/scripts/build.js" ] && [ -d "$ROOT_DIR/core" ]; then
+      echo "Building for Node.js (first run)..."
+      node "$ROOT_DIR/scripts/build.js" || {
+        echo "Error: Build failed. Run 'npm run build' manually."
+        exit 1
+      }
+    else
+      echo "Error: Compiled output not found. Run 'npm run build' first."
       exit 1
-    }
+    fi
   fi
 
   exec node "$DIST_BIN" "$@"