prjct-cli 1.22.0 → 1.24.0

package/CHANGELOG.md

@@ -1,5 +1,235 @@
 # Changelog
 
+## [1.24.0] - 2026-02-11
+
+### Features
+
+- implement daemon mode with IPC socket for near-zero startup (PRJ-302) (#170)
+
+### Bug Fixes
+
+- remove source shebang causing SyntaxError in compiled linear CLI (#169)
+
+
+## [1.24.1] - 2026-02-10
+
+### Bug Fixes
+
+- **Remove source shebangs from compiled entry points**: `core/daemon/entry.ts` and `core/cli/lint-meta-commentary.ts` had shebangs (`#!/usr/bin/env node`, `#!/usr/bin/env bun`) that caused dual shebangs in compiled `.mjs` output. Node.js only strips the first-line shebang, so the second became a SyntaxError. The build script's `banner` option is the single source of truth for shebang injection.
+
+## [1.24.0] - 2026-02-10
+
+### Features
+
+- **Daemon mode with IPC socket**: Background daemon process keeps CLI modules warm in memory. Commands are routed through a Unix domain socket using NDJSON protocol, achieving 1.6ms IPC roundtrip. Production startup drops from ~1060ms to ~220ms (4.8x speedup).
+- **Thin shim entry point**: Production build now uses a 1.6KB shim (`prjct.mjs`) that tries the daemon first, only loading the full 613KB core bundle (`prjct-core.mjs`) when the daemon is unavailable.
+- **Auto-start daemon**: First CLI invocation automatically spawns the daemon in background for future commands. 30-minute idle auto-shutdown.
+- **Daemon lifecycle commands**: `prjct daemon start|stop|status` for manual control. Supports `--foreground`, `--port=N`, `--no-http` flags.
+
+### Security
+
+- **Removed source maps from production build**: `.map` files previously embedded full `sourcesContent` including credential management code (`keychain.ts`, `project-credentials.ts`). Source maps are now completely removed from `dist/`.
+
+### Implementation Details
+
+Daemon mode with Unix socket IPC for near-zero CLI startup. The daemon pre-loads `PrjctCommands`, `CommandRegistry`, and storage caches once, then reuses them across invocations. The thin shim entry point avoids parsing the heavy core bundle when the daemon handles the command. ESM static imports are hoisted before any code runs, so all imports in `bin/prjct.ts` are now dynamic to enable the fast path.
+
+### Learnings
+
+- ESM hoists static imports — placing code before `import` statements doesn't help; all imports must be dynamic for a true fast path
+- esbuild code splitting creates ~60 chunk files, not suitable for CLI distribution; explicit two-file shim is cleaner
+- `process.stdin.unref()` doesn't exist in Bun — needs try/catch guard
+- Unix domain sockets with NDJSON are ideal for local IPC: secure (file permissions), fast, debuggable
+
+### Test Plan
+
+#### For QA
+1. `prjct daemon start` — verify socket at `~/.prjct-cli/run/daemon.sock`
+2. `prjct daemon status` — shows PID, uptime, commands served
+3. `prjct sync --json --yes` — works via IPC with valid JSON output
+4. `prjct daemon stop` — clean shutdown, socket removed
+5. Run any command without daemon — falls back to direct execution
+6. Verify `dist/` contains NO `.map` files or `sourcesContent`
+
+#### For Users
+**What changed:** CLI commands are now routed through a background daemon for faster execution.
+**How to use:** Automatic — daemon starts on first use, stops after 30min idle. Use `PRJCT_NO_DAEMON=1` to disable.
+**Breaking changes:** None.
+
+## [1.23.1] - 2026-02-10
+
+### Bug Fix
+
+- **Fix dual shebang in compiled linear CLI**: Removed `#!/usr/bin/env bun` from `core/cli/linear.ts` source file. The build script (esbuild) already injects `#!/usr/bin/env node` via banner, so the source shebang was duplicated in `dist/cli/linear.mjs` — causing `SyntaxError: Invalid or unexpected token` on Node.js for all `prjct linear` commands.
+
+### Root Cause
+
+The source file `core/cli/linear.ts` had `#!/usr/bin/env bun` on line 1. esbuild preserved it during compilation, and the build banner injected `#!/usr/bin/env node` — resulting in two shebangs. Node.js only strips line 1's shebang, so line 2 (`#!/usr/bin/env bun`) was parsed as JavaScript and threw a SyntaxError.
+
+### Learnings
+
+- Source files compiled by esbuild should NOT have shebangs — the build script's `banner` option is the single source of truth for shebang injection
+- Only the first line shebang is stripped by Node.js; any subsequent shebang lines cause parse errors
+
+### Test Plan
+
+#### For QA
+1. `head -1 dist/cli/linear.mjs` — single `#!/usr/bin/env node` shebang
+2. `node dist/cli/linear.mjs --help` — no SyntaxError
+3. `prjct linear list` — works end-to-end
+4. `grep -c '#!/' dist/cli/linear.mjs` — returns `1`
+
+#### For Users
+**What changed:** Fixed `prjct linear` commands failing with SyntaxError after v1.23.0.
+**How to use:** Update to v1.23.1 — no action needed.
+**Breaking changes:** None.
+
+## [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" "$@"