ctxsaver 1.0.0

package/README.md

@@ -0,0 +1,231 @@
+# CtxSaver 🧠
+
+> *"Git tracks your code history. CtxSaver tracks your intent history."*
+
+**Persistent AI coding context for teams.** Never re-explain your codebase to an AI assistant again.
+
+## The Problem
+
+You're deep in a Cursor session refactoring a payment service. You've explained the architecture, tried 3 approaches, finally found the right one. Session dies. Next morning — or worse, your teammate picks it up — and the AI has **zero memory**. You spend 15 min re-explaining everything. Every. Single. Time.
+
+This is broken across **every** AI coding tool: Cursor, Claude Code, Copilot, Windsurf — none of them persist context across sessions, editors, or team members.
+
+## The Solution
+
+**CtxSaver** is a CLI tool that automatically captures and restores AI coding context, scoped to your repo and branch.
+
+```bash
+# Save context after a session
+ctxsaver save "Refactoring payment service to use event sourcing"
+
+# Restore context in any editor, any machine
+ctxsaver resume
+```
+
+## Install
+
+### Prerequisites
+- Node.js 16+ and npm
+
+### Setup
+> **Note:** Not yet published to npm. Install locally from source:
+
+```bash
+git clone git@github.com:nickiiitu/CtxSaver.git
+cd CtxSaver
+npm install
+npm run build
+npm link        # makes `ctxsaver` available globally on your machine
+
+# Verify installation
+ctxsaver --version
+```
+
+Now **navigate to your project repo** to use CtxSaver:
+
+```bash
+cd /path/to/your/project
+ctxsaver init
+```
+
+## Quick Start
+
+```bash
+# 1. Initialize in your repo
+ctxsaver init
+
+# 2. Work on your code... then save context
+ctxsaver save
+# → Interactive prompts capture: Task, Approaches, Decisions, Next Steps
+
+# 3. Resume in ANY editor
+ctxsaver resume
+# → Copies a perfectly formatted prompt to your clipboard
+# → Paste into Cursor, Claude, or ChatGPT to restore full context
+```
+
+## Features & Commands
+
+### Core (No AI Key Required)
+**These commands work locally with zero dependencies.**
+| Command | Description |
+|---------|-------------|
+| `ctxsaver init` | Initialize CtxSaver in current repo |
+| `ctxsaver save [msg]` | Save context (interactive or quick mode) |
+| `ctxsaver save --auto` | Auto-save context from agent/editor logs (non-interactive) |
+| `ctxsaver resume` | Generate AI prompt & copy to clipboard |
+| `ctxsaver log` | View context history for current branch |
+| `ctxsaver diff` | Show changes since last context save |
+
+### Team & Automation (No AI Key Required)
+| Command | Description |
+|---------|-------------|
+| `ctxsaver handoff @user` | explicit handoff note to a teammate |
+| `ctxsaver share` | Commit `.ctxsaver/` folder to git for team sync |
+| `ctxsaver watch` | Auto-save context on file changes (using `chokidar`) |
+| `ctxsaver hook install` | Install git post-commit hook for auto-capture |
+
+### AI-Powered (Experimental)
+**Requires an LLM Provider.** Set via `CTXSAVER_AI_KEY` env var or `ctxsaver config set aiApiKey <key>`. Defaults to OpenAI-compatible API.
+| Command | Description |
+|---------|-------------|
+| `ctxsaver summarize` | AI-generates context from git diff + recent commits |
+| `ctxsaver suggest` | AI suggests next steps based on current context |
+| `ctxsaver compress` | detailed history into a concise summary |
+
+#### AI Commands Setup
+To use `ctxsaver summarize`, `suggest`, or `compress`, configure your AI provider:
+
+**Quick Setup for OpenAI (default):**
+```bash
+ctxsaver config set aiApiKey "your-openai-api-key"
+ctxsaver config set aiModel "gpt-4o-mini"
+# Provider defaults to https://api.openai.com/v1
+```
+
+**Quick Setup for Google Gemini (via OpenRouter):**
+```bash
+ctxsaver config set aiProvider "https://openrouter.ai/api/v1"
+ctxsaver config set aiApiKey "your-openrouter-api-key"
+ctxsaver config set aiModel "google/gemini-flash-1.5"
+```
+
+**Quick Setup for ChatGLM (via OpenRouter):**
+```bash
+ctxsaver config set aiProvider "https://openrouter.ai/api/v1"
+ctxsaver config set aiApiKey "your-openrouter-api-key"
+ctxsaver config set aiModel "zhipuai/glm-4"
+```
+
+**Configuration Commands:**
+```bash
+# View all settings
+ctxsaver config list
+
+# Get a specific config value
+ctxsaver config get aiModel
+
+# Set via environment variable (temporary)
+export CTXSAVER_AI_KEY="your-api-key"
+```
+
+**Supported Providers:**
+- **OpenAI** (default): `https://api.openai.com/v1`
+- **Google Gemini** (via OpenRouter): `https://openrouter.ai/api/v1`
+- **ChatGLM** (via OpenRouter): `https://openrouter.ai/api/v1`
+- **Ollama** (local): `http://localhost:11434/v1` (no API key needed)
+- **LM Studio** (local): `http://localhost:1234/v1` (no API key needed)
+- **Together.ai**: `https://api.together.xyz/v1`
+- Any OpenAI-compatible API endpoint
+
+**Example: Using Ollama locally**
+```bash
+ctxsaver config set aiProvider "http://localhost:11434/v1"
+ctxsaver config set aiModel "llama3"
+# No API key needed for local models
+```
+
+**Example: Using Google Gemini via OpenRouter**
+```bash
+ctxsaver config set aiProvider "https://openrouter.ai/api/v1"
+ctxsaver config set aiApiKey "your-openrouter-api-key"
+
+# Try these Gemini model names:
+ctxsaver config set aiModel "google/gemini-flash-1.5"
+# or
+ctxsaver config set aiModel "google/gemini-pro-1.5"
+# or
+ctxsaver config set aiModel "google/gemini-2.0-flash-exp"
+
+# Check available models at: https://openrouter.ai/models
+```
+
+**Example: Using ChatGLM via OpenRouter**
+```bash
+ctxsaver config set aiProvider "https://openrouter.ai/api/v1"
+ctxsaver config set aiApiKey "your-openrouter-api-key"
+ctxsaver config set aiModel "zhipuai/glm-4"
+# or
+ctxsaver config set aiModel "zhipuai/glm-4-plus"
+```
+
+### Configuration
+| Command | Description |
+|---------|-------------|
+| `ctxsaver config list` | View all configuration settings |
+| `ctxsaver config get <key>` | Get a specific config value |
+| `ctxsaver config set <key> <val>` | Set a configuration preference |
+
+**Available Configuration Keys:**
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `aiApiKey` | string | - | API key for AI provider (or use `CTXSAVER_AI_KEY` env var) |
+| `aiProvider` | string | `https://api.openai.com/v1` | OpenAI-compatible API endpoint |
+| `aiModel` | string | `gpt-4o-mini` | Model name to use for AI commands |
+| `aiMaxTokens` | number | `16384` | Max tokens for AI responses (increase for longer summaries) |
+| `defaultOutput` | string | `clipboard` | Output mode for resume: `clipboard` or `stdout` |
+| `autoGitCapture` | boolean | `true` | Auto-detect and include git info |
+| `recentCommitCount` | number | `5` | Number of recent commits to capture |
+| `defaultLogCount` | number | `10` | Default number of log entries to show |
+| `watchInterval` | number | `5` | Auto-save interval in minutes for watch mode |
+| `autoHook` | boolean | `false` | Auto-install git hook on init |
+
+**Examples:**
+```bash
+# View all settings
+ctxsaver config list
+
+# Configure AI settings
+ctxsaver config set aiApiKey "sk-..."
+ctxsaver config set aiProvider "https://api.openai.com/v1"
+ctxsaver config set aiModel "gpt-4o"
+ctxsaver config set aiMaxTokens 16384
+
+# Increase max tokens if summaries are getting truncated
+ctxsaver config set aiMaxTokens 32000
+
+# Configure behavior
+ctxsaver config set defaultOutput "stdout"
+ctxsaver config set recentCommitCount 10
+ctxsaver config set watchInterval 3
+
+# Get a specific value
+ctxsaver config get aiModel
+```
+
+## Integrations
+
+### 💻 Direct CLI Usage
+Any AI agent with terminal access (e.g. via `run_command` or similar tools) can directly run `ctxsaver save`, `resume`, and `log`.
+
+## How It Works
+
+CtxSaver stores a `.ctxsaver/` folder in your repo. Each entry captures:
+- **Task**: What you are doing
+- **Goal**: Why you are doing it
+- **Approaches**: What you tried (and what failed)
+- **Decisions**: Key architectural choices
+- **State**: Where you left off
+
+It works with **every** AI coding tool because it simply manages the *prompt* — the universal interface for LLMs.
+

package/dist/commands/compress.d.ts

@@ -0,0 +1,3 @@
+export declare function compressCommand(options?: {
+    force?: boolean;
+}): Promise<void>;

package/dist/commands/compress.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressCommand = compressCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const context_1 = require("../core/context");
+const git_1 = require("../core/git");
+const ai_1 = require("../core/ai");
+async function compressCommand(options) {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ CtxSaver not initialized. Run `ctxsaver init` first."));
+        return;
+    }
+    try {
+        const branch = await (0, git_1.getCurrentBranch)();
+        const entries = await (0, context_1.loadBranchContext)(branch);
+        if (entries.length <= 2) {
+            console.log(chalk_1.default.yellow("⚠ Not enough context to compress (need at least 3 entries)."));
+            return;
+        }
+        console.log(chalk_1.default.gray(`  Compressing ${entries.length} entries for branch: ${branch}...`));
+        // Keep the most recent entry intact, compress older ones
+        const toCompress = entries.slice(0, -1);
+        const latest = entries[entries.length - 1];
+        const prompt = `You are a developer assistant. Compress the following ${toCompress.length} coding session entries into a single summary entry. Keep only the most important information: key decisions, approaches that worked or failed, and overall progress.
+
+Sessions to compress:
+${toCompress
+            .map((e, i) => `
+Session ${i + 1} (${e.timestamp}):
+- Task: ${e.task}
+- Approaches: ${e.approaches.join(", ") || "none"}
+- Decisions: ${e.decisions.join(", ") || "none"}
+- State: ${e.currentState}
+- Next steps: ${e.nextSteps.join(", ") || "none"}
+`)
+            .join("\n")}
+
+Generate a JSON response:
+{
+  "task": "overall task description covering all sessions",
+  "approaches": ["significant approaches tried"],
+  "decisions": ["key decisions made across all sessions"],
+  "currentState": "where things stood after these sessions",
+  "nextSteps": ["remaining next steps"]
+}
+
+Be concise but preserve important decisions and learnings.`;
+        const result = await (0, ai_1.callAI)([
+            {
+                role: "system",
+                content: "You are a helpful assistant. Always respond with valid JSON.",
+            },
+            { role: "user", content: prompt },
+        ]);
+        if (result.error) {
+            console.log(chalk_1.default.red(`✗ ${result.error}`));
+            return;
+        }
+        let parsed;
+        try {
+            const jsonMatch = result.content.match(/```(?:json)?\s*([\s\S]*?)```/) ||
+                [null, result.content];
+            parsed = JSON.parse(jsonMatch[1].trim());
+        }
+        catch {
+            console.log(chalk_1.default.red("✗ Could not parse AI compression result."));
+            return;
+        }
+        // Create compressed entry from the oldest entry's metadata
+        const compressed = {
+            ...toCompress[0],
+            task: parsed.task || toCompress[0].task,
+            approaches: parsed.approaches || [],
+            decisions: parsed.decisions || [],
+            currentState: parsed.currentState || "",
+            nextSteps: parsed.nextSteps || [],
+            timestamp: toCompress[0].timestamp, // keep oldest timestamp
+        };
+        // Replace branch file with compressed + latest
+        const dir = await (0, context_1.getCtxSaverDir)();
+        const branchFile = path_1.default.join(dir, "branches", `${branch.replace(/\//g, "__")}.json`);
+        const newEntries = [compressed, latest];
+        fs_1.default.writeFileSync(branchFile, JSON.stringify(newEntries, null, 2));
+        console.log(chalk_1.default.green(`✓ Compressed ${entries.length} entries → 2 entries for branch: ${chalk_1.default.bold(branch)}`));
+        console.log(chalk_1.default.gray(`  Kept: 1 compressed summary + latest entry`));
+        console.log(chalk_1.default.cyan(`  Summary: ${parsed.task}`));
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/config-cmd.d.ts

@@ -0,0 +1 @@
+export declare function configCommand(action?: string, key?: string, value?: string): Promise<void>;

package/dist/commands/config-cmd.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configCommand = configCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const context_1 = require("../core/context");
+const config_1 = require("../utils/config");
+const VALID_KEYS = [
+    "defaultOutput",
+    "autoGitCapture",
+    "recentCommitCount",
+    "defaultLogCount",
+    "watchInterval",
+    "autoHook",
+    "aiProvider",
+    "aiModel",
+    "aiApiKey",
+    "aiMaxTokens",
+];
+async function configCommand(action, key, value) {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ CtxSaver not initialized. Run `ctxsaver init` first."));
+        return;
+    }
+    try {
+        const config = await (0, config_1.loadConfig)();
+        if (!action || action === "list") {
+            console.log(chalk_1.default.bold("\nCtxSaver Configuration:\n"));
+            for (const [k, v] of Object.entries(config)) {
+                if (k === "aiApiKey" && v) {
+                    console.log(`  ${chalk_1.default.cyan(k)}: ${chalk_1.default.gray("****" + String(v).slice(-4))}`);
+                }
+                else {
+                    console.log(`  ${chalk_1.default.cyan(k)}: ${chalk_1.default.white(String(v))}`);
+                }
+            }
+            console.log();
+            return;
+        }
+        if (action === "get") {
+            if (!key) {
+                console.log(chalk_1.default.red("✗ Usage: ctxsaver config get <key>"));
+                return;
+            }
+            if (!VALID_KEYS.includes(key)) {
+                console.log(chalk_1.default.red(`✗ Unknown config key: ${key}`));
+                console.log(chalk_1.default.gray(`  Valid keys: ${VALID_KEYS.join(", ")}`));
+                return;
+            }
+            const val = config[key];
+            console.log(`${chalk_1.default.cyan(key)}: ${chalk_1.default.white(String(val ?? "(not set)"))}`);
+            return;
+        }
+        if (action === "set") {
+            if (!key || value === undefined) {
+                console.log(chalk_1.default.red("✗ Usage: ctxsaver config set <key> <value>"));
+                return;
+            }
+            if (!VALID_KEYS.includes(key)) {
+                console.log(chalk_1.default.red(`✗ Unknown config key: ${key}`));
+                console.log(chalk_1.default.gray(`  Valid keys: ${VALID_KEYS.join(", ")}`));
+                return;
+            }
+            // Type coercion
+            let typedValue = value;
+            if (value === "true")
+                typedValue = true;
+            else if (value === "false")
+                typedValue = false;
+            else if (!isNaN(Number(value)) && !["aiApiKey", "aiProvider", "aiModel", "defaultOutput"].includes(key)) {
+                typedValue = Number(value);
+            }
+            await (0, config_1.saveConfig)({ [key]: typedValue });
+            console.log(chalk_1.default.green(`✓ Set ${chalk_1.default.bold(key)} = ${typedValue}`));
+            return;
+        }
+        console.log(chalk_1.default.red(`✗ Unknown action: ${action}`));
+        console.log(chalk_1.default.gray("  Usage: ctxsaver config [list|get|set] [key] [value]"));
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/diff.d.ts

@@ -0,0 +1 @@
+export declare function diffCommand(): Promise<void>;

package/dist/commands/diff.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffCommand = diffCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const context_1 = require("../core/context");
+const git_1 = require("../core/git");
+function getTimeAgo(timestamp) {
+    const diff = Date.now() - new Date(timestamp).getTime();
+    const minutes = Math.floor(diff / 60000);
+    if (minutes < 60)
+        return `${minutes} minutes ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} hours ago`;
+    const days = Math.floor(hours / 24);
+    return `${days} days ago`;
+}
+async function diffCommand() {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ CtxSaver not initialized. Run `ctxsaver init` first."));
+        return;
+    }
+    try {
+        const branch = await (0, git_1.getCurrentBranch)();
+        const entries = await (0, context_1.loadBranchContext)(branch);
+        if (entries.length === 0) {
+            console.log(chalk_1.default.yellow(`⚠ No context found for branch: ${branch}`));
+            console.log(chalk_1.default.gray("  Run `ctxsaver save` to capture context first."));
+            return;
+        }
+        const latest = entries[entries.length - 1];
+        const [currentChanged, currentStaged] = await Promise.all([
+            (0, git_1.getChangedFiles)(),
+            (0, git_1.getStagedFiles)(),
+        ]);
+        const lastSaveTime = getTimeAgo(latest.timestamp);
+        console.log(chalk_1.default.bold(`\nSince last save (${lastSaveTime}):\n`));
+        // --- Files ---
+        const previousFiles = new Set(latest.filesChanged);
+        const currentFiles = new Set([...currentChanged, ...currentStaged]);
+        const newFiles = [...currentFiles].filter((f) => !previousFiles.has(f));
+        const removedFiles = [...previousFiles].filter((f) => !currentFiles.has(f));
+        const stillChanged = [...currentFiles].filter((f) => previousFiles.has(f));
+        if (newFiles.length > 0) {
+            newFiles.forEach((f) => console.log(`  ${chalk_1.default.green("+")} ${f} ${chalk_1.default.green("(new)")}`));
+        }
+        if (stillChanged.length > 0) {
+            stillChanged.forEach((f) => console.log(`  ${chalk_1.default.yellow("~")} ${f} ${chalk_1.default.gray("(still modified)")}`));
+        }
+        if (removedFiles.length > 0) {
+            removedFiles.forEach((f) => console.log(`  ${chalk_1.default.red("-")} ${f} ${chalk_1.default.gray("(resolved)")}`));
+        }
+        if (newFiles.length === 0 && removedFiles.length === 0 && stillChanged.length === 0) {
+            console.log(chalk_1.default.gray("  No file changes since last save."));
+        }
+        // --- Decisions ---
+        if (entries.length >= 2) {
+            const previous = entries[entries.length - 2];
+            const prevDecisions = new Set(previous.decisions);
+            const newDecisions = latest.decisions.filter((d) => !prevDecisions.has(d));
+            if (newDecisions.length > 0) {
+                console.log();
+                newDecisions.forEach((d) => console.log(`  ${chalk_1.default.cyan("Decision added:")} "${d}"`));
+            }
+        }
+        else if (latest.decisions.length > 0) {
+            console.log();
+            latest.decisions.forEach((d) => console.log(`  ${chalk_1.default.cyan("Decision:")} "${d}"`));
+        }
+        // --- Next Steps Progress ---
+        if (entries.length >= 2) {
+            const previous = entries[entries.length - 2];
+            const completedSteps = previous.nextSteps.filter((step) => !latest.nextSteps.includes(step));
+            if (completedSteps.length > 0) {
+                console.log();
+                completedSteps.forEach((s) => console.log(`  ${chalk_1.default.green("✓")} Next step completed: "${s}"`));
+            }
+            const newSteps = latest.nextSteps.filter((step) => !previous.nextSteps.includes(step));
+            if (newSteps.length > 0) {
+                newSteps.forEach((s) => console.log(`  ${chalk_1.default.blue("→")} New next step: "${s}"`));
+            }
+        }
+        // --- Summary line ---
+        const totalNew = newFiles.length;
+        const totalModified = stillChanged.length;
+        const totalResolved = removedFiles.length;
+        console.log();
+        console.log(chalk_1.default.gray(`  Summary: +${totalNew} new, ~${totalModified} modified, -${totalResolved} resolved`));
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/handoff.d.ts

@@ -0,0 +1 @@
+export declare function handoffCommand(assignee?: string, message?: string): Promise<void>;

package/dist/commands/handoff.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handoffCommand = handoffCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const uuid_1 = require("uuid");
+const context_1 = require("../core/context");
+const git_1 = require("../core/git");
+async function handoffCommand(assignee, message) {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ CtxSaver not initialized. Run `ctxsaver init` first."));
+        return;
+    }
+    try {
+        // Clean up @ prefix if present
+        let targetAssignee = assignee?.replace(/^@/, "") || "";
+        let handoffNote = message || "";
+        if (!targetAssignee || !handoffNote) {
+            const answers = await inquirer_1.default.prompt([
+                ...(!targetAssignee
+                    ? [
+                        {
+                            type: "input",
+                            name: "assignee",
+                            message: "Who are you handing off to?",
+                            validate: (input) => input.length > 0 || "Assignee is required",
+                        },
+                    ]
+                    : []),
+                ...(!handoffNote
+                    ? [
+                        {
+                            type: "input",
+                            name: "handoffNote",
+                            message: "Handoff note (what they need to know):",
+                            validate: (input) => input.length > 0 || "Handoff note is required",
+                        },
+                    ]
+                    : []),
+                {
+                    type: "input",
+                    name: "task",
+                    message: "What were you working on?",
+                    validate: (input) => input.length > 0 || "Task description is required",
+                },
+                {
+                    type: "input",
+                    name: "currentState",
+                    message: "Where did you leave off?",
+                    validate: (input) => input.length > 0 || "Current state is required",
+                },
+                {
+                    type: "input",
+                    name: "nextSteps",
+                    message: "What comes next? (comma-separated)",
+                    default: "",
+                },
+                {
+                    type: "input",
+                    name: "blockers",
+                    message: "Any blockers? (comma-separated)",
+                    default: "",
+                },
+            ]);
+            targetAssignee = targetAssignee || answers.assignee;
+            handoffNote = handoffNote || answers.handoffNote;
+            const [branch, repo, filesChanged, filesStaged, recentCommits, author] = await Promise.all([
+                (0, git_1.getCurrentBranch)(),
+                (0, git_1.getRepoName)(),
+                (0, git_1.getChangedFiles)(),
+                (0, git_1.getStagedFiles)(),
+                (0, git_1.getRecentCommits)(),
+                (0, git_1.getAuthor)(),
+            ]);
+            const entry = {
+                id: (0, uuid_1.v4)(),
+                timestamp: new Date().toISOString(),
+                branch,
+                repo,
+                author,
+                task: answers.task,
+                approaches: [],
+                decisions: [],
+                currentState: answers.currentState,
+                nextSteps: answers.nextSteps
+                    ? answers.nextSteps
+                        .split(",")
+                        .map((s) => s.trim())
+                        .filter(Boolean)
+                    : [],
+                blockers: answers.blockers
+                    ? answers.blockers
+                        .split(",")
+                        .map((s) => s.trim())
+                        .filter(Boolean)
+                    : undefined,
+                filesChanged,
+                filesStaged,
+                recentCommits,
+                assignee: targetAssignee,
+                handoffNote,
+            };
+            await (0, context_1.saveContext)(entry);
+            console.log(chalk_1.default.green(`\n✓ Handoff created for ${chalk_1.default.bold("@" + targetAssignee)}`));
+            console.log(chalk_1.default.gray(`  Branch: ${branch}`));
+            console.log(chalk_1.default.cyan(`\n  📝 Handoff Note:`));
+            console.log(chalk_1.default.white(`  ${handoffNote}\n`));
+            console.log(chalk_1.default.gray(`  They can resume with: ${chalk_1.default.white("ctxsaver resume --branch " + branch)}`));
+        }
+        else {
+            // Quick mode — minimal context with handoff
+            const [branch, repo, filesChanged, filesStaged, recentCommits, author] = await Promise.all([
+                (0, git_1.getCurrentBranch)(),
+                (0, git_1.getRepoName)(),
+                (0, git_1.getChangedFiles)(),
+                (0, git_1.getStagedFiles)(),
+                (0, git_1.getRecentCommits)(),
+                (0, git_1.getAuthor)(),
+            ]);
+            const entry = {
+                id: (0, uuid_1.v4)(),
+                timestamp: new Date().toISOString(),
+                branch,
+                repo,
+                author,
+                task: `Handoff to @${targetAssignee}`,
+                approaches: [],
+                decisions: [],
+                currentState: handoffNote,
+                nextSteps: [],
+                filesChanged,
+                filesStaged,
+                recentCommits,
+                assignee: targetAssignee,
+                handoffNote,
+            };
+            await (0, context_1.saveContext)(entry);
+            console.log(chalk_1.default.green(`\n✓ Handoff created for ${chalk_1.default.bold("@" + targetAssignee)}`));
+            console.log(chalk_1.default.gray(`  Branch: ${branch}`));
+            console.log(chalk_1.default.cyan(`\n  📝 Handoff Note:`));
+            console.log(chalk_1.default.white(`  ${handoffNote}\n`));
+            console.log(chalk_1.default.gray(`  They can resume with: ${chalk_1.default.white("ctxsaver resume --branch " + branch)}`));
+        }
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/hook.d.ts

@@ -0,0 +1 @@
+export declare function hookCommand(action?: string): Promise<void>;