prjct-cli 1.22.0 → 1.23.0

package/CHANGELOG.md

@@ -1,5 +1,152 @@
 # 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

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" "$@"