@context-vault/core 2.17.1 → 3.0.0

package/src/server/tools/session-start.js

@@ -1,285 +0,0 @@
-import { z } from "zod";
-import { execSync } from "node:child_process";
-import { ok, err, ensureVaultExists } from "../helpers.js";
-
-const DEFAULT_MAX_TOKENS = 4000;
-const RECENT_DAYS = 7;
-const MAX_BODY_PER_ENTRY = 400;
-const PRIORITY_KINDS = ["decision", "insight", "pattern"];
-const SESSION_SUMMARY_KIND = "session";
-
-export const name = "session_start";
-
-export const description =
-  "Auto-assemble a context brief for the current project on session start. Pulls recent entries, last session summary, and active decisions/blockers into a token-budgeted capsule formatted for agent consumption.";
-
-export const inputSchema = {
-  project: z
-    .string()
-    .optional()
-    .describe(
-      "Project name or tag to scope the brief. Auto-detected from cwd/git remote if not provided.",
-    ),
-  max_tokens: z
-    .number()
-    .optional()
-    .describe(
-      "Token budget for the capsule (rough estimate: 1 token ~ 4 chars). Default: 4000.",
-    ),
-  buckets: z
-    .array(z.string())
-    .optional()
-    .describe(
-      "Bucket names to scope the session brief. Each name expands to a 'bucket:<name>' tag filter. When provided, the brief only includes entries from these buckets.",
-    ),
-};
-
-function detectProject() {
-  try {
-    const remote = execSync("git remote get-url origin 2>/dev/null", {
-      encoding: "utf-8",
-      timeout: 3000,
-      stdio: ["pipe", "pipe", "pipe"],
-    }).trim();
-    if (remote) {
-      const match = remote.match(/\/([^/]+?)(?:\.git)?$/);
-      if (match) return match[1];
-    }
-  } catch {}
-
-  try {
-    const cwd = process.cwd();
-    const parts = cwd.split(/[/\\]/);
-    return parts[parts.length - 1];
-  } catch {}
-
-  return null;
-}
-
-function truncateBody(body, maxLen = MAX_BODY_PER_ENTRY) {
-  if (!body) return "(no body)";
-  if (body.length <= maxLen) return body;
-  return body.slice(0, maxLen) + "...";
-}
-
-function estimateTokens(text) {
-  return Math.ceil((text || "").length / 4);
-}
-
-function formatEntry(entry) {
-  const tags = entry.tags ? JSON.parse(entry.tags) : [];
-  const tagStr = tags.length ? tags.join(", ") : "none";
-  const date = entry.updated_at || entry.created_at || "unknown";
-  return [
-    `- **${entry.title || "(untitled)"}** [${entry.kind}]`,
-    `  tags: ${tagStr} | ${date} | id: \`${entry.id}\``,
-    `  ${truncateBody(entry.body).replace(/\n+/g, " ").trim()}`,
-  ].join("\n");
-}
-
-export async function handler({ project, max_tokens, buckets }, ctx, { ensureIndexed }) {
-  const { config } = ctx;
-  const userId = ctx.userId !== undefined ? ctx.userId : undefined;
-
-  const vaultErr = ensureVaultExists(config);
-  if (vaultErr) return vaultErr;
-
-  await ensureIndexed();
-
-  const effectiveProject = project?.trim() || detectProject();
-  const tokenBudget = max_tokens || DEFAULT_MAX_TOKENS;
-
-  const bucketTags = buckets?.length ? buckets.map((b) => `bucket:${b}`) : [];
-  const effectiveTags = bucketTags.length
-    ? bucketTags
-    : effectiveProject
-      ? [effectiveProject]
-      : [];
-
-  const sinceDate = new Date(Date.now() - RECENT_DAYS * 86400000).toISOString();
-
-  const sections = [];
-  let tokensUsed = 0;
-
-  sections.push(
-    `# Session Brief${effectiveProject ? ` — ${effectiveProject}` : ""}`,
-  );
-  const bucketsLabel = buckets?.length ? ` | buckets: ${buckets.join(", ")}` : "";
-  sections.push(
-    `_Generated ${new Date().toISOString().slice(0, 10)} | budget: ${tokenBudget} tokens${bucketsLabel}_\n`,
-  );
-  tokensUsed += estimateTokens(sections.join("\n"));
-
-  const lastSession = queryLastSession(ctx, userId, effectiveTags);
-  if (lastSession) {
-    const sessionBlock = [
-      "## Last Session Summary",
-      truncateBody(lastSession.body, 600),
-      "",
-    ].join("\n");
-    const sessionTokens = estimateTokens(sessionBlock);
-    if (tokensUsed + sessionTokens <= tokenBudget) {
-      sections.push(sessionBlock);
-      tokensUsed += sessionTokens;
-    }
-  }
-
-  const decisions = queryByKinds(
-    ctx,
-    PRIORITY_KINDS,
-    sinceDate,
-    userId,
-    effectiveTags,
-  );
-  if (decisions.length > 0) {
-    const header = "## Active Decisions, Insights & Patterns\n";
-    const headerTokens = estimateTokens(header);
-    if (tokensUsed + headerTokens <= tokenBudget) {
-      const entryLines = [];
-      tokensUsed += headerTokens;
-      for (const entry of decisions) {
-        const line = formatEntry(entry);
-        const lineTokens = estimateTokens(line);
-        if (tokensUsed + lineTokens > tokenBudget) break;
-        entryLines.push(line);
-        tokensUsed += lineTokens;
-      }
-      if (entryLines.length > 0) {
-        sections.push(header + entryLines.join("\n") + "\n");
-      }
-    }
-  }
-
-  const recent = queryRecent(ctx, sinceDate, userId, effectiveTags);
-  const seenIds = new Set(decisions.map((d) => d.id));
-  if (lastSession) seenIds.add(lastSession.id);
-  const deduped = recent.filter((r) => !seenIds.has(r.id));
-
-  if (deduped.length > 0) {
-    const header = `## Recent Entries (last ${RECENT_DAYS} days)\n`;
-    const headerTokens = estimateTokens(header);
-    if (tokensUsed + headerTokens <= tokenBudget) {
-      const entryLines = [];
-      tokensUsed += headerTokens;
-      for (const entry of deduped) {
-        const line = formatEntry(entry);
-        const lineTokens = estimateTokens(line);
-        if (tokensUsed + lineTokens > tokenBudget) break;
-        entryLines.push(line);
-        tokensUsed += lineTokens;
-      }
-      if (entryLines.length > 0) {
-        sections.push(header + entryLines.join("\n") + "\n");
-      }
-    }
-  }
-
-  const totalEntries =
-    (lastSession ? 1 : 0) +
-    decisions.length +
-    deduped.filter((d) => {
-      const line = formatEntry(d);
-      return true;
-    }).length;
-
-  sections.push("---");
-  sections.push(
-    `_${tokensUsed} / ${tokenBudget} tokens used | project: ${effectiveProject || "unscoped"}_`,
-  );
-
-  const result = ok(sections.join("\n"));
-  result._meta = {
-    project: effectiveProject || null,
-    buckets: buckets || null,
-    tokens_used: tokensUsed,
-    tokens_budget: tokenBudget,
-    sections: {
-      last_session: lastSession ? 1 : 0,
-      decisions: decisions.length,
-      recent: deduped.length,
-    },
-  };
-  return result;
-}
-
-function queryLastSession(ctx, userId, effectiveTags) {
-  const clauses = [`kind = '${SESSION_SUMMARY_KIND}'`];
-  const params = [];
-
-  if (userId !== undefined) {
-    clauses.push("user_id = ?");
-    params.push(userId);
-  }
-  clauses.push("(expires_at IS NULL OR expires_at > datetime('now'))");
-  clauses.push("superseded_by IS NULL");
-
-  const where = `WHERE ${clauses.join(" AND ")}`;
-  const rows = ctx.db
-    .prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT 5`)
-    .all(...params);
-
-  if (effectiveTags.length) {
-    const match = rows.find((r) => {
-      const tags = r.tags ? JSON.parse(r.tags) : [];
-      return effectiveTags.some((t) => tags.includes(t));
-    });
-    if (match) return match;
-  }
-  return rows[0] || null;
-}
-
-function queryByKinds(ctx, kinds, since, userId, effectiveTags) {
-  const kindPlaceholders = kinds.map(() => "?").join(",");
-  const clauses = [`kind IN (${kindPlaceholders})`];
-  const params = [...kinds];
-
-  clauses.push("created_at >= ?");
-  params.push(since);
-
-  if (userId !== undefined) {
-    clauses.push("user_id = ?");
-    params.push(userId);
-  }
-  clauses.push("(expires_at IS NULL OR expires_at > datetime('now'))");
-  clauses.push("superseded_by IS NULL");
-
-  const where = `WHERE ${clauses.join(" AND ")}`;
-  const rows = ctx.db
-    .prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT 50`)
-    .all(...params);
-
-  if (effectiveTags.length) {
-    const tagged = rows.filter((r) => {
-      const tags = r.tags ? JSON.parse(r.tags) : [];
-      return effectiveTags.some((t) => tags.includes(t));
-    });
-    if (tagged.length > 0) return tagged;
-  }
-  return rows;
-}
-
-function queryRecent(ctx, since, userId, effectiveTags) {
-  const clauses = ["created_at >= ?"];
-  const params = [since];
-
-  if (userId !== undefined) {
-    clauses.push("user_id = ?");
-    params.push(userId);
-  }
-  clauses.push("(expires_at IS NULL OR expires_at > datetime('now'))");
-  clauses.push("superseded_by IS NULL");
-
-  const where = `WHERE ${clauses.join(" AND ")}`;
-  const rows = ctx.db
-    .prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT 50`)
-    .all(...params);
-
-  if (effectiveTags.length) {
-    const tagged = rows.filter((r) => {
-      const tags = r.tags ? JSON.parse(r.tags) : [];
-      return effectiveTags.some((t) => tags.includes(t));
-    });
-    if (tagged.length > 0) return tagged;
-  }
-  return rows;
-}

package/src/server/tools.js

@@ -1,172 +0,0 @@
-import { reindex } from "../index/index.js";
-import { captureAndIndex } from "../capture/index.js";
-import { err } from "./helpers.js";
-import { sendTelemetryEvent } from "../core/telemetry.js";
-import pkg from "../../package.json" with { type: "json" };
-
-import * as getContext from "./tools/get-context.js";
-import * as saveContext from "./tools/save-context.js";
-import * as listContext from "./tools/list-context.js";
-import * as deleteContext from "./tools/delete-context.js";
-import * as ingestUrl from "./tools/ingest-url.js";
-import * as contextStatus from "./tools/context-status.js";
-import * as clearContext from "./tools/clear-context.js";
-import * as createSnapshot from "./tools/create-snapshot.js";
-import * as sessionStart from "./tools/session-start.js";
-import * as listBuckets from "./tools/list-buckets.js";
-import * as ingestProject from "./tools/ingest-project.js";
-
-const toolModules = [
-  getContext,
-  saveContext,
-  listContext,
-  deleteContext,
-  ingestUrl,
-  ingestProject,
-  contextStatus,
-  clearContext,
-  createSnapshot,
-  sessionStart,
-  listBuckets,
-];
-
-const TOOL_TIMEOUT_MS = 60_000;
-
-export function registerTools(server, ctx) {
-  const userId = ctx.userId !== undefined ? ctx.userId : undefined;
-
-  function tracked(handler, toolName) {
-    return async (...args) => {
-      if (ctx.activeOps) ctx.activeOps.count++;
-      let timer;
-      let handlerPromise;
-      try {
-        handlerPromise = Promise.resolve(handler(...args));
-        const result = await Promise.race([
-          handlerPromise,
-          new Promise((_, reject) => {
-            timer = setTimeout(
-              () => reject(new Error("TOOL_TIMEOUT")),
-              TOOL_TIMEOUT_MS,
-            );
-          }),
-        ]);
-        if (ctx.toolStats) ctx.toolStats.ok++;
-        return result;
-      } catch (e) {
-        if (e.message === "TOOL_TIMEOUT") {
-          // Suppress any late rejection from the still-running handler to
-          // prevent unhandled promise rejection warnings in the host process.
-          handlerPromise?.catch(() => {});
-          if (ctx.toolStats) {
-            ctx.toolStats.errors++;
-            ctx.toolStats.lastError = {
-              tool: toolName,
-              code: "TIMEOUT",
-              timestamp: Date.now(),
-            };
-          }
-          sendTelemetryEvent(ctx.config, {
-            event: "tool_error",
-            code: "TIMEOUT",
-            tool: toolName,
-            cv_version: pkg.version,
-          });
-          return err(
-            "Tool timed out after 60s. Try a simpler query or run `context-vault reindex` first.",
-            "TIMEOUT",
-          );
-        }
-        if (ctx.toolStats) {
-          ctx.toolStats.errors++;
-          ctx.toolStats.lastError = {
-            tool: toolName,
-            code: "UNKNOWN",
-            timestamp: Date.now(),
-          };
-        }
-        sendTelemetryEvent(ctx.config, {
-          event: "tool_error",
-          code: "UNKNOWN",
-          tool: toolName,
-          cv_version: pkg.version,
-        });
-        try {
-          await captureAndIndex(ctx, {
-            kind: "feedback",
-            title: `Unhandled error in ${toolName ?? "tool"} call`,
-            body: `${e.message}\n\n${e.stack ?? ""}`,
-            tags: ["bug", "auto-captured"],
-            source: "auto-capture",
-            meta: {
-              tool: toolName,
-              error_type: e.constructor?.name,
-              cv_version: pkg.version,
-              auto: true,
-            },
-          });
-        } catch {} // never block on feedback capture
-        throw e;
-      } finally {
-        clearTimeout(timer);
-        if (ctx.activeOps) ctx.activeOps.count--;
-      }
-    };
-  }
-
-  // In hosted mode, skip reindex — DB is always in sync via writeEntry→indexEntry
-  let reindexDone = userId !== undefined ? true : false;
-  let reindexPromise = null;
-  let reindexAttempts = 0;
-  let reindexFailed = false;
-  const MAX_REINDEX_ATTEMPTS = 2;
-
-  async function ensureIndexed() {
-    if (reindexDone) return;
-    if (reindexPromise) return reindexPromise;
-    // Assign promise synchronously to prevent concurrent calls from both entering reindex()
-    const promise = reindex(ctx, { fullSync: true })
-      .then((stats) => {
-        reindexDone = true;
-        const total = stats.added + stats.updated + stats.removed;
-        if (total > 0) {
-          console.error(
-            `[context-vault] Auto-reindex: +${stats.added} ~${stats.updated} -${stats.removed} (${stats.unchanged} unchanged)`,
-          );
-        }
-      })
-      .catch((e) => {
-        reindexAttempts++;
-        console.error(
-          `[context-vault] Auto-reindex failed (attempt ${reindexAttempts}/${MAX_REINDEX_ATTEMPTS}): ${e.message}`,
-        );
-        if (reindexAttempts >= MAX_REINDEX_ATTEMPTS) {
-          console.error(
-            `[context-vault] Giving up on auto-reindex. Run \`context-vault reindex\` manually to diagnose.`,
-          );
-          reindexDone = true;
-          reindexFailed = true;
-        } else {
-          reindexPromise = null; // Allow retry on next tool call
-        }
-      });
-    reindexPromise = promise;
-    return reindexPromise;
-  }
-
-  const shared = {
-    ensureIndexed,
-    get reindexFailed() {
-      return reindexFailed;
-    },
-  };
-
-  for (const mod of toolModules) {
-    server.tool(
-      mod.name,
-      mod.description,
-      mod.inputSchema,
-      tracked((args) => mod.handler(args, ctx, shared), mod.name),
-    );
-  }
-}

package/src/sync/sync.js

@@ -1,235 +0,0 @@
-/**
- * sync.js — Bidirectional sync protocol
- *
- * v1 design:
- * - Additive-only — no delete propagation (avoids data loss)
- * - Last-write-wins by created_at for conflicts (both have same ID)
- * - Push uses POST /api/vault/import/bulk
- * - Pull uses GET /api/vault/export + local captureAndIndex()
- */
-
-import { captureAndIndex } from "../capture/index.js";
-
-/**
- * Build a manifest of local vault entries (id → { id, created_at, kind, title }).
- *
- * @param {import('../server/types.js').BaseCtx} ctx
- * @returns {Map<string, { id: string, created_at: string, kind: string, title: string|null }>}
- */
-export function buildLocalManifest(ctx) {
-  const rows = ctx.db
-    .prepare(
-      "SELECT id, created_at, kind, title FROM vault WHERE (expires_at IS NULL OR expires_at > datetime('now'))",
-    )
-    .all();
-
-  const manifest = new Map();
-  for (const row of rows) {
-    manifest.set(row.id, {
-      id: row.id,
-      created_at: row.created_at,
-      kind: row.kind,
-      title: row.title || null,
-    });
-  }
-  return manifest;
-}
-
-/**
- * Fetch the remote vault manifest from the hosted API.
- *
- * @param {string} hostedUrl - Base URL of hosted service
- * @param {string} apiKey - Bearer token
- * @returns {Promise<Map<string, { id: string, created_at: string, kind: string, title: string|null }>>}
- */
-export async function fetchRemoteManifest(hostedUrl, apiKey) {
-  const response = await fetch(`${hostedUrl}/api/vault/manifest`, {
-    headers: { Authorization: `Bearer ${apiKey}` },
-  });
-
-  if (!response.ok) {
-    throw new Error(`Failed to fetch remote manifest: HTTP ${response.status}`);
-  }
-
-  const data = await response.json();
-  const manifest = new Map();
-
-  for (const entry of data.entries || []) {
-    manifest.set(entry.id, {
-      id: entry.id,
-      created_at: entry.created_at,
-      kind: entry.kind,
-      title: entry.title || null,
-    });
-  }
-
-  return manifest;
-}
-
-/**
- * @typedef {object} SyncPlan
- * @property {string[]} toPush - Entry IDs that exist locally but not remotely
- * @property {string[]} toPull - Entry IDs that exist remotely but not locally
- * @property {string[]} upToDate - Entry IDs that exist in both
- */
-
-/**
- * Compute what needs to be pushed/pulled by comparing manifests.
- * Additive-only: entries in both are considered up-to-date.
- *
- * @param {Map<string, object>} local
- * @param {Map<string, object>} remote
- * @returns {SyncPlan}
- */
-export function computeSyncPlan(local, remote) {
-  const toPush = [];
-  const toPull = [];
-  const upToDate = [];
-
-  // Find local-only entries
-  for (const id of local.keys()) {
-    if (remote.has(id)) {
-      upToDate.push(id);
-    } else {
-      toPush.push(id);
-    }
-  }
-
-  // Find remote-only entries
-  for (const id of remote.keys()) {
-    if (!local.has(id)) {
-      toPull.push(id);
-    }
-  }
-
-  return { toPush, toPull, upToDate };
-}
-
-/**
- * Execute a sync plan: push local entries to remote, pull remote entries to local.
- *
- * @param {import('../server/types.js').BaseCtx & Partial<import('../server/types.js').HostedCtxExtensions>} ctx
- * @param {{ hostedUrl: string, apiKey: string, plan: SyncPlan, onProgress?: (phase: string, current: number, total: number) => void }} opts
- * @returns {Promise<{ pushed: number, pulled: number, failed: number, errors: string[] }>}
- */
-export async function executeSync(
-  ctx,
-  { hostedUrl, apiKey, plan, onProgress },
-) {
-  let pushed = 0;
-  let pulled = 0;
-  let failed = 0;
-  const errors = [];
-
-  // ── Push: upload local-only entries to remote ──
-  if (plan.toPush.length > 0) {
-    const BATCH_SIZE = 50;
-    const entries = [];
-
-    // Collect full entry data for push
-    for (const id of plan.toPush) {
-      const row = ctx.stmts.getEntryById.get(id);
-      if (!row) continue;
-
-      entries.push({
-        kind: row.kind,
-        title: row.title || null,
-        body: row.body,
-        tags: row.tags ? JSON.parse(row.tags) : [],
-        meta: row.meta ? JSON.parse(row.meta) : undefined,
-        source: row.source || "sync-push",
-        identity_key: row.identity_key || undefined,
-        expires_at: row.expires_at || undefined,
-      });
-    }
-
-    // Push in batches
-    for (let i = 0; i < entries.length; i += BATCH_SIZE) {
-      const batch = entries.slice(i, i + BATCH_SIZE);
-      if (onProgress) onProgress("push", i + batch.length, entries.length);
-
-      try {
-        const response = await fetch(`${hostedUrl}/api/vault/import/bulk`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`,
-          },
-          body: JSON.stringify({ entries: batch }),
-        });
-
-        if (!response.ok) {
-          const errData = await response.json().catch(() => ({}));
-          failed += batch.length;
-          errors.push(
-            `Push batch failed: HTTP ${response.status} — ${errData.error || "unknown"}`,
-          );
-          continue;
-        }
-
-        const result = await response.json();
-        pushed += result.imported || 0;
-        failed += result.failed || 0;
-        if (result.errors?.length) {
-          errors.push(...result.errors);
-        }
-      } catch (err) {
-        failed += batch.length;
-        errors.push(`Push batch failed: ${err.message}`);
-      }
-    }
-  }
-
-  // ── Pull: download remote-only entries to local ──
-  if (plan.toPull.length > 0) {
-    if (onProgress) onProgress("pull", 0, plan.toPull.length);
-
-    try {
-      const response = await fetch(`${hostedUrl}/api/vault/export`, {
-        headers: { Authorization: `Bearer ${apiKey}` },
-      });
-
-      if (!response.ok) {
-        throw new Error(`Export failed: HTTP ${response.status}`);
-      }
-
-      const data = await response.json();
-      const remoteEntries = data.entries || [];
-
-      // Filter to only pull entries we need
-      const pullIds = new Set(plan.toPull);
-      const entriesToPull = remoteEntries.filter((e) => pullIds.has(e.id));
-
-      for (let i = 0; i < entriesToPull.length; i++) {
-        const entry = entriesToPull[i];
-        if (onProgress) onProgress("pull", i + 1, entriesToPull.length);
-
-        try {
-          await captureAndIndex(ctx, {
-            kind: entry.kind,
-            title: entry.title,
-            body: entry.body,
-            meta:
-              entry.meta && typeof entry.meta === "object"
-                ? entry.meta
-                : undefined,
-            tags: Array.isArray(entry.tags) ? entry.tags : undefined,
-            source: entry.source || "sync-pull",
-            identity_key: entry.identity_key,
-            expires_at: entry.expires_at,
-            userId: ctx.userId || null,
-          });
-          pulled++;
-        } catch (err) {
-          failed++;
-          errors.push(`Pull "${entry.title || entry.id}": ${err.message}`);
-        }
-      }
-    } catch (err) {
-      failed += plan.toPull.length;
-      errors.push(`Pull failed: ${err.message}`);
-    }
-  }
-
-  return { pushed, pulled, failed, errors };
-}