@dtoolkit/dcontext 0.0.3 → 0.1.0

package/README.md

@@ -1,33 +1,155 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/ivncmp/dtoolkit/main/logo.png" alt="dtoolkit" />
+  <img src="../../logo.png" alt="dtoolkit" />
 </p>
 
 <h1 align="center">@dtoolkit/dcontext</h1>
-<p align="center">Tool cache + background compactor for AI coding agents</p>
+<p align="center">dbrain hooks for AI coding CLIs</p>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/@dtoolkit/dcontext"><img src="https://img.shields.io/npm/v/@dtoolkit/dcontext.svg" alt="npm"></a>
   <a href="../../LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License"></a>
 </p>
 
-> **Status:** not yet implemented
+Hook-based bridge between [dbrain](../dbrain/) and AI coding CLIs. Injects your identity, soul, and project facts at session start so the AI already knows everything — no need to call `recall`. Also saves key exchanges to dbrain before context compaction.
 
-## What it does
+Requires a running [dbrain](../dbrain/) instance.
 
-dcontext runs **locally** on the developer's machine and optimizes the agent's context window in real time:
+## Works with
 
-- **Tool cache** — content-addressable cache of tool outputs to avoid redundant reads
-- **Background compactor** — compresses context with a fast model (Haiku) while the dev thinks, eliminating the compaction pause
-- **Context doctor** — detects and warns about context bloat before it impacts quality
-- **Fact extraction** — extracts reusable knowledge during compaction and stores it in dbrain
+| CLI | Hook mechanism | Status |
+|-----|---------------|--------|
+| **Claude Code** | Hooks in `~/.claude/settings.json` | v1 |
+| **Codex CLI** | Hooks in `~/.codex/config.toml` | v1 |
+| **Gemini CLI** | Hooks in `~/.gemini/settings.json` | v1 |
+| **OpenCode** | In-process npm plugin | v1 |
 
-## Design
+## Install
 
-dcontext is **not** memory (that's dbrain) — it's a cache with TTL. It doesn't know the provider (that's dproxy) and doesn't format briefings (that's dprime).
+```bash
+npm install -g @dtoolkit/dcontext
+```
+
+## Quick start
 
 ```bash
-dproxy chat --context dcontext              # enable context optimization
-dproxy ask "x" --memory dbrain --context dcontext --prime .  # full stack
+# 1. Connect to dbrain and map your project
+dcontext init
+# ? How do you want to connect to dbrain? → Connect to existing dbrain
+# ? dbrain URL: http://localhost:7878
+# ? dbrain token: sk-dbr_...
+# ? Map /Users/you/my-project to entity: → my-project
+
+# 2. Install hooks for your CLI
+dcontext install claude
+
+# 3. Start coding — sessions start warm
+claude
+# → Session Context (from dbrain) is injected automatically
+# → Identity, soul, user profile, and project facts already loaded
+# → No recall needed at start
+```
+
+## How it works
+
+dcontext hooks into two moments of a session's lifecycle:
+
+| Moment | What happens |
+|--------|-------------|
+| **Session start** | Searches dbrain for project facts, loads identity/soul/user docs, injects as `additionalContext` |
+| **Pre-compaction** | Reads the session transcript, extracts meaningful exchanges, saves to dbrain as a conversation |
+
+The AI receives the context transparently via hooks — it never calls dcontext directly.
+
+```
+┌─────────────────┐     SessionStart      ┌─────────────┐
+│   Claude Code   │◄─────────────────────  │  dcontext    │
+│   Gemini CLI    │  additionalContext     │  (hooks)     │
+│   OpenCode      │                        │              │
+│                 │     PreCompact         │              │
+│                 │─────────────────────►  │              │
+└─────────────────┘  transcript            └──────┬───────┘
+                                                  │
+                                           search / save
+                                                  │
+                                           ┌──────▼───────┐
+                                           │    dbrain     │
+                                           │  (memory)     │
+                                           └──────────────┘
+```
+
+### What gets injected
+
+The session briefing includes (in order):
+
+1. **Identity** — who the AI is (name, creation date)
+2. **Soul** — behavioral guidelines
+3. **User** — who you are (name, timezone)
+4. **Project facts** — recent decisions, milestones, preferences, context (up to 15 facts, truncated to 200 chars each)
+
+Total briefing capped at 8000 characters.
+
+### Instruction file integration
+
+When you run `dcontext install <target>`, it modifies the dbrain section in the client's instruction file to tell the AI **not to call `recall` at session start** — since the context is already injected. Run `dbrain connect <target>` to restore the original dbrain instructions after uninstalling.
+
+| Target | Instruction file |
+|--------|-----------------|
+| `claude` | `~/.claude/CLAUDE.md` |
+| `codex` | `~/.codex/AGENTS.md` |
+| `gemini` | `~/.gemini/GEMINI.md` |
+| `opencode` | `~/.config/opencode/AGENTS.md` |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `dcontext init` | Interactive setup — connect to dbrain, map projects |
+| `dcontext install <target>` | Install hooks (`claude`, `codex`, `gemini`, `opencode`) |
+| `dcontext uninstall <target>` | Remove hooks |
+| `dcontext status` | Show config, targets, project mappings, stats |
+| `dcontext explore` | Preview the briefing that would be injected for the current directory |
+| `dcontext hook <event>` | Internal — called by CLI hooks, not for direct use |
+
+## Configuration
+
+Config at `~/.dcontext/config.json` (created by `dcontext init`):
+
+```json
+{
+  "initialized": true,
+  "dbrain": {
+    "url": "http://localhost:7878",
+    "token": "sk-dbr_..."
+  },
+  "projects": {
+    "/Users/you/my-project": "my-project"
+  },
+  "briefing": {
+    "maxFacts": 15,
+    "includeIdentity": true,
+    "maxChars": 8000,
+    "maxCharsPerFact": 200
+  }
+}
+```
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `dbrain.url` | — | dbrain server URL |
+| `dbrain.token` | — | Bearer token for dbrain API |
+| `projects` | `{}` | Maps absolute cwd path to dbrain entity name |
+| `briefing.maxFacts` | `15` | Max facts to include in briefing |
+| `briefing.includeIdentity` | `true` | Include identity, soul, and user docs |
+| `briefing.maxChars` | `8000` | Max total briefing length |
+| `briefing.maxCharsPerFact` | `200` | Max characters per individual fact |
+
+## Data storage
+
+```
+~/.dcontext/
+├── config.json     # Configuration (created by init)
+├── stats.json      # Usage statistics (briefings served, extractions done)
+└── error.log       # Hook errors (hooks never crash — they log and exit 0)
 ```
 
 ## License

package/dist/index.js

@@ -1,3 +1,814 @@
-export {};
-// placeholder
-//# sourceMappingURL=index.js.map
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command7 } from "commander";
+import pc6 from "picocolors";
+
+// src/commands/explore.ts
+import { Command } from "commander";
+import pc from "picocolors";
+
+// src/core/briefing.ts
+import { DBrainClient } from "@dtoolkit/sdk";
+function cleanDocContent(content, sectionTitle) {
+  const lines = content.split("\n");
+  const cleaned = [];
+  let prevEmpty = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) {
+      const headerText = trimmed.replace(/^#+\s*/, "").trim().toLowerCase();
+      if (headerText === sectionTitle.toLowerCase()) continue;
+    }
+    if (trimmed === "") {
+      if (prevEmpty) continue;
+      prevEmpty = true;
+    } else {
+      prevEmpty = false;
+    }
+    cleaned.push(line);
+  }
+  while (cleaned.length > 0 && cleaned[0].trim() === "") cleaned.shift();
+  while (cleaned.length > 0 && cleaned[cleaned.length - 1].trim() === "") cleaned.pop();
+  return cleaned.join("\n");
+}
+function truncateFact(fact, max) {
+  if (fact.length <= max) return fact;
+  return fact.slice(0, max - 1) + "\u2026";
+}
+async function generateBriefing(projectEntity, config) {
+  const client = new DBrainClient(config.dbrain.url, config.dbrain.token);
+  const safeQuery = `"${projectEntity}"`;
+  const [results, documents] = await Promise.all([
+    client.search(safeQuery, { limit: config.briefing.maxFacts }).catch(() => []),
+    config.briefing.includeIdentity ? client.listDocuments() : Promise.resolve([])
+  ]);
+  if (results.length === 0 && documents.length === 0) return null;
+  const parts = [];
+  parts.push("## Session Context (from dbrain)");
+  parts.push(
+    "> **DO NOT call `recall` or `wake_up`.** Your identity, soul, user profile, and project facts are already below. This context was injected by dcontext at session start."
+  );
+  if (config.briefing.includeIdentity && documents.length > 0) {
+    const identityDocs = documents.filter(
+      (d) => d.key === "identity" || d.key === "user" || d.key === "soul"
+    );
+    for (const doc of identityDocs) {
+      try {
+        const full = await client.getDocument(doc.key);
+        if (full.content) {
+          const title = doc.title || doc.key;
+          const cleaned = cleanDocContent(full.content, title);
+          if (cleaned) {
+            parts.push("");
+            parts.push(`### ${title}`);
+            parts.push(cleaned);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (results.length > 0) {
+    parts.push("");
+    parts.push(`### Project: ${projectEntity}`);
+    for (const r of results) {
+      const category = r.fact.category || "context";
+      parts.push(`- [${category}] ${truncateFact(r.fact.fact, config.briefing.maxCharsPerFact)}`);
+    }
+  }
+  let briefing = parts.join("\n");
+  if (briefing.length > config.briefing.maxChars) {
+    briefing = briefing.slice(0, config.briefing.maxChars - 3) + "\u2026";
+  }
+  return briefing;
+}
+
+// src/core/config.ts
+import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var DATA_DIR = process.env.DCONTEXT_DATA_DIR || join(homedir(), ".dcontext");
+var DEFAULT_CONFIG = {
+  initialized: false,
+  dbrain: {
+    url: "",
+    token: ""
+  },
+  projects: {},
+  briefing: {
+    maxFacts: 15,
+    includeIdentity: true,
+    maxChars: 8e3,
+    maxCharsPerFact: 200
+  },
+  targets: {
+    claude: { installed: false },
+    codex: { installed: false },
+    gemini: { installed: false },
+    opencode: { installed: false }
+  }
+};
+var DEFAULT_STATS = {
+  briefings: { total: 0 },
+  extractions: { total: 0, messagesSaved: 0 },
+  byTarget: {}
+};
+function getDataDir() {
+  return DATA_DIR;
+}
+async function ensureDataDir() {
+  await mkdir(DATA_DIR, { recursive: true });
+}
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key in overrides) {
+    if (typeof defaults[key] === "object" && defaults[key] !== null && !Array.isArray(defaults[key]) && typeof overrides[key] === "object" && overrides[key] !== null && !Array.isArray(overrides[key])) {
+      result[key] = deepMerge(
+        defaults[key],
+        overrides[key]
+      );
+    } else {
+      result[key] = overrides[key];
+    }
+  }
+  return result;
+}
+async function atomicWriteFile(filePath, data) {
+  const tmp = filePath + ".tmp";
+  await writeFile(tmp, data, "utf-8");
+  await rename(tmp, filePath);
+}
+async function loadConfig() {
+  try {
+    const raw = await readFile(join(DATA_DIR, "config.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(
+      DEFAULT_CONFIG,
+      parsed
+    );
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+async function saveConfig(config) {
+  await ensureDataDir();
+  await atomicWriteFile(join(DATA_DIR, "config.json"), JSON.stringify(config, null, 2) + "\n");
+}
+async function loadStats() {
+  try {
+    const raw = await readFile(join(DATA_DIR, "stats.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(
+      DEFAULT_STATS,
+      parsed
+    );
+  } catch {
+    return { ...DEFAULT_STATS };
+  }
+}
+async function updateStats(fn) {
+  const stats = await loadStats();
+  fn(stats);
+  await ensureDataDir();
+  await atomicWriteFile(join(DATA_DIR, "stats.json"), JSON.stringify(stats, null, 2) + "\n");
+}
+async function logError(message) {
+  try {
+    await ensureDataDir();
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`;
+    await appendFile(join(DATA_DIR, "error.log"), line, "utf-8");
+  } catch {
+  }
+}
+
+// src/commands/explore.ts
+function createExploreCommand() {
+  return new Command("explore").description("Preview the context that would be injected for a directory").argument("[path]", "Directory to explore (defaults to cwd)").action(async (path) => {
+    try {
+      await runExplore(path);
+    } catch (err) {
+      console.error(pc.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+async function runExplore(path) {
+  const cwd = path || process.cwd();
+  const config = await loadConfig();
+  if (!config.dbrain.url) {
+    console.error(pc.red("dcontext not configured. Run: dcontext init"));
+    process.exit(1);
+  }
+  const entity = config.projects[cwd];
+  if (!entity) {
+    console.log(pc.dim(`No entity mapped for ${cwd}`));
+    console.log();
+    const projects = Object.entries(config.projects);
+    if (projects.length > 0) {
+      console.log(pc.bold("Mapped directories:"));
+      for (const [p2, e] of projects) {
+        console.log(`  ${pc.dim(p2)} \u2192 ${pc.blue(e)}`);
+      }
+    } else {
+      console.log(`Run ${pc.cyan("dcontext init")} in a project directory to map it.`);
+    }
+    return;
+  }
+  console.log(pc.bold("Context preview") + pc.dim(` \u2014 ${cwd} \u2192 ${entity}`));
+  console.log();
+  const briefing = await generateBriefing(entity, config);
+  if (!briefing) {
+    console.log(pc.dim("No context found in dbrain for this project."));
+    return;
+  }
+  console.log(briefing);
+  console.log();
+  console.log(pc.dim(`${briefing.length} chars \u2014 max ${config.briefing.maxChars}`));
+}
+
+// src/commands/hook.ts
+import { Command as Command2 } from "commander";
+
+// src/core/extraction.ts
+import { DBrainClient as DBrainClient2 } from "@dtoolkit/sdk";
+async function extractAndSave(sessionId, target, cwd, config) {
+  const transcriptPath = target.resolveTranscriptPath(sessionId, cwd);
+  let entries;
+  try {
+    entries = await target.parseTranscript(transcriptPath);
+  } catch (err) {
+    await logError(`Failed to parse transcript: ${err.message}`);
+    return null;
+  }
+  const filtered = entries.filter((e) => e.content.length >= 50);
+  if (filtered.length === 0) return null;
+  const messages = filtered.map((e) => ({ role: e.role, content: e.content }));
+  try {
+    const client = new DBrainClient2(config.dbrain.url, config.dbrain.token);
+    const conv = await client.startConversation(`dcontext-${target.name}`);
+    await client.sendMessages(conv.id, messages);
+  } catch (err) {
+    await logError(`Failed to save to dbrain: ${err.message}`);
+  }
+  await updateStats((stats) => {
+    stats.extractions.total++;
+    stats.extractions.lastAt = (/* @__PURE__ */ new Date()).toISOString();
+    stats.extractions.messagesSaved += messages.length;
+    if (!stats.byTarget[target.name]) {
+      stats.byTarget[target.name] = { briefings: 0, extractions: 0 };
+    }
+    stats.byTarget[target.name].extractions++;
+  });
+  return `Session log saved to dbrain (${messages.length} messages from ${target.name})`;
+}
+
+// src/commands/targets.ts
+import { createClaudeTarget } from "@dtoolkit/adapter-claude";
+import { createCodexTarget } from "@dtoolkit/adapter-codex";
+import { createGeminiTarget } from "@dtoolkit/adapter-gemini";
+import { createOpenCodeTarget } from "@dtoolkit/adapter-opencode";
+var targets = {
+  claude: createClaudeTarget,
+  codex: createCodexTarget,
+  gemini: createGeminiTarget,
+  opencode: createOpenCodeTarget
+};
+function resolveTarget(name) {
+  const factory = targets[name];
+  return factory ? factory() : null;
+}
+
+// src/commands/hook.ts
+function createHookCommand() {
+  return new Command2("hook").description("Handle hook events (internal \u2014 called by CLI hooks)").argument("<event>", "Hook event: session-start, pre-compact").option("--target <name>", "Explicit target override (claude, codex, gemini, opencode)").action(async (event, opts) => {
+    try {
+      await runHook(event, opts.target);
+    } catch (err) {
+      await logError(`hook ${event}: ${err.message}`);
+      process.stdout.write("{}");
+    }
+  });
+}
+function readStdinRaw() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve("{}");
+      return;
+    }
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data || "{}"));
+  });
+}
+function detectTarget(env) {
+  for (const name of ["claude", "codex", "gemini", "opencode"]) {
+    const target = resolveTarget(name);
+    if (target?.detectFromEnv(env)) return target;
+  }
+  return resolveTarget("claude");
+}
+async function runHook(event, explicitTarget) {
+  const raw = await readStdinRaw();
+  let input = {};
+  try {
+    input = JSON.parse(raw);
+  } catch {
+  }
+  const config = await loadConfig();
+  if (!config.dbrain.url) {
+    process.stdout.write("{}");
+    return;
+  }
+  const env = process.env;
+  const target = explicitTarget ? resolveTarget(explicitTarget) : detectTarget(env);
+  if (!target) {
+    process.stdout.write("{}");
+    return;
+  }
+  const cwd = input["cwd"] || env["GEMINI_CWD"] || env["GEMINI_PROJECT_DIR"] || process.cwd();
+  const sessionId = target.getSessionId(env, input);
+  if (event === "session-start") {
+    await handleSessionStart(target, cwd, config);
+  } else if (event === "pre-compact") {
+    await handlePreCompact(sessionId, target, cwd, config);
+  } else {
+    process.stdout.write("{}");
+  }
+}
+function formatOutput(target, event, context) {
+  if (target.name === "codex") {
+    return JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: event,
+        additionalContext: context
+      }
+    });
+  }
+  return JSON.stringify({ additionalContext: context });
+}
+async function handleSessionStart(target, cwd, config) {
+  const projectEntity = config.projects[cwd];
+  if (!projectEntity) {
+    process.stdout.write("{}");
+    return;
+  }
+  const briefing = await generateBriefing(projectEntity, config);
+  if (!briefing) {
+    process.stdout.write("{}");
+    return;
+  }
+  await updateStats((stats) => {
+    stats.briefings.total++;
+    stats.briefings.lastAt = (/* @__PURE__ */ new Date()).toISOString();
+  });
+  process.stdout.write(formatOutput(target, "SessionStart", briefing));
+}
+async function handlePreCompact(sessionId, target, cwd, config) {
+  if (!sessionId) {
+    process.stdout.write("{}");
+    return;
+  }
+  const notes = await extractAndSave(sessionId, target, cwd, config);
+  if (!notes) {
+    process.stdout.write("{}");
+    return;
+  }
+  process.stdout.write(formatOutput(target, "PreCompact", notes));
+}
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import { DBrainClient as DBrainClient3 } from "@dtoolkit/sdk";
+import { Command as Command3 } from "commander";
+import pc2 from "picocolors";
+function createInitCommand() {
+  return new Command3("init").description("Interactive setup wizard").action(async () => {
+    try {
+      await runInit();
+    } catch (err) {
+      if (err.message?.includes("cancelled")) process.exit(0);
+      console.error(pc2.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+async function runInit() {
+  p.intro(pc2.cyan("dcontext") + " \u2014 dbrain hooks for AI coding CLIs");
+  const config = await loadConfig();
+  if (config.initialized && config.dbrain.url) {
+    p.log.info(`Current dbrain: ${pc2.blue(config.dbrain.url)}`);
+    const cwd = process.cwd();
+    const entity = config.projects[cwd];
+    if (entity) {
+      p.log.info(`Current mapping: ${pc2.dim(cwd)} \u2192 ${pc2.blue(entity)}`);
+    }
+  }
+  const options = [
+    {
+      value: "connect",
+      label: "Connect to existing dbrain",
+      description: "I have a dbrain running already"
+    },
+    {
+      value: "local",
+      label: "Start a local dbrain",
+      description: "Initialize and start a new brain here"
+    }
+  ];
+  if (config.initialized && config.dbrain.url) {
+    options.unshift({
+      value: "remap",
+      label: "Keep dbrain, remap this directory",
+      description: `Change entity mapping for ${process.cwd()}`
+    });
+  }
+  const mode = await p.select({
+    message: config.initialized ? "What do you want to change?" : "How do you want to connect to dbrain?",
+    options
+  });
+  if (p.isCancel(mode)) {
+    p.cancel("Init cancelled.");
+    process.exit(0);
+  }
+  if (mode === "remap") {
+    await finishInit(config);
+  } else if (mode === "local") {
+    await startLocalDbrain(config);
+  } else {
+    await connectToDbrain(config);
+  }
+}
+async function startLocalDbrain(config) {
+  const s = p.spinner();
+  s.start("Checking dbrain CLI");
+  try {
+    const { execSync } = await import("child_process");
+    execSync("dbrain --help", { stdio: "ignore" });
+    s.stop("dbrain CLI found");
+  } catch {
+    s.stop(pc2.red("dbrain CLI not found"));
+    p.log.error("Install dbrain first: " + pc2.cyan("npm i -g @dtoolkit/dbrain"));
+    p.outro(pc2.red("Then run dcontext init again."));
+    process.exit(1);
+  }
+  const brainPath = await p.text({
+    message: "Brain path",
+    initialValue: `${process.env.HOME}/.dbrain`,
+    validate: (v) => !v ? "Path is required" : void 0
+  });
+  if (p.isCancel(brainPath)) {
+    p.cancel("Init cancelled.");
+    process.exit(0);
+  }
+  const s2 = p.spinner();
+  s2.start("Initializing and starting dbrain");
+  try {
+    const { execSync, spawn } = await import("child_process");
+    execSync(`dbrain init "${brainPath}"`, { stdio: "ignore" });
+    const child = spawn("dbrain", ["start", brainPath], {
+      stdio: "ignore",
+      detached: true
+    });
+    child.unref();
+    let healthy = false;
+    for (let i = 0; i < 10; i++) {
+      await new Promise((r) => setTimeout(r, 500));
+      try {
+        await new DBrainClient3("http://localhost:7878").health();
+        healthy = true;
+        break;
+      } catch {
+      }
+    }
+    if (!healthy) throw new Error("dbrain did not start in time");
+    let token = "";
+    try {
+      const { readFile: readFile2 } = await import("fs/promises");
+      const { join: join2 } = await import("path");
+      const dbrainConfig = JSON.parse(await readFile2(join2(brainPath, "config.json"), "utf-8"));
+      token = dbrainConfig.token || "";
+    } catch {
+    }
+    const client = new DBrainClient3("http://localhost:7878", token);
+    const health = await client.health();
+    s2.stop(
+      `dbrain running \u2014 ${pc2.green(String(health.entities))} entities, ${pc2.green(String(health.facts))} facts`
+    );
+    config.dbrain = { url: "http://localhost:7878", token };
+    await finishInit(config);
+  } catch (err) {
+    s2.stop(pc2.red("Failed to start dbrain"));
+    p.log.error(err.message);
+    p.outro(pc2.red("Try starting dbrain manually: dbrain start"));
+    process.exit(1);
+  }
+}
+async function connectToDbrain(config) {
+  const answers = await p.group(
+    {
+      url: () => p.text({
+        message: "dbrain URL",
+        initialValue: config.dbrain.url || "http://localhost:7878",
+        validate: (v) => !v ? "URL is required" : void 0
+      }),
+      token: () => p.text({
+        message: "dbrain token (empty if none)",
+        initialValue: config.dbrain.token || ""
+      })
+    },
+    {
+      onCancel: () => {
+        p.cancel("Init cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  const s = p.spinner();
+  s.start("Connecting to dbrain");
+  try {
+    const client = new DBrainClient3(answers.url, answers.token);
+    const health = await client.health();
+    s.stop(
+      `Connected \u2014 ${pc2.green(String(health.entities))} entities, ${pc2.green(String(health.facts))} facts`
+    );
+  } catch (err) {
+    s.stop(pc2.red("Connection failed"));
+    p.log.error(err.message);
+    p.outro(pc2.red("Check dbrain URL and token, then try again."));
+    process.exit(1);
+  }
+  config.dbrain = { url: answers.url, token: answers.token };
+  await finishInit(config);
+}
+async function finishInit(config) {
+  const client = new DBrainClient3(config.dbrain.url, config.dbrain.token);
+  let entityName;
+  try {
+    const entities = await client.listEntities();
+    if (entities.length > 0) {
+      const cwd = process.cwd();
+      const selected = await p.select({
+        message: `Map ${pc2.dim(cwd)} to entity:`,
+        options: [
+          ...entities.map((e) => ({
+            value: e.id,
+            label: `${e.name} (${e.type}, ${e.category})`
+          })),
+          { value: "__skip__", label: "Skip for now" },
+          { value: "__custom__", label: "Enter custom name..." }
+        ]
+      });
+      if (p.isCancel(selected)) {
+        p.cancel("Init cancelled.");
+        process.exit(0);
+      }
+      if (selected === "__custom__") {
+        const custom = await p.text({
+          message: "Entity name for this project",
+          validate: (v) => !v ? "Name is required" : void 0
+        });
+        if (p.isCancel(custom)) {
+          p.cancel("Init cancelled.");
+          process.exit(0);
+        }
+        entityName = custom;
+        try {
+          await client.createEntity({
+            id: custom.toLowerCase().replace(/\s+/g, "-"),
+            name: custom,
+            type: "project",
+            category: "projects"
+          });
+          p.log.success(`Entity ${pc2.blue(custom)} created in dbrain`);
+        } catch {
+        }
+      } else if (selected !== "__skip__") {
+        entityName = selected;
+      }
+      if (entityName) {
+        config.projects[cwd] = entityName;
+      }
+    }
+  } catch (err) {
+    p.log.warn(`Could not list entities: ${err.message}`);
+  }
+  config.initialized = true;
+  await saveConfig(config);
+  p.note(
+    [
+      `dbrain:  ${pc2.green(config.dbrain.url)}`,
+      entityName ? `Project: ${pc2.green(process.cwd())} \u2192 ${pc2.green(entityName)}` : "",
+      `Config:  ${pc2.green(getDataDir() + "/config.json")}`
+    ].filter(Boolean).join("\n"),
+    "Configuration"
+  );
+  p.outro(`Next: ${pc2.cyan("dcontext install claude")}`);
+}
+async function requireInit() {
+  const config = await loadConfig();
+  if (!config.initialized) {
+    console.error(pc2.red("dcontext is not initialized. Run: dcontext init"));
+    process.exit(1);
+  }
+}
+
+// src/commands/install.ts
+import { Command as Command4 } from "commander";
+import pc3 from "picocolors";
+function createInstallCommand() {
+  return new Command4("install").description("Install hooks for a target CLI").argument("<target>", "Target CLI: claude, gemini, opencode").action(async (targetName) => {
+    try {
+      await runInstall(targetName);
+    } catch (err) {
+      console.error(pc3.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+async function runInstall(targetName) {
+  const target = resolveTarget(targetName);
+  if (!target) {
+    console.error(pc3.red(`Unknown target: ${targetName}. Use: claude, gemini, opencode`));
+    process.exit(1);
+  }
+  const already = await target.isInstalled();
+  if (already) {
+    console.log(pc3.dim(`dcontext hooks already installed for ${target.name}`));
+    return;
+  }
+  await target.install();
+  const config = await loadConfig();
+  config.targets[target.name] = {
+    installed: true,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveConfig(config);
+  console.log(pc3.green(`\u2713 Hooks installed for ${target.name}`));
+  if (target.name === "claude") {
+    console.log(pc3.dim(`  ~/.claude/CLAUDE.md updated with dcontext instructions`));
+  }
+}
+
+// src/commands/status.ts
+import { DBrainClient as DBrainClient4 } from "@dtoolkit/sdk";
+import { Command as Command5 } from "commander";
+import pc4 from "picocolors";
+function createStatusCommand() {
+  return new Command5("status").description("Show configuration, context, and stats").action(async () => {
+    try {
+      await runStatus();
+    } catch (err) {
+      console.error(pc4.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+async function runStatus() {
+  const config = await loadConfig();
+  const stats = await loadStats();
+  console.log(pc4.bold("dcontext status"));
+  console.log();
+  console.log(pc4.bold("dbrain"));
+  const { url, token } = config.dbrain;
+  if (url) {
+    try {
+      const client = new DBrainClient4(url, token);
+      const health = await client.health();
+      console.log(`  ${pc4.green(url)} \u2014 ${health.entities} entities, ${health.facts} facts`);
+    } catch {
+      console.log(`  ${pc4.red(url)} (unreachable)`);
+    }
+  } else {
+    console.log(`  ${pc4.red("not configured")} \u2014 run ${pc4.cyan("dcontext init")}`);
+  }
+  console.log();
+  console.log(pc4.bold("Targets"));
+  for (const name of ["claude", "gemini", "opencode"]) {
+    const target = resolveTarget(name);
+    if (!target) continue;
+    const installed = await target.isInstalled();
+    const cfg = config.targets[name];
+    if (installed) {
+      const since = cfg?.installedAt ? ` (since ${cfg.installedAt.split("T")[0]})` : "";
+      console.log(`  ${name}: ${pc4.green("installed")}${pc4.dim(since)}`);
+    } else {
+      console.log(`  ${name}: ${pc4.dim("not installed")}`);
+    }
+  }
+  console.log();
+  const cwd = process.cwd();
+  const entity = config.projects[cwd];
+  console.log(pc4.bold("Context") + pc4.dim(` (${cwd})`));
+  if (entity) {
+    console.log(`  Entity: ${pc4.blue(entity)}`);
+    if (url) {
+      try {
+        const client = new DBrainClient4(url, token);
+        const results = await client.search(`"${entity}"`, { limit: 5 });
+        if (results.length > 0) {
+          console.log(`  Facts:  ${pc4.green(String(results.length))}+ matching`);
+          for (const r of results.slice(0, 3)) {
+            console.log(`    ${pc4.dim("\xB7")} ${r.fact.fact.slice(0, 80)}`);
+          }
+          if (results.length > 3) {
+            console.log(`    ${pc4.dim(`... and ${results.length - 3} more`)}`);
+          }
+        } else {
+          console.log(`  Facts:  ${pc4.dim("none found")}`);
+        }
+      } catch {
+        console.log(`  Facts:  ${pc4.dim("could not query")}`);
+      }
+    }
+  } else {
+    console.log(
+      `  ${pc4.dim("no entity mapped")} \u2014 run ${pc4.cyan("dcontext init")} in this directory`
+    );
+  }
+  console.log();
+  const projects = Object.entries(config.projects).filter(([path]) => path !== cwd);
+  if (projects.length > 0) {
+    console.log(pc4.bold("Other projects"));
+    for (const [path, ent] of projects) {
+      console.log(`  ${pc4.dim(path)} \u2192 ${pc4.blue(ent)}`);
+    }
+    console.log();
+  }
+  console.log(pc4.bold("Stats"));
+  console.log(
+    `  Briefings:    ${stats.briefings.total}${stats.briefings.lastAt ? pc4.dim(` (last: ${stats.briefings.lastAt.split("T")[0]})`) : ""}`
+  );
+  console.log(
+    `  Extractions:  ${stats.extractions.total}${stats.extractions.messagesSaved ? ` (${stats.extractions.messagesSaved} messages)` : ""}${stats.extractions.lastAt ? pc4.dim(` (last: ${stats.extractions.lastAt.split("T")[0]})`) : ""}`
+  );
+  console.log();
+  console.log(pc4.dim(`Config: ${getDataDir()}/config.json`));
+}
+
+// src/commands/uninstall.ts
+import { Command as Command6 } from "commander";
+import pc5 from "picocolors";
+function createUninstallCommand() {
+  return new Command6("uninstall").description("Remove hooks for a target CLI").argument("<target>", "Target CLI: claude, gemini, opencode").action(async (targetName) => {
+    try {
+      await runUninstall(targetName);
+    } catch (err) {
+      console.error(pc5.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+async function runUninstall(targetName) {
+  const target = resolveTarget(targetName);
+  if (!target) {
+    console.error(pc5.red(`Unknown target: ${targetName}. Use: claude, gemini, opencode`));
+    process.exit(1);
+  }
+  const installed = await target.isInstalled();
+  if (!installed) {
+    console.log(pc5.dim(`dcontext hooks not installed for ${target.name}`));
+    return;
+  }
+  await target.uninstall();
+  const config = await loadConfig();
+  config.targets[target.name] = { installed: false };
+  await saveConfig(config);
+  console.log(pc5.green(`\u2713 Hooks removed for ${target.name}`));
+  if (target.name === "claude") {
+    console.log(
+      pc5.dim(`  Run ${pc5.cyan("dbrain connect claude")} to restore original dbrain instructions`)
+    );
+  }
+}
+
+// src/index.ts
+var program = new Command7();
+var banner = `     _                 _            _
+    | |               | |          | |
+  __| | ___ ___  _ __ | |_ _____  _| |_
+ / _\` |/ __/ _ \\| '_ \\| __/ _ \\ \\/ / __|
+| (_| | (_| (_) | | | | ||  __/>  <| |_
+ \\__,_|\\___\\___/|_| |_|\\__\\___/_/\\_\\\\__|`;
+var description = `${pc6.green(banner)}
+
+${pc6.green("dbrain hooks for AI coding CLIs")}
+${pc6.dim("Part of the dtoolkit suite")}`;
+program.name("dcontext").description(description).version("0.1.0");
+var guarded = (cmd) => {
+  cmd.hook("preAction", async () => {
+    await requireInit();
+  });
+  return cmd;
+};
+program.addCommand(createInitCommand());
+program.addCommand(guarded(createInstallCommand()));
+program.addCommand(guarded(createUninstallCommand()));
+program.addCommand(guarded(createStatusCommand()));
+program.addCommand(guarded(createExploreCommand()));
+program.addCommand(createHookCommand());
+program.parse();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dtoolkit/dcontext",
-  "version": "0.0.3",
-  "description": "Tool cache + background compactor for AI coding agents",
+  "version": "0.1.0",
+  "description": "dbrain hooks for AI coding CLIs",
   "type": "module",
   "license": "MIT",
   "author": "Iván Campillo <ivncmp@gmail.com>",
@@ -32,19 +32,29 @@
   "keywords": [
     "ai",
     "context",
-    "cache",
-    "compactor",
+    "dbrain",
+    "hooks",
     "dtoolkit"
   ],
   "dependencies": {
-    "@dtoolkit/core": "0.3.0"
+    "@clack/prompts": "^1.3.0",
+    "commander": "^13.0.0",
+    "picocolors": "^1.1.0",
+    "@dtoolkit/adapter-gemini": "1.3.0",
+    "@dtoolkit/adapter-claude": "1.3.0",
+    "@dtoolkit/core": "0.4.0",
+    "@dtoolkit/sdk": "0.3.1",
+    "@dtoolkit/adapter-opencode": "1.3.0",
+    "@dtoolkit/adapter-codex": "1.3.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
     "typescript": "^5.7.0"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix"
   }

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,cAAc"}