claude-launchpad 0.10.0 → 0.10.1-dev.0

package/README.md

@@ -4,106 +4,109 @@
 [![npm downloads](https://img.shields.io/npm/dm/claude-launchpad?style=flat-square)](https://www.npmjs.com/package/claude-launchpad)
 [![GitHub stars](https://img.shields.io/github/stars/mboss37/claude-launchpad?style=flat-square)](https://github.com/mboss37/claude-launchpad)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](https://github.com/mboss37/claude-launchpad/blob/master/LICENSE)
+![macOS](https://img.shields.io/badge/macOS-supported-brightgreen?style=flat-square&logo=apple)
+![Linux](https://img.shields.io/badge/Linux-supported-brightgreen?style=flat-square&logo=linux)
+![Windows](https://img.shields.io/badge/Windows-untested-yellow?style=flat-square&logo=windows)
 
-**Score your Claude Code setup. Fix what's broken. Prove it works.**
+**Score your Claude Code config. Fix it. Prove it works.**
 
-CLAUDE.md is advisory, so Claude follows your rules about 80% of the time. Hooks are deterministic: 100% compliance. Most developers have zero hooks and too many instructions. This tool scores your setup, fixes the gaps, and proves Claude follows your config.
+Claude Code follows CLAUDE.md about 80% of the time. Hooks run at 100%. Most developers have zero hooks and too many instructions. Claude Launchpad scores your setup, fixes the gaps, and tests that Claude actually follows your rules.
+
+This is for developers using Claude Code who want consistent results: solo devs, vibe coders, AI-first teams. If you have ever wondered why Claude ignores half your CLAUDE.md, this is the fix.
+
+## Install and See Your Score
 
 ```bash
 npx claude-launchpad
 ```
 
-That's it. Run it in any project with Claude Code. You'll see a score out of 100 and a list of exactly what's wrong. Run `--fix` to auto-repair.
+```
+  Instruction Budget     ━━━━━━━━━━━━━━━━━━━━   100%
+  CLAUDE.md Quality      ━━━━━━━━━━━━━━━━━━━━   100%
+  Settings               ━━━━━━━━━━━━━━━━━━━━   100%
+  Hooks                  ━━━━━━━━━━━━━━━━━━━━   100%
+  Rules                  ━━━━━━━━━━━━━━━━━━━━   100%
+  Permissions            ━━━━━━━━━━━━━━━━━━━━   100%
+  MCP Servers            ━━━━━━━━━━━━━━━━━━━━   100%
 
-Claude Launchpad has 4 CLI commands (`init`, `doctor`, `eval`, `memory`) plus 1 in-session skill (`/lp-enhance`). Memory is optional.
+  Overall                ━━━━━━━━━━━━━━━━━━━━   100%
 
-## Two Paths, One Tool
+  ✓ No issues found. Your configuration looks solid.
+```
+
+A typical unconfigured project scores ~31%. After `--fix`, it jumps to ~91%.
 
-### Starting a new project?
+## Quick Start
+
+**New project:**
 
 ```bash
-claude-launchpad init
+npx claude-launchpad init
 ```
 
-Detects your stack and generates `CLAUDE.md` with your commands and conventions. Creates `TASKS.md` for tracking, `BACKLOG.md` for parking features, sets up hooks that auto-format and block dangerous operations, and adds `.claudeignore` for noise files.
-
-Then use `/lp-enhance` inside Claude Code to have Claude read your actual codebase and fill in the architecture and guardrails — not boilerplate, real project-specific content.
+Detects your stack, generates config, hooks, and permissions. Start at ~93%.
 
-### Already have a project?
+**Existing project:**
 
 ```bash
-claude-launchpad
+npx claude-launchpad doctor --fix
 ```
 
-Scores your config out of 100 and tells you what's wrong. Run `doctor --fix` for automatic repairs, `/lp-enhance` for AI-powered rewrites, and `eval` to prove behavior.
+Scores your config, auto-repairs everything it can.
 
-## Command Model
+## The Three-File System
 
-| Command | What it does | Runs |
+| File | Purpose | Example |
 |---|---|---|
-| `claude-launchpad init` | Detect stack, generate config, hooks, permissions | Locally |
-| `claude-launchpad` | Default entrypoint (routes to doctor when config exists) | Locally |
-| `claude-launchpad doctor --fix` | Auto-fix issues: hooks, rules, sections, .claudeignore | Locally |
-| `claude-launchpad doctor --watch` | Live score that updates when you save config files | Locally |
-| `/lp-enhance` (skill) | Claude reads your code and completes CLAUDE.md | Inside Claude Code |
-| `claude-launchpad eval` | Run Claude against test scenarios, prove config works | Via Claude CLI |
-| `claude-launchpad memory` | Optional memory setup (or stats) + installs `/lp-migrate-memory` skill | Locally |
-| `claude-launchpad memory --dashboard` | TUI dashboard for memory visualization | Locally |
+| `CLAUDE.md` | What Claude needs to know | Stack, commands, conventions, guardrails |
+| `TASKS.md` | What we're doing now | Current sprint, session log, progress |
+| `BACKLOG.md` | What we're doing later | Parked features with P0/P1/P2 priority tiers |
 
-## Quick Start
+Without BACKLOG.md, deferred features get lost in conversation history or bloat TASKS.md. Init generates all three. Doctor checks for them. `--fix` creates any that are missing.
 
-```bash
-cd your-project
-npx claude-launchpad            # see your score
-npx claude-launchpad doctor --fix   # fix everything
-```
+## Commands
+
+| Command | What it does | Runs |
+|---|---|---|
+| `claude-launchpad` | Score your config (routes to doctor) | Locally, free |
+| `claude-launchpad init` | Detect stack, generate config + hooks + permissions | Locally, free |
+| `claude-launchpad doctor --fix` | Auto-fix issues found by doctor | Locally, free |
+| `claude-launchpad eval` | Run Claude against test scenarios, score results | Via Claude CLI |
+| `claude-launchpad memory` | Optional persistent memory system | Locally |
+| `/lp-enhance` (skill) | Claude reads your code and completes CLAUDE.md | Inside Claude Code |
 
-A typical unconfigured project scores ~42%. After `--fix`, it jumps to ~86%. Run `init` on a fresh project and you start at ~93%.
+## Doctor
 
-## The Doctor
+Runs 7 analyzers against your `.claude/` directory and CLAUDE.md. No API calls, no network, no cost.
 
-The core of the tool. Runs 7 core analyzers against your `.claude/` directory and `CLAUDE.md` (plus an optional Memory analyzer when agentic memory is detected):
+**Analyzers:**
 
 | Analyzer | What it catches |
 |---|---|
-| **Instruction Budget** | Too many instructions in CLAUDE.md — Claude starts ignoring rules past ~200 |
-| **CLAUDE.md Quality** | Missing essential sections, vague instructions ("write good code"), hardcoded secrets |
+| **Instruction Budget** | Too many instructions. Claude starts ignoring rules past ~200. |
+| **CLAUDE.md Quality** | Missing sections, vague instructions, hardcoded secrets |
 | **Settings** | No hooks configured, dangerous tool access without safety nets |
-| **Hooks** | Missing auto-format on save, no .env file protection, no security gates, no PostCompact hook |
+| **Hooks** | Missing auto-format, no .env protection, no PostCompact hook |
 | **Rules** | Dead rule files, stale references, empty configs |
-| **Permissions** | Credential file exposure (~/.ssh, ~/.aws, ~/.npmrc), blanket Bash approval, bypass mode unprotected, sandbox disabled, .env gap between hooks and .claudeignore, no force-push protection |
+| **Permissions** | Credential exposure (~/.ssh, ~/.aws), blanket Bash approval, sandbox disabled |
 | **MCP Servers** | Invalid transport configs, missing commands/URLs |
 
-Output looks like this:
-
-```
-  Instruction Budget     ━━━━━━━━━━━━━━━━━━━━   100%
-  CLAUDE.md Quality      ━━━━━━━━━━━━━━━━━━━━   100%
-  Settings               ━━━━━━━━━━━━━━━━━━━━   100%
-  Hooks                  ━━━━━━━━━━━━━━━━━━━━   100%
-  Rules                  ━━━━━━━━━━━━━━━━━━━━   100%
-  Permissions            ━━━━━━━━━━━━━━━━━━━━   100%
-  MCP Servers            ━━━━━━━━━━──────────    50%
-
-  Overall                ━━━━━━━━━━━━━━━━━━━─    93%
+An optional Memory analyzer runs when agentic memory is detected.
 
-  ✓ No issues found. Your configuration looks solid.
-```
-
-**All doctor flags:**
+**Flags:**
 
 | Flag | What it does |
 |---|---|
-| `--fix` | Auto-fixes issues: adds hooks, CLAUDE.md sections, BACKLOG.md, rules, .claudeignore |
-| `--fix --dry-run` | Preview what --fix would change without applying |
-| `--watch` | Re-runs every second, updates when you save a config file |
-| `--json` | Pure JSON output, no colors, no banner — for scripts and CI |
-| `--min-score <n>` | Exit code 1 if score is below threshold — use in CI to block bad configs |
+| `--fix` | Auto-fix: adds hooks, CLAUDE.md sections, BACKLOG.md, rules, .claudeignore |
+| `--fix --dry-run` | Preview fixes without applying them |
+| `--watch` | Re-runs every second as you edit config files |
+| `--json` | Pure JSON output for scripts and CI |
+| `--min-score <n>` | Exit code 1 if score is below threshold (for CI) |
 | `-p, --path <dir>` | Run on a different directory |
 
 ## Init
 
-Detects your project and generates Claude Code config that fits. No templates, no menus — it reads your manifest files and figures it out.
+Reads your manifest files (package.json, go.mod, pyproject.toml, etc.) and generates config that fits. No templates, no menus.
 
 ```
   → Detecting project...
@@ -119,78 +122,40 @@ Detects your project and generates Claude Code config that fits. No templates, n
   ✓ Generated .claude/rules/conventions.md
 ```
 
-**Works with:** TypeScript, JavaScript, Python, Go, Ruby, Rust, Dart, PHP, Java, Kotlin, Swift, Elixir, C# — and detects frameworks (Next.js, FastAPI, Django, Rails, Laravel, Express, SvelteKit, Angular, NestJS, and 15+ more).
-
 **What init writes:**
-- Always writes: `CLAUDE.md`, `TASKS.md`, `BACKLOG.md`, `.claude/settings.json`
+- Always: `CLAUDE.md`, `TASKS.md`, `BACKLOG.md`, `.claude/settings.json`
 - Creates when missing: `.claude/.gitignore`, `.claudeignore`, `.claude/rules/conventions.md`
-- Offers `/lp-enhance` install (project/global/skip) only when no project/global/legacy install already exists
+- Offers `/lp-enhance` install (project/global/skip) if not already present
 
-**The three-file system:**
-
-| File | Purpose |
-|---|---|
-| `CLAUDE.md` | What Claude needs to know — stack, commands, conventions, guardrails |
-| `TASKS.md` | What we're doing now — sprint tracking, session continuity |
-| `BACKLOG.md` | What we're doing later — parked features with P0/P1/P2 priority tiers |
-
-Without BACKLOG.md, deferred features get lost in conversation history or bloat TASKS.md. Init generates it, doctor checks for it, `--fix` creates it if missing.
+**Supported stacks:** TypeScript, JavaScript, Python, Go, Ruby, Rust, Dart, PHP, Java, Kotlin, Swift, Elixir, C#. Detects frameworks: Next.js, FastAPI, Django, Rails, Laravel, Express, SvelteKit, Angular, NestJS, and 15+ more.
 
 ## Enhance
 
-Init detects your stack but can't understand your architecture. The `/lp-enhance` skill runs inside your Claude Code session to read your actual code and fill in the details.
+Init detects your stack but cannot read your architecture. The `/lp-enhance` skill runs inside Claude Code to fill in the details.
 
 ```
 /lp-enhance
 ```
 
-Installed as a skill during `init` (you pick global or project scope). Claude reads your codebase and updates CLAUDE.md with real content - actual architecture, actual conventions, actual guardrails, and memory management instructions. Not boilerplate. It also suggests project-specific hooks (including PostCompact for session continuity) and MCP servers based on what it finds.
+Claude reads your codebase and updates CLAUDE.md with real content: actual architecture, actual conventions, actual guardrails. Not boilerplate. It also suggests project-specific hooks and MCP servers.
 
 Stays under the 200-instruction budget. Overflows detailed content to `.claude/rules/` files. If the skill is missing, `doctor --fix` will create it.
 
-## Memory
-
-Optional persistent memory system that replaces Claude Code's built-in flat-file memory with intelligent, decay-based retrieval.
-
-```bash
-claude-launchpad memory
-```
-
-Requires native deps first: `npm install better-sqlite3 sqlite-vec` (the CLI will prompt you if missing). Interactive setup - asks before changing anything. Installs a SQLite database, hooks for automatic context injection, and 7 MCP tools.
-
-**What it does:**
-- **Smart session injection** - each session starts with the most relevant memories, ranked by 6 signals (context, value, importance, recency, type, noise) and packed into a 2000-token budget across three tiers (full content / summary / title-only)
-- **Stop hook** extracts facts from the conversation transcript when you're done
-- **Decay model** - memories fade naturally based on type (episodic: 60 days, semantic: 1 year, procedural: 2 years)
-- **Self-tuning retrieval** - memories Claude actively searches for rise in rank; memories injected but never used gradually stop appearing
-- **Project-scoped** - memories are partitioned per project, no cross-contamination
-- **TUI dashboard** (`--dashboard`) for visualization with vim navigation, filtering, and search
-
-No cloud. No sync. Everything stays in `~/.agentic-memory/memory.db`.
-
-**Memory flags:**
-
-| Flag | What it does |
-|---|---|
-| `--dashboard` | Opens the interactive TUI dashboard |
-
-Default behavior of `claude-launchpad memory`:
-- If memory is not installed, it runs interactive install
-- If memory is installed, it shows memory stats
+**When to re-run:** after major refactors, new dependencies, or architecture changes.
 
 ## Eval
 
-The part nobody else has built. Runs Claude against real test scenarios and scores the results.
+Runs Claude against real test scenarios and scores the results. Nobody else has built this.
 
 ```bash
-# Interactive mode — pick suite, runs, and model
+# Interactive mode (pick suite, runs, model)
 claude-launchpad eval
 
 # Or pass flags directly
 claude-launchpad eval --suite security --runs 1 --model haiku
 ```
 
-Each scenario creates an isolated sandbox with your full Claude Code config (settings.json, rules, hooks, .claudeignore) copied in, runs Claude with a task, and checks if your configuration made Claude follow the rules:
+Each scenario creates an isolated sandbox with your full Claude Code config copied in. It runs Claude with a task and checks if your configuration made Claude follow the rules.
 
 ```
   ✓ security/sql-injection            10/10  PASS
@@ -203,7 +168,7 @@ Each scenario creates an isolated sandbox with your full Claude Code config (set
   Config Eval Score      ━━━━━━━━━━━━━━━━━━━─    95%
 ```
 
-Results are saved to `.claude/eval/` as structured markdown — you can feed these reports back to Claude to fix the failures.
+Results save to `.claude/eval/` as structured markdown. Feed them back to Claude to fix failures.
 
 **Suites:**
 
@@ -213,19 +178,48 @@ Results are saved to `.claude/eval/` as structured markdown — you can feed the
 | `conventions` | 5 | Error handling, immutability, file size, naming, no hardcoded values |
 | `workflow` | 4 | Git conventions, session continuity, memory persistence, deferred tracking |
 
-**All eval flags:**
+**Flags:**
 
 | Flag | What it does |
 |---|---|
 | `--suite <name>` | Run one suite: `security`, `conventions`, or `workflow` |
-| `-p, --path <dir>` | Project root to evaluate (defaults to current directory) |
+| `-p, --path <dir>` | Project root to evaluate (defaults to cwd) |
 | `--scenarios <path>` | Use a custom scenarios directory |
 | `--model <model>` | Model to use: `haiku`, `sonnet`, `opus` |
 | `--runs <n>` | Runs per scenario (default 3, median score used) |
-| `--debug` | Keep sandbox directories so you can inspect what Claude wrote |
+| `--debug` | Keep sandbox directories for inspection |
 | `--json` | JSON output |
 | `--timeout <ms>` | Timeout per run (default 120000) |
 
+## Memory
+
+Optional persistent memory that replaces Claude Code's built-in flat-file memory with intelligent, decay-based retrieval.
+
+```bash
+claude-launchpad memory
+```
+
+If memory is not installed, it runs interactive setup. If installed, it shows stats. Requires native deps first: `npm install better-sqlite3 sqlite-vec`.
+
+**What it does:**
+- **Smart session injection** starts each session with the most relevant memories, ranked by 6 signals and packed into a 2000-token budget across three tiers
+- **Stop hook** extracts facts from the conversation when you finish
+- **Decay model** fades memories naturally (episodic: 60 days, semantic: 1 year, procedural: 2 years)
+- **Self-tuning retrieval** promotes memories Claude searches for, demotes ones injected but never used
+- **Project-scoped** with no cross-contamination between projects
+- **TUI dashboard** (`--dashboard`) with vim navigation, filtering, and search
+- **Cross-device sync** via private GitHub Gist — push/pull memories between machines
+
+Data stays in `~/.agentic-memory/memory.db`. Sync is opt-in and uses your existing `gh` CLI auth.
+
+| Flag / Subcommand | What it does |
+|---|---|
+| `--dashboard` | Opens the interactive TUI dashboard |
+| `push` | Push memories to a private GitHub Gist |
+| `pull` | Pull memories from a private GitHub Gist |
+| `push --project <name>` | Push only one project's memories |
+| `pull --project <name>` | Pull only one project's memories |
+
 ## Use in CI
 
 Block PRs that degrade your Claude Code config quality:
@@ -252,35 +246,38 @@ Score below threshold = exit code 1 = PR blocked.
 
 **Doctor** reads your files and runs static analysis. No API calls. No network. No cost.
 
-**Init** scans manifest files (package.json, go.mod, pyproject.toml, etc.), detects your stack, and generates 8 files: CLAUDE.md (with sprint reviews and backlog management), TASKS.md (with deferred issues section), BACKLOG.md (priority-tiered feature parking), settings.json (with credential deny rules, sandbox enabled, bypass mode disabled, hooks including sprint review and PostCompact), .claude/.gitignore, .claudeignore, /lp-enhance skill, and language-specific rules. Formatter hooks use hardcoded safe commands only.
-
-**Enhance** is a `/lp-enhance` skill installed during `init`. It runs inside your active Claude Code session - no separate process, no overhead. Claude already has your codebase context, so it produces better results than an external command.
+**Init** scans manifest files (package.json, go.mod, pyproject.toml, etc.) and detects your stack. Generates 8 files:
+- CLAUDE.md (sprint reviews, backlog management)
+- TASKS.md (session log, sprint tracking)
+- BACKLOG.md (priority-tiered feature parking)
+- settings.json (credential deny rules, sandbox, hooks)
+- .claude/.gitignore, .claudeignore, /lp-enhance skill, conventions.md
 
-**Eval** creates a temp directory, copies your full `.claude/` config (settings.json, rules, hooks, permissions) and `.claudeignore` into it, writes seed files from the scenario YAML, initializes a git repo, runs Claude via the Agent SDK (or falls back to CLI), then checks the output with grep/file assertions. Your code is never copied, only your Claude Code configuration. Sandbox is cleaned up after (or preserved with `--debug`).
+Formatter hooks use hardcoded safe commands only.
 
-## Why This Exists
+**Enhance** is a `/lp-enhance` skill installed during `init`. It runs inside your active Claude Code session, not a separate process. Claude already has your codebase context, so it produces better results than an external command.
 
-Nobody measures their Claude Code config quality. You write CLAUDE.md, hope Claude follows it, and never verify. This tool gives you a number. Fix the issues, re-run, watch it go up.
+**Eval** creates a temp directory, copies your full `.claude/` config (settings.json, rules, hooks, permissions) and `.claudeignore` into it, writes seed files from the scenario YAML, initializes a git repo, runs Claude via the Agent SDK (or falls back to CLI), then checks the output with grep/file assertions. Your code is never copied, only your Claude Code configuration. Sandbox is cleaned up after (or preserved with `--debug`).
 
 ## Glossary
 
-New to Claude Code? Here's what the terms mean:
+New to Claude Code? Here's what the terms mean.
 
 | Term | What it is |
 |---|---|
 | **CLAUDE.md** | A markdown file in your project root that tells Claude how to work on your code. Think of it as instructions for your AI pair programmer. [Official docs](https://docs.anthropic.com/en/docs/claude-code/memory#claudemd) |
 | **TASKS.md** | Sprint tracker and session log. Claude reads this at session start to pick up where you left off. |
 | **BACKLOG.md** | Where deferred features live. Priority tiers (P0/P1/P2) keep future ideas organized without cluttering TASKS.md. |
-| **Hooks** | Shell commands that run automatically when Claude does something. For example: auto-format a file after Claude edits it, or block Claude from reading your `.env` file. They live in `.claude/settings.json`. |
+| **Hooks** | Shell commands that run automatically when Claude does something. Example: auto-format after edits, block reading `.env`. They live in `.claude/settings.json`. |
 | **Instruction budget** | CLAUDE.md has a soft limit of ~200 actionable lines. Past that, Claude starts ignoring rules at the bottom. Doctor counts your lines and warns you. |
 | **Rules** | Extra markdown files in `.claude/rules/` that Claude reads alongside CLAUDE.md. Use them to offload detailed conventions so CLAUDE.md stays under budget. |
-| **Compaction** | When a Claude Code conversation gets too long, it compresses older messages to free up space. This can lose context — a PostCompact hook re-injects critical files (like TASKS.md) after compaction. |
+| **Compaction** | When a conversation gets too long, Claude compresses older messages. This can lose context. A PostCompact hook re-injects critical files (like TASKS.md) after compaction. |
 | **MCP Servers** | External tools Claude can connect to (databases, APIs, docs). Configured in `.claude/settings.json`. Most projects don't need them. |
-| **.claudeignore** | Like `.gitignore` but for Claude. Tells Claude which files to skip (node_modules, dist, lockfiles) so it doesn't waste time reading noise. |
+| **.claudeignore** | Like `.gitignore` but for Claude. Tells Claude which files to skip so it doesn't waste time reading noise. |
 
 ## Privacy
 
-No telemetry. No analytics. No data sent anywhere. Doctor, init, and fix are fully offline. Memory stores data locally at `~/.agentic-memory/` - no cloud sync. Enhance and eval run through your local Claude CLI - no data passes through this tool. [Full privacy policy](https://mboss37.github.io/claude-launchpad/privacy.html).
+No telemetry. No analytics. No data sent anywhere. Doctor, init, and fix are fully offline. Memory stores data locally at `~/.agentic-memory/`. The optional sync feature (`memory push/pull`) uses a private GitHub Gist under your own account — data goes to GitHub, not to us. Enhance and eval run through your local Claude CLI, no data passes through this tool. [Full privacy policy](https://mboss37.github.io/claude-launchpad/privacy.html).
 
 ## License
 

package/dist/chunk-7YDBTED2.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_CONFIG,
+  resolveDataDir
+} from "./chunk-ZMSHFAZQ.js";
+
+// src/commands/memory/utils/gist-transport.ts
+import { execSync } from "child_process";
+import { readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { tmpdir } from "os";
+var EXEC_OPTS = { encoding: "utf-8", timeout: 3e4 };
+var GIST_FILENAME = "agentic-memory-sync.json";
+var SYNC_CONFIG_FILE = "sync-config.json";
+function syncConfigPath() {
+  return join(resolveDataDir(DEFAULT_CONFIG.dataDir), SYNC_CONFIG_FILE);
+}
+function assertGhAvailable() {
+  try {
+    execSync("gh --version", { ...EXEC_OPTS, stdio: "pipe" });
+  } catch {
+    throw new Error(
+      "Memory sync requires the GitHub CLI.\nInstall: https://cli.github.com/\nThen run: gh auth login"
+    );
+  }
+  try {
+    execSync("gh auth status", { ...EXEC_OPTS, stdio: "pipe" });
+  } catch {
+    throw new Error(
+      "gh is installed but not authenticated.\nRun: gh auth login"
+    );
+  }
+}
+function loadSyncConfig() {
+  try {
+    const raw = readFileSync(syncConfigPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.gistId === "string" && parsed.gistId.length > 0) {
+      return { gistId: parsed.gistId };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveSyncConfig(config) {
+  const filePath = syncConfigPath();
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function createGist(payload) {
+  const tmpFile = join(tmpdir(), GIST_FILENAME);
+  try {
+    writeFileSync(tmpFile, payload, "utf-8");
+    const result = execSync(
+      `gh gist create "${tmpFile}" --desc "agentic-memory sync" --public=false`,
+      { ...EXEC_OPTS, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    const gistId = result.split("/").pop() ?? "";
+    if (!gistId) throw new Error(`Failed to parse gist ID from: ${result}`);
+    saveSyncConfig({ gistId });
+    return gistId;
+  } finally {
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+    }
+  }
+}
+function readGist(gistId) {
+  try {
+    return execSync(
+      `gh gist view "${gistId}" --filename "${GIST_FILENAME}" --raw`,
+      { ...EXEC_OPTS, stdio: ["pipe", "pipe", "pipe"] }
+    );
+  } catch {
+    return null;
+  }
+}
+function updateGist(gistId, payload) {
+  const tmpFile = join(tmpdir(), GIST_FILENAME);
+  try {
+    writeFileSync(tmpFile, payload, "utf-8");
+    execSync(
+      `gh gist edit "${gistId}" --filename "${GIST_FILENAME}" "${tmpFile}"`,
+      { ...EXEC_OPTS, stdio: ["pipe", "pipe", "pipe"] }
+    );
+  } finally {
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+    }
+  }
+}
+
+// src/commands/memory/utils/sync-merge.ts
+function memoryToSyncRow(m) {
+  return {
+    id: m.id,
+    type: m.type,
+    title: m.title,
+    content: m.content,
+    context: m.context,
+    source: m.source,
+    project: m.project,
+    tags: [...m.tags],
+    importance: m.importance,
+    access_count: m.accessCount,
+    injection_count: m.injectionCount,
+    created_at: m.createdAt,
+    updated_at: m.updatedAt,
+    last_accessed: m.lastAccessed
+  };
+}
+function mergeFromRemote(memoryRepo, relationRepo, payload, project) {
+  let inserted = 0;
+  let updated = 0;
+  let relationsAdded = 0;
+  const memories = project ? payload.memories.filter((m) => m.project === project) : payload.memories;
+  for (const remote of memories) {
+    const local = memoryRepo.getById(remote.id);
+    if (!local) {
+      memoryRepo.upsertFromSync(remote);
+      inserted++;
+    } else if (remote.updated_at > local.updatedAt) {
+      memoryRepo.upsertFromSync(remote);
+      updated++;
+    }
+  }
+  const localIds = new Set(memoryRepo.getAll().map((m) => m.id));
+  const relations = payload.relations.filter(
+    (r) => localIds.has(r.source_id) && localIds.has(r.target_id)
+  );
+  for (const rel of relations) {
+    const added = relationRepo.create(
+      rel.source_id,
+      rel.target_id,
+      rel.relation_type
+    );
+    if (added) relationsAdded++;
+  }
+  return { inserted, updated, relationsAdded };
+}
+
+export {
+  assertGhAvailable,
+  loadSyncConfig,
+  createGist,
+  readGist,
+  updateGist,
+  memoryToSyncRow,
+  mergeFromRemote
+};
+//# sourceMappingURL=chunk-7YDBTED2.js.map

package/dist/chunk-7YDBTED2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/memory/utils/gist-transport.ts","../src/commands/memory/utils/sync-merge.ts"],"sourcesContent":["import { execSync } from 'node:child_process';\nimport { readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';\nimport { join, dirname } from 'node:path';\nimport { tmpdir } from 'node:os';\nimport { randomUUID } from 'node:crypto';\nimport { resolveDataDir, DEFAULT_CONFIG } from '../config.js';\nimport type { SyncConfig } from '../types.js';\n\nconst EXEC_OPTS = { encoding: 'utf-8' as const, timeout: 30_000 };\nconst GIST_FILENAME = 'agentic-memory-sync.json';\nconst SYNC_CONFIG_FILE = 'sync-config.json';\n\nfunction syncConfigPath(): string {\n  return join(resolveDataDir(DEFAULT_CONFIG.dataDir), SYNC_CONFIG_FILE);\n}\n\nexport function assertGhAvailable(): void {\n  try {\n    execSync('gh --version', { ...EXEC_OPTS, stdio: 'pipe' });\n  } catch {\n    throw new Error(\n      'Memory sync requires the GitHub CLI.\\n' +\n      'Install: https://cli.github.com/\\n' +\n      'Then run: gh auth login'\n    );\n  }\n  try {\n    execSync('gh auth status', { ...EXEC_OPTS, stdio: 'pipe' });\n  } catch {\n    throw new Error(\n      'gh is installed but not authenticated.\\n' +\n      'Run: gh auth login'\n    );\n  }\n}\n\nexport function loadSyncConfig(): SyncConfig | null {\n  try {\n    const raw = readFileSync(syncConfigPath(), 'utf-8');\n    const parsed = JSON.parse(raw) as Record<string, unknown>;\n    if (typeof parsed.gistId === 'string' && parsed.gistId.length > 0) {\n      return { gistId: parsed.gistId };\n    }\n    return null;\n  } catch {\n    return null;\n  }\n}\n\nexport function saveSyncConfig(config: SyncConfig): void {\n  const filePath = syncConfigPath();\n  mkdirSync(dirname(filePath), { recursive: true });\n  writeFileSync(filePath, JSON.stringify(config, null, 2) + '\\n', 'utf-8');\n}\n\nexport function createGist(payload: string): string {\n  const tmpFile = join(tmpdir(), GIST_FILENAME);\n  try {\n    writeFileSync(tmpFile, payload, 'utf-8');\n    const result = execSync(\n      `gh gist create \"${tmpFile}\" --desc \"agentic-memory sync\" --public=false`,\n      { ...EXEC_OPTS, stdio: ['pipe', 'pipe', 'pipe'] },\n    ).trim();\n    const gistId = result.split('/').pop() ?? '';\n    if (!gistId) throw new Error(`Failed to parse gist ID from: ${result}`);\n    saveSyncConfig({ gistId });\n    return gistId;\n  } finally {\n    try { unlinkSync(tmpFile); } catch { /* ignore */ }\n  }\n}\n\nexport function readGist(gistId: string): string | null {\n  try {\n    return execSync(\n      `gh gist view \"${gistId}\" --filename \"${GIST_FILENAME}\" --raw`,\n      { ...EXEC_OPTS, stdio: ['pipe', 'pipe', 'pipe'] },\n    );\n  } catch {\n    return null;\n  }\n}\n\nexport function updateGist(gistId: string, payload: string): void {\n  const tmpFile = join(tmpdir(), GIST_FILENAME);\n  try {\n    writeFileSync(tmpFile, payload, 'utf-8');\n    execSync(\n      `gh gist edit \"${gistId}\" --filename \"${GIST_FILENAME}\" \"${tmpFile}\"`,\n      { ...EXEC_OPTS, stdio: ['pipe', 'pipe', 'pipe'] },\n    );\n  } finally {\n    try { unlinkSync(tmpFile); } catch { /* ignore */ }\n  }\n}\n","import type { Memory, SyncPayload, SyncMemoryRow, MergeResult, RelationType } from '../types.js';\nimport type { MemoryRepo } from '../storage/memory-repo.js';\nimport type { RelationRepo } from '../storage/relation-repo.js';\n\nfunction memoryToSyncRow(m: Memory): SyncMemoryRow {\n  return {\n    id: m.id,\n    type: m.type,\n    title: m.title,\n    content: m.content,\n    context: m.context,\n    source: m.source,\n    project: m.project,\n    tags: [...m.tags],\n    importance: m.importance,\n    access_count: m.accessCount,\n    injection_count: m.injectionCount,\n    created_at: m.createdAt,\n    updated_at: m.updatedAt,\n    last_accessed: m.lastAccessed,\n  };\n}\n\nexport { memoryToSyncRow };\n\nexport function mergeFromRemote(\n  memoryRepo: MemoryRepo,\n  relationRepo: RelationRepo,\n  payload: SyncPayload,\n  project?: string,\n): MergeResult {\n  let inserted = 0;\n  let updated = 0;\n  let relationsAdded = 0;\n\n  const memories = project\n    ? payload.memories.filter((m) => m.project === project)\n    : payload.memories;\n\n  for (const remote of memories) {\n    const local = memoryRepo.getById(remote.id);\n    if (!local) {\n      memoryRepo.upsertFromSync(remote);\n      inserted++;\n    } else if (remote.updated_at > local.updatedAt) {\n      memoryRepo.upsertFromSync(remote);\n      updated++;\n    }\n  }\n\n  const localIds = new Set(memoryRepo.getAll().map((m) => m.id));\n  const relations = payload.relations.filter(\n    (r) => localIds.has(r.source_id) && localIds.has(r.target_id),\n  );\n\n  for (const rel of relations) {\n    const added = relationRepo.create(\n      rel.source_id,\n      rel.target_id,\n      rel.relation_type as RelationType,\n    );\n    if (added) relationsAdded++;\n  }\n\n  return { inserted, updated, relationsAdded };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-J5NT4JGE.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+// src/commands/memory/types.ts
+import { z } from "zod";
+var MEMORY_TYPES = ["working", "episodic", "semantic", "procedural", "pattern"];
+var MEMORY_SOURCES = ["manual", "session_end", "consolidation", "hook", "import"];
+var RELATION_TYPES = [
+  "relates_to",
+  "depends_on",
+  "contradicts",
+  "extends",
+  "implements",
+  "derived_from"
+];
+var StoreInputSchema = z.object({
+  type: z.enum(MEMORY_TYPES),
+  content: z.string().min(1).max(1e4),
+  title: z.string().max(200).optional(),
+  tags: z.array(z.string()).max(20).default([]),
+  importance: z.number().min(0).max(1).default(0.5),
+  context: z.string().optional(),
+  source: z.enum(MEMORY_SOURCES).default("manual"),
+  project: z.string().max(200).optional()
+});
+var SearchInputSchema = z.object({
+  query: z.string().min(1).max(500),
+  id: z.string().optional(),
+  type: z.enum(MEMORY_TYPES).optional(),
+  tags: z.array(z.string()).max(10).optional(),
+  limit: z.number().int().min(1).max(50).default(10),
+  min_importance: z.number().min(0).max(1).default(0),
+  project: z.string().max(200).optional()
+});
+var ForgetInputSchema = z.object({
+  id: z.string(),
+  hard_delete: z.boolean().default(false)
+});
+var RelateInputSchema = z.object({
+  source_id: z.string(),
+  target_id: z.string(),
+  relation_type: z.enum(RELATION_TYPES)
+});
+var SyncPayloadSchema = z.object({
+  version: z.number(),
+  machine_id: z.string(),
+  pushed_at: z.string(),
+  memories: z.array(z.object({
+    id: z.string(),
+    type: z.enum(MEMORY_TYPES),
+    title: z.string().nullable(),
+    content: z.string(),
+    context: z.string().nullable(),
+    source: z.enum(MEMORY_SOURCES).nullable(),
+    project: z.string().nullable(),
+    tags: z.array(z.string()),
+    importance: z.number(),
+    access_count: z.number(),
+    injection_count: z.number(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    last_accessed: z.string().nullable()
+  })),
+  relations: z.array(z.object({
+    source_id: z.string(),
+    target_id: z.string(),
+    relation_type: z.enum(RELATION_TYPES),
+    created_at: z.string()
+  }))
+});
+
+export {
+  MEMORY_TYPES,
+  MEMORY_SOURCES,
+  RELATION_TYPES,
+  SyncPayloadSchema
+};
+//# sourceMappingURL=chunk-J5NT4JGE.js.map

package/dist/chunk-J5NT4JGE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/memory/types.ts"],"sourcesContent":["import { z } from 'zod';\n\n// ── Memory Types ──────────────────────────────────────────────\n\nexport const MEMORY_TYPES = ['working', 'episodic', 'semantic', 'procedural', 'pattern'] as const;\nexport type MemoryType = typeof MEMORY_TYPES[number];\n\nexport const MEMORY_SOURCES = ['manual', 'session_end', 'consolidation', 'hook', 'import'] as const;\nexport type MemorySource = typeof MEMORY_SOURCES[number];\n\nexport const RELATION_TYPES = [\n  'relates_to', 'depends_on', 'contradicts', 'extends', 'implements', 'derived_from',\n] as const;\nexport type RelationType = typeof RELATION_TYPES[number];\n\n// ── Core Entities ─────────────────────────────────────────────\n\nexport interface Memory {\n  readonly id: string;\n  readonly type: MemoryType;\n  readonly title: string | null;\n  readonly content: string;\n  readonly context: string | null;\n  readonly source: MemorySource | null;\n  readonly project: string | null;\n  readonly tags: readonly string[];\n  readonly importance: number;\n  readonly createdAt: string;\n  readonly updatedAt: string;\n  readonly accessCount: number;\n  readonly lastAccessed: string | null;\n  readonly injectionCount: number;\n}\n\nexport interface Relation {\n  readonly sourceId: string;\n  readonly targetId: string;\n  readonly relationType: RelationType;\n  readonly createdAt: string;\n}\n\n// ── Search Types ──────────────────────────────────────────────\n\nexport interface SearchResult {\n  readonly memory: Memory;\n  readonly score: number;\n  readonly explanation: string;\n}\n\nexport interface FtsMatch {\n  readonly rowid: number;\n  readonly memoryId: string;\n  readonly rank: number;\n}\n\nexport interface ScoredCandidate {\n  readonly memoryId: string;\n  readonly textScore: number;\n  readonly importanceScore: number;\n  readonly recencyScore: number;\n  readonly accessScore: number;\n  readonly contextScore: number;\n  readonly composite: number;\n}\n\n// ── Decay Parameters ──────────────────────────────────────────\n\nexport interface DecayParams {\n  readonly tauByType: Record<MemoryType, number>;\n  readonly accessModifiers: readonly { readonly maxCount: number; readonly multiplier: number }[];\n  readonly relationModifier: { readonly connectedThreshold: number; readonly connectedMultiplier: number; readonly isolatedMultiplier: number };\n  readonly importanceFloor: number;\n  readonly pruneThreshold: number;\n  readonly pruneMinAgeDays: number;\n}\n\n// ── Input Schemas (for MCP tools) ─────────────────────────────\n\nexport const StoreInputSchema = z.object({\n  type: z.enum(MEMORY_TYPES),\n  content: z.string().min(1).max(10000),\n  title: z.string().max(200).optional(),\n  tags: z.array(z.string()).max(20).default([]),\n  importance: z.number().min(0).max(1).default(0.5),\n  context: z.string().optional(),\n  source: z.enum(MEMORY_SOURCES).default('manual'),\n  project: z.string().max(200).optional(),\n});\nexport type StoreInput = z.infer<typeof StoreInputSchema>;\n\nexport const SearchInputSchema = z.object({\n  query: z.string().min(1).max(500),\n  id: z.string().optional(),\n  type: z.enum(MEMORY_TYPES).optional(),\n  tags: z.array(z.string()).max(10).optional(),\n  limit: z.number().int().min(1).max(50).default(10),\n  min_importance: z.number().min(0).max(1).default(0),\n  project: z.string().max(200).optional(),\n});\nexport type SearchInput = z.infer<typeof SearchInputSchema>;\n\nexport const ForgetInputSchema = z.object({\n  id: z.string(),\n  hard_delete: z.boolean().default(false),\n});\nexport type ForgetInput = z.infer<typeof ForgetInputSchema>;\n\nexport const RelateInputSchema = z.object({\n  source_id: z.string(),\n  target_id: z.string(),\n  relation_type: z.enum(RELATION_TYPES),\n});\nexport type RelateInput = z.infer<typeof RelateInputSchema>;\n\n// ── Sync Types ───────────────────────────────────────────────\n\nexport interface SyncPayload {\n  readonly version: number;\n  readonly machine_id: string;\n  readonly pushed_at: string;\n  readonly memories: readonly SyncMemoryRow[];\n  readonly relations: readonly SyncRelationRow[];\n}\n\nexport interface SyncMemoryRow {\n  readonly id: string;\n  readonly type: MemoryType;\n  readonly title: string | null;\n  readonly content: string;\n  readonly context: string | null;\n  readonly source: MemorySource | null;\n  readonly project: string | null;\n  readonly tags: readonly string[];\n  readonly importance: number;\n  readonly access_count: number;\n  readonly injection_count: number;\n  readonly created_at: string;\n  readonly updated_at: string;\n  readonly last_accessed: string | null;\n}\n\nexport interface SyncRelationRow {\n  readonly source_id: string;\n  readonly target_id: string;\n  readonly relation_type: RelationType;\n  readonly created_at: string;\n}\n\nexport const SyncPayloadSchema = z.object({\n  version: z.number(),\n  machine_id: z.string(),\n  pushed_at: z.string(),\n  memories: z.array(z.object({\n    id: z.string(),\n    type: z.enum(MEMORY_TYPES),\n    title: z.string().nullable(),\n    content: z.string(),\n    context: z.string().nullable(),\n    source: z.enum(MEMORY_SOURCES).nullable(),\n    project: z.string().nullable(),\n    tags: z.array(z.string()),\n    importance: z.number(),\n    access_count: z.number(),\n    injection_count: z.number(),\n    created_at: z.string(),\n    updated_at: z.string(),\n    last_accessed: z.string().nullable(),\n  })),\n  relations: z.array(z.object({\n    source_id: z.string(),\n    target_id: z.string(),\n    relation_type: z.enum(RELATION_TYPES),\n    created_at: z.string(),\n  })),\n});\n\nexport interface SyncConfig {\n  readonly gistId: string;\n}\n\nexport interface MergeResult {\n  readonly inserted: number;\n  readonly updated: number;\n  readonly relationsAdded: number;\n}\n\n// ── Stats ─────────────────────────────────────────────────────\n\nexport interface MemoryStats {\n  readonly totalMemories: number;\n  readonly byType: Record<MemoryType, number>;\n  readonly totalRelations: number;\n  readonly dbSizeBytes: number;\n  readonly oldestMemory: string | null;\n  readonly newestMemory: string | null;\n  readonly topInjected: readonly { readonly id: string; readonly title: string | null; readonly injectionCount: number }[];\n}\n"],"mappings":"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","names":[]}