@datasynx/agentic-ai-cartography 2.0.0 → 2.3.0

package/dist/chunk-W7YE6AAH.js

@@ -1,1516 +0,0 @@
-#!/usr/bin/env node
-import {
-  EDGE_RELATIONSHIPS,
-  NODE_TYPES,
-  NODE_TYPE_GROUPS,
-  defaultConfig
-} from "./chunk-J6FDZ6HZ.js";
-import {
-  PLATFORM,
-  commandExists,
-  run,
-  scanAllBookmarks,
-  scanListeningPorts
-} from "./chunk-CJ2PITFA.js";
-
-// src/db.ts
-import Database from "better-sqlite3";
-import { mkdirSync } from "fs";
-import { dirname } from "path";
-import { z } from "zod";
-var SessionRowSchema = z.object({
-  id: z.string(),
-  mode: z.literal("discover"),
-  started_at: z.string(),
-  completed_at: z.string().nullable().optional(),
-  config: z.string()
-});
-var NodeRowSchema = z.object({
-  id: z.string(),
-  session_id: z.string(),
-  type: z.enum(NODE_TYPES),
-  name: z.string(),
-  discovered_via: z.string().nullable().optional(),
-  discovered_at: z.string(),
-  path_id: z.string().nullable().optional(),
-  depth: z.number().default(0),
-  confidence: z.number().default(0.5),
-  metadata: z.string().default("{}"),
-  tags: z.string().default("[]"),
-  domain: z.string().nullable().optional(),
-  sub_domain: z.string().nullable().optional(),
-  quality_score: z.number().nullable().optional()
-});
-var EdgeRowSchema = z.object({
-  id: z.string(),
-  session_id: z.string(),
-  source_id: z.string(),
-  target_id: z.string(),
-  relationship: z.enum(EDGE_RELATIONSHIPS),
-  evidence: z.string().nullable().optional(),
-  confidence: z.number().default(0.5),
-  discovered_at: z.string()
-});
-var EventRowSchema = z.object({
-  id: z.string(),
-  session_id: z.string(),
-  task_id: z.string().nullable().optional(),
-  timestamp: z.string(),
-  event_type: z.string(),
-  process: z.string(),
-  pid: z.number(),
-  target: z.string().nullable().optional(),
-  target_type: z.string().nullable().optional(),
-  port: z.number().nullable().optional(),
-  duration_ms: z.number().nullable().optional()
-});
-var TaskRowSchema = z.object({
-  id: z.string(),
-  session_id: z.string(),
-  description: z.string().nullable().optional(),
-  started_at: z.string(),
-  completed_at: z.string().nullable().optional(),
-  steps: z.string().default("[]"),
-  involved_services: z.string().default("[]"),
-  status: z.enum(["active", "completed", "cancelled"])
-});
-var WorkflowRowSchema = z.object({
-  id: z.string(),
-  session_id: z.string(),
-  name: z.string().nullable().optional(),
-  pattern: z.string(),
-  task_ids: z.string().default("[]"),
-  occurrences: z.number().default(1),
-  first_seen: z.string(),
-  last_seen: z.string(),
-  avg_duration_ms: z.number().nullable().optional(),
-  involved_services: z.string().default("[]")
-});
-var ConnectionRowSchema = z.object({
-  id: z.string(),
-  session_id: z.string(),
-  source_asset_id: z.string(),
-  target_asset_id: z.string(),
-  type: z.string().nullable().optional(),
-  created_at: z.string()
-});
-var SCHEMA = `
-PRAGMA journal_mode = WAL;
-PRAGMA foreign_keys = ON;
-PRAGMA busy_timeout = 5000;
-
-CREATE TABLE IF NOT EXISTS sessions (
-  id TEXT PRIMARY KEY,
-  mode TEXT NOT NULL CHECK (mode IN ('discover')),
-  started_at TEXT NOT NULL,
-  completed_at TEXT,
-  config TEXT NOT NULL DEFAULT '{}'
-);
-
-CREATE TABLE IF NOT EXISTS nodes (
-  id TEXT NOT NULL,
-  session_id TEXT NOT NULL REFERENCES sessions(id),
-  type TEXT NOT NULL,
-  name TEXT NOT NULL,
-  discovered_via TEXT,
-  discovered_at TEXT NOT NULL,
-  path_id TEXT,
-  depth INTEGER DEFAULT 0,
-  confidence REAL DEFAULT 0.5,
-  metadata TEXT NOT NULL DEFAULT '{}',
-  tags TEXT NOT NULL DEFAULT '[]',
-  domain TEXT,
-  sub_domain TEXT,
-  quality_score REAL,
-  PRIMARY KEY (id, session_id)
-);
-
-CREATE TABLE IF NOT EXISTS connections (
-  id TEXT PRIMARY KEY,
-  session_id TEXT NOT NULL REFERENCES sessions(id),
-  source_asset_id TEXT NOT NULL,
-  target_asset_id TEXT NOT NULL,
-  type TEXT,
-  created_at TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS edges (
-  id TEXT PRIMARY KEY,
-  session_id TEXT NOT NULL REFERENCES sessions(id),
-  source_id TEXT NOT NULL,
-  target_id TEXT NOT NULL,
-  relationship TEXT NOT NULL,
-  evidence TEXT,
-  confidence REAL DEFAULT 0.5,
-  discovered_at TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS activity_events (
-  id TEXT PRIMARY KEY,
-  session_id TEXT NOT NULL REFERENCES sessions(id),
-  task_id TEXT,
-  timestamp TEXT NOT NULL,
-  event_type TEXT NOT NULL,
-  process TEXT NOT NULL,
-  pid INTEGER NOT NULL,
-  target TEXT,
-  target_type TEXT,
-  port INTEGER,
-  duration_ms INTEGER
-);
-
-CREATE TABLE IF NOT EXISTS tasks (
-  id TEXT PRIMARY KEY,
-  session_id TEXT NOT NULL REFERENCES sessions(id),
-  description TEXT,
-  started_at TEXT NOT NULL,
-  completed_at TEXT,
-  steps TEXT NOT NULL DEFAULT '[]',
-  involved_services TEXT NOT NULL DEFAULT '[]',
-  status TEXT DEFAULT 'active' CHECK (status IN ('active','completed','cancelled'))
-);
-
-CREATE TABLE IF NOT EXISTS workflows (
-  id TEXT PRIMARY KEY,
-  session_id TEXT NOT NULL REFERENCES sessions(id),
-  name TEXT,
-  pattern TEXT NOT NULL,
-  task_ids TEXT NOT NULL DEFAULT '[]',
-  occurrences INTEGER DEFAULT 1,
-  first_seen TEXT NOT NULL,
-  last_seen TEXT NOT NULL,
-  avg_duration_ms INTEGER,
-  involved_services TEXT NOT NULL DEFAULT '[]'
-);
-
-CREATE TABLE IF NOT EXISTS node_approvals (
-  pattern TEXT PRIMARY KEY,
-  action TEXT NOT NULL CHECK (action IN ('save','ignore','auto')),
-  created_at TEXT NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_nodes_session ON nodes(session_id);
-CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(session_id, type);
-CREATE INDEX IF NOT EXISTS idx_edges_session ON edges(session_id);
-CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(session_id, source_id);
-CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(session_id, target_id);
-CREATE INDEX IF NOT EXISTS idx_events_session ON activity_events(session_id);
-CREATE INDEX IF NOT EXISTS idx_events_task ON activity_events(task_id);
-CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
-CREATE INDEX IF NOT EXISTS idx_connections_session ON connections(session_id);
-CREATE INDEX IF NOT EXISTS idx_connections_lookup ON connections(session_id, source_asset_id, target_asset_id);
-`;
-var CartographyDB = class {
-  db;
-  constructor(dbPath) {
-    mkdirSync(dirname(dbPath), { recursive: true });
-    this.db = new Database(dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
-    this.db.pragma("busy_timeout = 5000");
-    this.migrate();
-  }
-  migrate() {
-    const version = this.db.pragma("user_version", { simple: true });
-    if (version === 0) {
-      this.db.exec(SCHEMA);
-      this.db.pragma("user_version = 4");
-      return;
-    } else if (version === 1) {
-      const cols = this.db.prepare("PRAGMA table_info(nodes)").all().map((c) => c.name);
-      if (!cols.includes("domain")) this.db.exec("ALTER TABLE nodes ADD COLUMN domain TEXT");
-      if (!cols.includes("sub_domain")) this.db.exec("ALTER TABLE nodes ADD COLUMN sub_domain TEXT");
-      if (!cols.includes("quality_score")) this.db.exec("ALTER TABLE nodes ADD COLUMN quality_score REAL");
-      this.db.exec(`
-        CREATE TABLE IF NOT EXISTS connections (
-          id TEXT PRIMARY KEY,
-          session_id TEXT NOT NULL REFERENCES sessions(id),
-          source_asset_id TEXT NOT NULL,
-          target_asset_id TEXT NOT NULL,
-          type TEXT,
-          created_at TEXT NOT NULL
-        );
-        CREATE INDEX IF NOT EXISTS idx_connections_session ON connections(session_id);
-        CREATE INDEX IF NOT EXISTS idx_connections_lookup ON connections(session_id, source_asset_id, target_asset_id);
-      `);
-      this.db.pragma("user_version = 3");
-    }
-    if (version === 2) {
-      this.db.exec("CREATE INDEX IF NOT EXISTS idx_connections_lookup ON connections(session_id, source_asset_id, target_asset_id)");
-      this.db.pragma("user_version = 3");
-    }
-    const current = this.db.pragma("user_version", { simple: true });
-    if (current < 4) {
-      this.db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(session_id, type);
-        CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(session_id, source_id);
-        CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(session_id, target_id);
-      `);
-      this.db.pragma("user_version = 4");
-    }
-  }
-  close() {
-    this.db.pragma("optimize");
-    this.db.close();
-  }
-  /**
-   * Advanced: the underlying better-sqlite3 connection. Used by the optional
-   * semantic-search layer to load the `sqlite-vec` extension and manage its
-   * virtual table. Prefer the typed methods above for everything else.
-   */
-  rawConnection() {
-    return this.db;
-  }
-  // ── Sessions ────────────────────────────
-  createSession(mode, config) {
-    const id = crypto.randomUUID();
-    this.db.prepare(
-      "INSERT INTO sessions (id, mode, started_at, config) VALUES (?, ?, ?, ?)"
-    ).run(id, mode, (/* @__PURE__ */ new Date()).toISOString(), JSON.stringify(config));
-    return id;
-  }
-  endSession(id) {
-    this.db.prepare("UPDATE sessions SET completed_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
-  }
-  getSession(id) {
-    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
-    return row ? this.mapSession(row) : void 0;
-  }
-  getLatestSession(mode) {
-    const row = mode ? this.db.prepare("SELECT * FROM sessions WHERE mode = ? ORDER BY rowid DESC LIMIT 1").get(mode) : this.db.prepare("SELECT * FROM sessions ORDER BY rowid DESC LIMIT 1").get();
-    return row ? this.mapSession(row) : void 0;
-  }
-  getSessions() {
-    const rows = this.db.prepare("SELECT * FROM sessions ORDER BY rowid DESC").all();
-    return rows.map((r) => this.mapSession(r));
-  }
-  mapSession(r) {
-    const v = SessionRowSchema.parse(r);
-    return {
-      id: v.id,
-      mode: v.mode,
-      startedAt: v.started_at,
-      completedAt: v.completed_at ?? void 0,
-      config: v.config
-    };
-  }
-  // ── Nodes ───────────────────────────────
-  upsertNode(sessionId, node, depth = 0) {
-    this.db.prepare(`
-      INSERT OR REPLACE INTO nodes
-        (id, session_id, type, name, discovered_via, discovered_at, depth, confidence, metadata, tags,
-         domain, sub_domain, quality_score)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      node.id,
-      sessionId,
-      node.type,
-      node.name,
-      node.discoveredVia,
-      (/* @__PURE__ */ new Date()).toISOString(),
-      depth,
-      node.confidence,
-      JSON.stringify(node.metadata ?? {}),
-      JSON.stringify(node.tags ?? []),
-      node.domain ?? null,
-      node.subDomain ?? null,
-      node.qualityScore ?? null
-    );
-  }
-  getNodes(sessionId, opts) {
-    let sql = "SELECT * FROM nodes WHERE session_id = ?";
-    if (opts?.limit) {
-      sql += ` LIMIT ${opts.limit}`;
-      if (opts.offset) sql += ` OFFSET ${opts.offset}`;
-    }
-    const rows = this.db.prepare(sql).all(sessionId);
-    return rows.map((r) => this.mapNode(r));
-  }
-  getNodeCount(sessionId) {
-    const row = this.db.prepare("SELECT COUNT(*) as cnt FROM nodes WHERE session_id = ?").get(sessionId);
-    return row.cnt;
-  }
-  mapNode(r) {
-    const v = NodeRowSchema.parse(r);
-    return {
-      id: v.id,
-      sessionId: v.session_id,
-      type: v.type,
-      name: v.name,
-      discoveredVia: v.discovered_via ?? "",
-      discoveredAt: v.discovered_at,
-      depth: v.depth,
-      confidence: v.confidence,
-      metadata: JSON.parse(v.metadata),
-      tags: JSON.parse(v.tags),
-      pathId: v.path_id ?? void 0,
-      domain: v.domain ?? void 0,
-      subDomain: v.sub_domain ?? void 0,
-      qualityScore: v.quality_score ?? void 0
-    };
-  }
-  deleteNode(sessionId, nodeId) {
-    this.db.prepare("DELETE FROM nodes WHERE session_id = ? AND id = ?").run(sessionId, nodeId);
-    this.db.prepare(
-      "DELETE FROM edges WHERE session_id = ? AND (source_id = ? OR target_id = ?)"
-    ).run(sessionId, nodeId, nodeId);
-  }
-  // ── Edges ───────────────────────────────
-  insertEdge(sessionId, edge) {
-    const id = crypto.randomUUID();
-    this.db.prepare(`
-      INSERT OR IGNORE INTO edges
-        (id, session_id, source_id, target_id, relationship, evidence, confidence, discovered_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      id,
-      sessionId,
-      edge.sourceId,
-      edge.targetId,
-      edge.relationship,
-      edge.evidence,
-      edge.confidence,
-      (/* @__PURE__ */ new Date()).toISOString()
-    );
-  }
-  getEdges(sessionId, opts) {
-    let sql = "SELECT * FROM edges WHERE session_id = ?";
-    if (opts?.limit) {
-      sql += ` LIMIT ${opts.limit}`;
-      if (opts.offset) sql += ` OFFSET ${opts.offset}`;
-    }
-    const rows = this.db.prepare(sql).all(sessionId);
-    return rows.map((r) => {
-      const v = EdgeRowSchema.parse(r);
-      return {
-        id: v.id,
-        sessionId: v.session_id,
-        sourceId: v.source_id,
-        targetId: v.target_id,
-        relationship: v.relationship,
-        evidence: v.evidence ?? "",
-        confidence: v.confidence,
-        discoveredAt: v.discovered_at
-      };
-    });
-  }
-  // ── Events ──────────────────────────────
-  insertEvent(sessionId, event, taskId) {
-    const id = crypto.randomUUID();
-    this.db.prepare(`
-      INSERT INTO activity_events
-        (id, session_id, task_id, timestamp, event_type, process, pid, target, target_type, port)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      id,
-      sessionId,
-      taskId ?? null,
-      (/* @__PURE__ */ new Date()).toISOString(),
-      event.eventType,
-      event.process,
-      event.pid,
-      event.target ?? null,
-      event.targetType ?? null,
-      event.port ?? null
-    );
-  }
-  getEvents(sessionId, since) {
-    const rows = since ? this.db.prepare("SELECT * FROM activity_events WHERE session_id = ? AND timestamp > ? ORDER BY timestamp").all(sessionId, since) : this.db.prepare("SELECT * FROM activity_events WHERE session_id = ? ORDER BY timestamp").all(sessionId);
-    return rows.map((r) => {
-      const v = EventRowSchema.parse(r);
-      return {
-        id: v.id,
-        sessionId: v.session_id,
-        taskId: v.task_id ?? void 0,
-        timestamp: v.timestamp,
-        eventType: v.event_type,
-        process: v.process,
-        pid: v.pid,
-        target: v.target ?? void 0,
-        targetType: v.target_type ?? void 0,
-        port: v.port ?? void 0,
-        durationMs: v.duration_ms ?? void 0
-      };
-    });
-  }
-  // ── Tasks ───────────────────────────────
-  startTask(sessionId, description) {
-    const id = crypto.randomUUID();
-    this.db.prepare(`
-      INSERT INTO tasks (id, session_id, description, started_at, steps, involved_services, status)
-      VALUES (?, ?, ?, ?, '[]', '[]', 'active')
-    `).run(id, sessionId, description ?? null, (/* @__PURE__ */ new Date()).toISOString());
-    return id;
-  }
-  endCurrentTask(sessionId) {
-    this.db.prepare(`
-      UPDATE tasks SET status = 'completed', completed_at = ?
-      WHERE session_id = ? AND status = 'active'
-    `).run((/* @__PURE__ */ new Date()).toISOString(), sessionId);
-  }
-  updateTaskDescription(sessionId, description) {
-    this.db.prepare(`
-      UPDATE tasks SET description = ?
-      WHERE session_id = ? AND status = 'active'
-    `).run(description, sessionId);
-  }
-  getActiveTask(sessionId) {
-    const row = this.db.prepare(
-      "SELECT * FROM tasks WHERE session_id = ? AND status = 'active' LIMIT 1"
-    ).get(sessionId);
-    return row ? this.mapTask(row) : void 0;
-  }
-  getTasks(sessionId) {
-    const rows = this.db.prepare("SELECT * FROM tasks WHERE session_id = ? ORDER BY started_at").all(sessionId);
-    return rows.map((r) => this.mapTask(r));
-  }
-  mapTask(r) {
-    const v = TaskRowSchema.parse(r);
-    return {
-      id: v.id,
-      sessionId: v.session_id,
-      description: v.description ?? void 0,
-      startedAt: v.started_at,
-      completedAt: v.completed_at ?? void 0,
-      steps: v.steps,
-      involvedServices: v.involved_services,
-      status: v.status
-    };
-  }
-  // ── Workflows ───────────────────────────
-  insertWorkflow(sessionId, data) {
-    const id = crypto.randomUUID();
-    this.db.prepare(`
-      INSERT INTO workflows
-        (id, session_id, name, pattern, task_ids, occurrences,
-         first_seen, last_seen, avg_duration_ms, involved_services)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      id,
-      sessionId,
-      data.name ?? null,
-      data.pattern,
-      data.taskIds,
-      data.occurrences,
-      data.firstSeen,
-      data.lastSeen,
-      data.avgDurationMs,
-      data.involvedServices
-    );
-  }
-  getWorkflows(sessionId) {
-    const rows = this.db.prepare("SELECT * FROM workflows WHERE session_id = ?").all(sessionId);
-    return rows.map((r) => {
-      const v = WorkflowRowSchema.parse(r);
-      return {
-        id: v.id,
-        sessionId: v.session_id,
-        name: v.name ?? void 0,
-        pattern: v.pattern,
-        taskIds: v.task_ids,
-        occurrences: v.occurrences,
-        firstSeen: v.first_seen,
-        lastSeen: v.last_seen,
-        avgDurationMs: v.avg_duration_ms ?? 0,
-        involvedServices: v.involved_services
-      };
-    });
-  }
-  // ── Connections (user-created hex map links) ─────────────────────────────
-  upsertConnection(sessionId, conn) {
-    const existing = this.db.prepare(
-      "SELECT id FROM connections WHERE session_id = ? AND source_asset_id = ? AND target_asset_id = ?"
-    ).get(sessionId, conn.sourceAssetId, conn.targetAssetId);
-    if (existing) return existing.id;
-    const id = crypto.randomUUID();
-    this.db.prepare(`
-      INSERT INTO connections (id, session_id, source_asset_id, target_asset_id, type, created_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(id, sessionId, conn.sourceAssetId, conn.targetAssetId, conn.type ?? null, (/* @__PURE__ */ new Date()).toISOString());
-    return id;
-  }
-  getConnections(sessionId) {
-    const rows = this.db.prepare("SELECT * FROM connections WHERE session_id = ?").all(sessionId);
-    return rows.map((r) => {
-      const v = ConnectionRowSchema.parse(r);
-      return {
-        id: v.id,
-        sessionId: v.session_id,
-        sourceAssetId: v.source_asset_id,
-        targetAssetId: v.target_asset_id,
-        type: v.type ?? void 0,
-        createdAt: v.created_at
-      };
-    });
-  }
-  deleteConnection(sessionId, connectionId) {
-    this.db.prepare("DELETE FROM connections WHERE session_id = ? AND id = ?").run(sessionId, connectionId);
-  }
-  // ── Approvals ───────────────────────────
-  setApproval(pattern, action) {
-    this.db.prepare(`
-      INSERT OR REPLACE INTO node_approvals (pattern, action, created_at) VALUES (?, ?, ?)
-    `).run(pattern, action, (/* @__PURE__ */ new Date()).toISOString());
-  }
-  getApproval(pattern) {
-    const row = this.db.prepare("SELECT action FROM node_approvals WHERE pattern = ?").get(pattern);
-    return row?.action;
-  }
-  // ── Pruning ──────────────────────────────
-  /**
-   * Delete a session and all its associated data (nodes, edges, events, tasks, workflows, connections).
-   */
-  deleteSession(sessionId) {
-    this.db.prepare("DELETE FROM connections WHERE session_id = ?").run(sessionId);
-    this.db.prepare("DELETE FROM workflows WHERE session_id = ?").run(sessionId);
-    this.db.prepare("DELETE FROM activity_events WHERE session_id = ?").run(sessionId);
-    this.db.prepare("DELETE FROM tasks WHERE session_id = ?").run(sessionId);
-    this.db.prepare("DELETE FROM edges WHERE session_id = ?").run(sessionId);
-    this.db.prepare("DELETE FROM nodes WHERE session_id = ?").run(sessionId);
-    this.db.prepare("DELETE FROM sessions WHERE id = ?").run(sessionId);
-  }
-  /**
-   * Prune sessions older than the given ISO date string. Returns count of deleted sessions.
-   */
-  pruneSessions(olderThan) {
-    const rows = this.db.prepare(
-      "SELECT id FROM sessions WHERE started_at < ?"
-    ).all(olderThan);
-    for (const row of rows) {
-      this.deleteSession(row.id);
-    }
-    return rows.length;
-  }
-  // ── Graph queries (read-only context layer) ─────────────────────────────────
-  /** Fetch a single node by id within a session. */
-  getNode(sessionId, nodeId) {
-    const row = this.db.prepare("SELECT * FROM nodes WHERE session_id = ? AND id = ?").get(sessionId, nodeId);
-    return row ? this.mapNode(row) : void 0;
-  }
-  /** Batch-fetch nodes by id, keyed for O(1) lookup. Chunked to stay under SQLite's bind-variable limit. */
-  getNodesByIds(sessionId, ids) {
-    const out = /* @__PURE__ */ new Map();
-    for (let i = 0; i < ids.length; i += 900) {
-      const chunk = ids.slice(i, i + 900);
-      const placeholders = chunk.map(() => "?").join(",");
-      const rows = this.db.prepare(
-        `SELECT * FROM nodes WHERE session_id = ? AND id IN (${placeholders})`
-      ).all(sessionId, ...chunk);
-      for (const r of rows) {
-        const n = this.mapNode(r);
-        out.set(n.id, n);
-      }
-    }
-    return out;
-  }
-  /** Fetch all nodes of one or more types. */
-  getNodesByType(sessionId, types) {
-    if (types.length === 0) return [];
-    const placeholders = types.map(() => "?").join(",");
-    const rows = this.db.prepare(
-      `SELECT * FROM nodes WHERE session_id = ? AND type IN (${placeholders})`
-    ).all(sessionId, ...types);
-    return rows.map((r) => this.mapNode(r));
-  }
-  /**
-   * Lexical search over node id, name, domain, sub-domain and tags.
-   * Case-insensitive substring match — the deterministic fallback for semantic search.
-   */
-  searchNodes(sessionId, query, opts) {
-    const q = `%${query.trim().toLowerCase()}%`;
-    const params = [sessionId, q, q, q, q, q];
-    let sql = `
-      SELECT * FROM nodes
-      WHERE session_id = ?
-        AND (
-          lower(id) LIKE ? OR lower(name) LIKE ?
-          OR lower(COALESCE(domain, '')) LIKE ?
-          OR lower(COALESCE(sub_domain, '')) LIKE ?
-          OR lower(tags) LIKE ?
-        )`;
-    if (opts?.types && opts.types.length > 0) {
-      sql += ` AND type IN (${opts.types.map(() => "?").join(",")})`;
-      params.push(...opts.types);
-    }
-    sql += " ORDER BY confidence DESC";
-    if (opts?.limit) sql += ` LIMIT ${Math.max(1, Math.floor(opts.limit))}`;
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((r) => this.mapNode(r));
-  }
-  /**
-   * Traverse the dependency graph from a node using a recursive CTE with a
-   * path-based cycle guard. `downstream` follows source→target (what the node
-   * depends on / points to); `upstream` follows target→source (what depends on it).
-   */
-  getDependencies(sessionId, nodeId, opts = {}) {
-    const direction = opts.direction ?? "downstream";
-    const maxDepth = Math.max(1, Math.min(opts.maxDepth ?? 8, 64));
-    const root = this.getNode(sessionId, nodeId);
-    const depthById = /* @__PURE__ */ new Map();
-    const collect = (dir) => {
-      const [from, to] = dir === "downstream" ? ["source_id", "target_id"] : ["target_id", "source_id"];
-      const sql = `
-        WITH RECURSIVE walk(node_id, depth, path) AS (
-          SELECT ?, 0, char(10) || ? || char(10)
-          UNION ALL
-          SELECT e.${to}, w.depth + 1, w.path || e.${to} || char(10)
-          FROM edges e JOIN walk w ON e.${from} = w.node_id
-          WHERE e.session_id = ?
-            AND w.depth < ?
-            AND instr(w.path, char(10) || e.${to} || char(10)) = 0
-        )
-        SELECT node_id, MIN(depth) AS depth FROM walk WHERE node_id != ? GROUP BY node_id`;
-      const rows = this.db.prepare(sql).all(nodeId, nodeId, sessionId, maxDepth, nodeId);
-      for (const r of rows) {
-        const prev = depthById.get(r.node_id);
-        if (prev === void 0 || r.depth < prev) depthById.set(r.node_id, r.depth);
-      }
-    };
-    if (direction === "both") {
-      collect("downstream");
-      collect("upstream");
-    } else collect(direction);
-    const byId = this.getNodesByIds(sessionId, [...depthById.keys()]);
-    const nodes = [...depthById.entries()].map(([id, depth]) => {
-      const n = byId.get(id);
-      return n ? { ...n, depth } : void 0;
-    }).filter((n) => n !== void 0).sort((a, b) => a.depth - b.depth);
-    const reachable = /* @__PURE__ */ new Set([nodeId, ...depthById.keys()]);
-    const edges = this.getEdges(sessionId).filter((e) => reachable.has(e.sourceId) && reachable.has(e.targetId));
-    return { root, direction, maxDepth, nodes, edges };
-  }
-  /** Lightweight aggregate index of the whole topology — the progressive-disclosure summary. */
-  getGraphSummary(sessionId) {
-    const totals = {
-      nodes: this.db.prepare("SELECT COUNT(*) c FROM nodes WHERE session_id = ?").get(sessionId).c,
-      edges: this.db.prepare("SELECT COUNT(*) c FROM edges WHERE session_id = ?").get(sessionId).c
-    };
-    const byType = {};
-    for (const r of this.db.prepare("SELECT type, COUNT(*) c FROM nodes WHERE session_id = ? GROUP BY type").all(sessionId)) {
-      byType[r.type] = r.c;
-    }
-    const byDomain = {};
-    for (const r of this.db.prepare("SELECT COALESCE(domain, '(none)') d, COUNT(*) c FROM nodes WHERE session_id = ? GROUP BY d").all(sessionId)) {
-      byDomain[r.d] = r.c;
-    }
-    const byRelationship = {};
-    for (const r of this.db.prepare("SELECT relationship rel, COUNT(*) c FROM edges WHERE session_id = ? GROUP BY rel").all(sessionId)) {
-      byRelationship[r.rel] = r.c;
-    }
-    const topConnected = this.db.prepare(`
-      SELECT n.id, n.name, n.type, COUNT(e.id) AS degree
-      FROM nodes n
-      LEFT JOIN edges e ON e.session_id = n.session_id AND (e.source_id = n.id OR e.target_id = n.id)
-      WHERE n.session_id = ?
-      GROUP BY n.id, n.name, n.type
-      ORDER BY degree DESC, n.confidence DESC
-      LIMIT 10
-    `).all(sessionId);
-    return { sessionId, totals, nodesByType: byType, nodesByDomain: byDomain, edgesByRelationship: byRelationship, topConnected };
-  }
-  // ── Stats ───────────────────────────────
-  getStats(sessionId) {
-    const nodes = this.db.prepare("SELECT COUNT(*) as c FROM nodes WHERE session_id = ?").get(sessionId).c;
-    const edges = this.db.prepare("SELECT COUNT(*) as c FROM edges WHERE session_id = ?").get(sessionId).c;
-    const events = this.db.prepare("SELECT COUNT(*) as c FROM activity_events WHERE session_id = ?").get(sessionId).c;
-    const tasks = this.db.prepare("SELECT COUNT(*) as c FROM tasks WHERE session_id = ?").get(sessionId).c;
-    return { nodes, edges, events, tasks };
-  }
-};
-
-// src/mcp/server.ts
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z2 } from "zod";
-var SERVER_NAME = "cartography";
-var SERVER_VERSION = "2.0.0";
-var SERVICE_TYPES = NODE_TYPE_GROUPS.web;
-var DATA_TYPES = NODE_TYPE_GROUPS.data;
-var lexicalSearch = async (db, sessionId, query, opts) => db.searchNodes(sessionId, query, { types: opts.types, limit: opts.limit }).map((node) => ({ node }));
-function compactNode(n) {
-  return {
-    id: n.id,
-    type: n.type,
-    name: n.name,
-    confidence: n.confidence,
-    ...n.domain ? { domain: n.domain } : {},
-    ...n.tags.length ? { tags: n.tags } : {}
-  };
-}
-function json(data) {
-  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-}
-function summaryText(s) {
-  const lines = [
-    `# Infrastructure topology \u2014 session ${s.sessionId}`,
-    ``,
-    `Totals: ${s.totals.nodes} nodes, ${s.totals.edges} edges`,
-    ``,
-    `Nodes by type:`,
-    ...Object.entries(s.nodesByType).sort((a, b) => b[1] - a[1]).map(([t, c]) => `  - ${t}: ${c}`),
-    ``,
-    `Nodes by domain:`,
-    ...Object.entries(s.nodesByDomain).sort((a, b) => b[1] - a[1]).map(([d, c]) => `  - ${d}: ${c}`),
-    ``,
-    `Edges by relationship:`,
-    ...Object.entries(s.edgesByRelationship).sort((a, b) => b[1] - a[1]).map(([r, c]) => `  - ${r}: ${c}`),
-    ``,
-    `Most connected:`,
-    ...s.topConnected.map((n) => `  - ${n.id} (${n.type}) \u2014 degree ${n.degree}`),
-    ``,
-    `Read cartography://nodes/{id} or cartography://dependencies/{id} for detail.`
-  ];
-  return lines.join("\n");
-}
-function createMcpServer(opts = {}) {
-  const db = opts.db ?? new CartographyDB(opts.dbPath ?? defaultConfig().dbPath);
-  const search = opts.search ?? lexicalSearch;
-  const resolveSession = () => {
-    if (opts.session && opts.session !== "latest") return opts.session;
-    return db.getLatestSession("discover")?.id ?? db.getLatestSession()?.id;
-  };
-  const server = new McpServer(
-    { name: SERVER_NAME, version: SERVER_VERSION },
-    {
-      capabilities: { resources: { subscribe: true, listChanged: true }, tools: {}, prompts: {}, logging: {} },
-      instructions: "Cartography exposes a discovered infrastructure/SaaS topology. Start by reading cartography://graph/summary for a low-token overview, then drill into specific nodes via cartography://nodes/{id} or query with the query_infrastructure / get_dependencies tools."
-    }
-  );
-  server.registerResource(
-    "graph-summary",
-    "cartography://graph/summary",
-    { title: "Topology summary", description: "Low-token aggregate index of the whole landscape \u2014 read this first.", mimeType: "text/markdown" },
-    (uri) => {
-      const sid = resolveSession();
-      if (!sid) return { contents: [{ uri: uri.href, mimeType: "text/markdown", text: "No discovery session found. Run discovery first." }] };
-      return { contents: [{ uri: uri.href, mimeType: "text/markdown", text: summaryText(db.getGraphSummary(sid)) }] };
-    }
-  );
-  server.registerResource(
-    "nodes-index",
-    "cartography://nodes",
-    { title: "Node index", description: "Lightweight list of all nodes (id, type, name only).", mimeType: "application/json" },
-    (uri) => {
-      const sid = resolveSession();
-      const nodes = sid ? db.getNodes(sid) : [];
-      return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ count: nodes.length, nodes: nodes.map((n) => ({ id: n.id, type: n.type, name: n.name })) }, null, 2) }] };
-    }
-  );
-  server.registerResource(
-    "node-detail",
-    new ResourceTemplate("cartography://nodes/{id}", { list: void 0 }),
-    { title: "Node detail", description: "Full node record plus its incident edges.", mimeType: "application/json" },
-    (uri, variables) => {
-      const sid = resolveSession();
-      const id = decodeURIComponent(String(variables["id"]));
-      const node = sid ? db.getNode(sid, id) : void 0;
-      if (!node) return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ error: `node not found: ${id}` }) }] };
-      const edges = db.getEdges(sid).filter((e) => e.sourceId === id || e.targetId === id);
-      return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ node, edges }, null, 2) }] };
-    }
-  );
-  const typedListResource = (name, uri, title, types) => server.registerResource(name, uri, { title, description: `Nodes of type: ${types.join(", ")}.`, mimeType: "application/json" }, (u) => {
-    const sid = resolveSession();
-    const nodes = sid ? db.getNodesByType(sid, types) : [];
-    return { contents: [{ uri: u.href, mimeType: "application/json", text: JSON.stringify({ count: nodes.length, nodes: nodes.map(compactNode) }, null, 2) }] };
-  });
-  typedListResource("services", "cartography://services", "Services", SERVICE_TYPES);
-  typedListResource("databases", "cartography://databases", "Data stores", DATA_TYPES);
-  server.registerResource(
-    "dependencies",
-    new ResourceTemplate("cartography://dependencies/{id}", { list: void 0 }),
-    { title: "Dependencies", description: "Transitive downstream dependencies of a node.", mimeType: "application/json" },
-    (uri, variables) => {
-      const sid = resolveSession();
-      const id = decodeURIComponent(String(variables["id"]));
-      if (!sid) return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ error: "no session" }) }] };
-      const r = db.getDependencies(sid, id, { direction: "downstream", maxDepth: 8 });
-      return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ root: id, count: r.nodes.length, nodes: r.nodes.map((n) => ({ ...compactNode(n), depth: n.depth })) }, null, 2) }] };
-    }
-  );
-  server.registerResource(
-    "sessions",
-    "cartography://sessions",
-    { title: "Discovery sessions", description: "All discovery sessions in the catalog.", mimeType: "application/json" },
-    (uri) => ({ contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(db.getSessions(), null, 2) }] })
-  );
-  server.registerTool(
-    "get_summary",
-    { title: "Get topology summary", description: "Low-token overview of the whole landscape (counts, types, domains, most-connected).", inputSchema: {} },
-    () => {
-      const sid = resolveSession();
-      if (!sid) return json({ error: "No discovery session found." });
-      return json(db.getGraphSummary(sid));
-    }
-  );
-  server.registerTool(
-    "query_infrastructure",
-    {
-      title: "Query infrastructure",
-      description: "Search the topology by name/id/domain (optionally filtered by node type). Returns compact node records.",
-      inputSchema: {
-        query: z2.string().describe('Free-text query, e.g. "postgres", "auth", "github"'),
-        types: z2.array(z2.enum(NODE_TYPES)).optional().describe("Restrict to these node types"),
-        limit: z2.number().int().min(1).max(200).default(25).optional()
-      }
-    },
-    async (args) => {
-      const sid = resolveSession();
-      if (!sid) return json({ error: "No discovery session found." });
-      const results = await search(db, sid, args.query, { types: args.types, limit: args.limit ?? 25 });
-      return json({ count: results.length, results: results.map((r) => ({ ...compactNode(r.node), ...r.score !== void 0 ? { score: r.score } : {} })) });
-    }
-  );
-  server.registerTool(
-    "search_topology",
-    {
-      title: "Search topology (semantic)",
-      description: "Find nodes related to a concept by meaning (semantic search when available, lexical otherwise).",
-      inputSchema: { query: z2.string(), limit: z2.number().int().min(1).max(100).default(10).optional() }
-    },
-    async (args) => {
-      const sid = resolveSession();
-      if (!sid) return json({ error: "No discovery session found." });
-      const results = await search(db, sid, args.query, { limit: args.limit ?? 10 });
-      return json({ count: results.length, results: results.map((r) => ({ ...compactNode(r.node), ...r.score !== void 0 ? { score: r.score } : {} })) });
-    }
-  );
-  server.registerTool(
-    "list_services",
-    {
-      title: "List services",
-      description: "List discovered services or data stores.",
-      inputSchema: { kind: z2.enum(["services", "databases", "all"]).default("all").optional() }
-    },
-    (args) => {
-      const sid = resolveSession();
-      if (!sid) return json({ error: "No discovery session found." });
-      const kind = args.kind ?? "all";
-      const types = kind === "services" ? SERVICE_TYPES : kind === "databases" ? DATA_TYPES : [...SERVICE_TYPES, ...DATA_TYPES];
-      return json(db.getNodesByType(sid, types).map(compactNode));
-    }
-  );
-  server.registerTool(
-    "get_node",
-    { title: "Get node", description: "Fetch a single node with its incident edges.", inputSchema: { id: z2.string() } },
-    (args) => {
-      const sid = resolveSession();
-      if (!sid) return json({ error: "No discovery session found." });
-      const node = db.getNode(sid, args.id);
-      if (!node) return json({ error: `node not found: ${args.id}` });
-      const edges = db.getEdges(sid).filter((e) => e.sourceId === args.id || e.targetId === args.id);
-      return json({ node, edges });
-    }
-  );
-  server.registerTool(
-    "get_dependencies",
-    {
-      title: "Get dependencies",
-      description: "Traverse the dependency graph from a node (downstream/upstream/both) with a depth limit.",
-      inputSchema: {
-        id: z2.string(),
-        direction: z2.enum(["downstream", "upstream", "both"]).default("downstream").optional(),
-        maxDepth: z2.number().int().min(1).max(64).default(8).optional()
-      }
-    },
-    (args) => {
-      const sid = resolveSession();
-      if (!sid) return json({ error: "No discovery session found." });
-      const r = db.getDependencies(sid, args.id, { direction: args.direction ?? "downstream", maxDepth: args.maxDepth ?? 8 });
-      return json({
-        root: r.root ? compactNode(r.root) : null,
-        direction: r.direction,
-        count: r.nodes.length,
-        nodes: r.nodes.map((n) => ({ ...compactNode(n), depth: n.depth })),
-        edges: r.edges.map((e) => ({ from: e.sourceId, to: e.targetId, rel: e.relationship }))
-      });
-    }
-  );
-  if (opts.discovery) {
-    const discovery = opts.discovery;
-    server.registerTool(
-      "run_discovery",
-      {
-        title: "Run discovery",
-        description: "Scan the local system (read-only) and update the catalog. Returns counts of nodes/edges found.",
-        inputSchema: { hint: z2.string().optional().describe("Optional focus, e.g. tool names to look for") }
-      },
-      async (args) => {
-        let sid = resolveSession();
-        if (!sid) sid = db.createSession("discover", defaultConfig());
-        const result = await discovery(db, sid, { hint: args.hint });
-        server.server.sendResourceUpdated({ uri: "cartography://graph/summary" }).catch(() => {
-        });
-        server.server.sendResourceListChanged?.();
-        return json({ session: sid, ...result });
-      }
-    );
-  }
-  server.registerPrompt(
-    "audit-attack-surface",
-    { title: "Audit attack surface", description: "Review the discovered topology for externally-reachable services and risky dependencies." },
-    () => ({
-      messages: [{
-        role: "user",
-        content: { type: "text", text: "Read cartography://graph/summary and cartography://services. Identify externally-reachable services, data stores with broad inbound dependencies, and any node with low confidence that warrants verification. Use get_dependencies to assess blast radius. Summarize the attack surface and concrete hardening recommendations." }
-      }]
-    })
-  );
-  server.registerPrompt(
-    "map-service-dependencies",
-    {
-      title: "Map service dependencies",
-      description: "Produce a dependency map for a given service.",
-      argsSchema: { service: z2.string().describe("Service node id or name") }
-    },
-    (args) => ({
-      messages: [{
-        role: "user",
-        content: { type: "text", text: `Use query_infrastructure to locate "${args.service}", then get_dependencies (direction=both) to map everything it depends on and everything that depends on it. Present the result as a clear dependency tree and call out single points of failure.` }
-      }]
-    })
-  );
-  server.registerPrompt(
-    "onboard-to-system",
-    { title: "Onboard to system", description: "Explain the system landscape to a new engineer." },
-    () => ({
-      messages: [{
-        role: "user",
-        content: { type: "text", text: "Read cartography://graph/summary, then cartography://services and cartography://databases. Write a concise onboarding briefing for a new engineer: what the major systems are, how they connect, which data stores are central, and where to look first." }
-      }]
-    })
-  );
-  return server;
-}
-
-// src/mcp/transports.ts
-import { randomUUID } from "crypto";
-import http from "http";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-async function runStdio(server) {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-async function readJsonBody(req) {
-  const chunks = [];
-  for await (const chunk of req) chunks.push(chunk);
-  if (chunks.length === 0) return void 0;
-  try {
-    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-  } catch {
-    return void 0;
-  }
-}
-async function runHttp(factory, opts = {}) {
-  const host = opts.host ?? "127.0.0.1";
-  const port = opts.port ?? 3737;
-  const allowedHosts = opts.allowedHosts ?? [`${host}:${port}`, `localhost:${port}`, `127.0.0.1:${port}`];
-  const transports = /* @__PURE__ */ new Map();
-  const httpServer = http.createServer(async (req, res) => {
-    try {
-      const url = req.url ?? "";
-      if (!url.startsWith("/mcp")) {
-        res.writeHead(404, { "content-type": "application/json" }).end('{"error":"not found"}');
-        return;
-      }
-      const sessionId = req.headers["mcp-session-id"];
-      const existing = sessionId ? transports.get(sessionId) : void 0;
-      if (existing) {
-        const body2 = req.method === "POST" ? await readJsonBody(req) : void 0;
-        await existing.handleRequest(req, res, body2);
-        return;
-      }
-      if (req.method !== "POST") {
-        res.writeHead(400, { "content-type": "application/json" }).end('{"error":"missing or unknown mcp-session-id"}');
-        return;
-      }
-      const body = await readJsonBody(req);
-      const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-        enableDnsRebindingProtection: true,
-        allowedHosts,
-        ...opts.allowedOrigins ? { allowedOrigins: opts.allowedOrigins } : {},
-        onsessioninitialized: (id) => {
-          transports.set(id, transport);
-        }
-      });
-      transport.onclose = () => {
-        if (transport.sessionId) transports.delete(transport.sessionId);
-      };
-      await factory().connect(transport);
-      await transport.handleRequest(req, res, body);
-    } catch {
-      if (!res.headersSent) res.writeHead(500, { "content-type": "application/json" }).end('{"error":"internal error"}');
-    }
-  });
-  await new Promise((resolve) => httpServer.listen(port, host, resolve));
-  return httpServer;
-}
-
-// src/semantic/hash.ts
-function fnv1a(s) {
-  let h = 2166136261;
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return h >>> 0;
-}
-
-// src/semantic/embeddings.ts
-async function createLocalEmbedder(model = "Xenova/all-MiniLM-L6-v2") {
-  try {
-    const tf = await import("./transformers.node-BTYUTJK5.js");
-    const extractor = await tf.pipeline("feature-extraction", model);
-    return {
-      id: `local:${model}`,
-      dimensions: 384,
-      async embed(texts) {
-        const out = [];
-        for (const text of texts) {
-          const tensor = await extractor(text, { pooling: "mean", normalize: true });
-          out.push(Float32Array.from(tensor.data));
-        }
-        return out;
-      }
-    };
-  } catch {
-    return void 0;
-  }
-}
-
-// src/semantic/store.ts
-function nodeText(n) {
-  const desc = typeof n.metadata?.["description"] === "string" ? n.metadata["description"] : "";
-  const category = typeof n.metadata?.["category"] === "string" ? n.metadata["category"] : "";
-  return [n.name, n.id.replace(/[:_]/g, " "), `type ${n.type}`, n.domain ?? "", n.subDomain ?? "", category, n.tags.join(" "), desc].filter(Boolean).join(" \u2014 ");
-}
-function hash(s) {
-  return fnv1a(s).toString(16);
-}
-function toBuffer(v) {
-  return Buffer.from(v.buffer, v.byteOffset, v.byteLength);
-}
-var VectorStore = class {
-  constructor(db, embedder) {
-    this.db = db;
-    this.embedder = embedder;
-  }
-  loaded = false;
-  /** Load sqlite-vec and ensure the schema exists. Returns false if unavailable. */
-  async init() {
-    if (this.loaded) return true;
-    try {
-      const conn = this.db.rawConnection();
-      const sqliteVec = await import("./sqlite-vec-EZN67B2V.js");
-      sqliteVec.load(conn);
-      conn.exec(`
-        CREATE TABLE IF NOT EXISTS vec_index (
-          rowid INTEGER PRIMARY KEY AUTOINCREMENT,
-          session_id TEXT NOT NULL,
-          node_id TEXT NOT NULL,
-          hash TEXT NOT NULL,
-          UNIQUE(session_id, node_id)
-        );
-        CREATE TABLE IF NOT EXISTS vec_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
-      `);
-      const dimRow = conn.prepare("SELECT value FROM vec_meta WHERE key = 'dims'").get();
-      const dims = this.embedder.dimensions;
-      if (dimRow && Number(dimRow.value) !== dims) {
-        conn.exec("DROP TABLE IF EXISTS vec_nodes; DELETE FROM vec_index;");
-      }
-      conn.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS vec_nodes USING vec0(embedding float[${dims}])`);
-      conn.prepare("INSERT OR REPLACE INTO vec_meta(key, value) VALUES (?, ?)").run("dims", String(dims));
-      conn.prepare("INSERT OR REPLACE INTO vec_meta(key, value) VALUES (?, ?)").run("embedder", this.embedder.id);
-      this.loaded = true;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /** Incrementally embed and index any new/changed nodes for a session. */
-  async index(sessionId) {
-    if (!await this.init()) return { embedded: 0, total: 0 };
-    const conn = this.db.rawConnection();
-    const nodes = this.db.getNodes(sessionId);
-    const getRow = conn.prepare("SELECT rowid, hash FROM vec_index WHERE session_id = ? AND node_id = ?");
-    const insIndex = conn.prepare("INSERT INTO vec_index (session_id, node_id, hash) VALUES (?, ?, ?)");
-    const updHash = conn.prepare("UPDATE vec_index SET hash = ? WHERE rowid = ?");
-    const delVec = conn.prepare("DELETE FROM vec_nodes WHERE rowid = ?");
-    const insVec = conn.prepare("INSERT INTO vec_nodes (rowid, embedding) VALUES (?, ?)");
-    const pending = [];
-    for (const n of nodes) {
-      const text = nodeText(n);
-      const h = hash(`${this.embedder.id}:${text}`);
-      const existing = getRow.get(sessionId, n.id);
-      if (existing) {
-        if (existing.hash === h) continue;
-        updHash.run(h, existing.rowid);
-        delVec.run(BigInt(existing.rowid));
-        pending.push({ rowid: BigInt(existing.rowid), text });
-      } else {
-        const info = insIndex.run(sessionId, n.id, h);
-        pending.push({ rowid: BigInt(info.lastInsertRowid), text });
-      }
-    }
-    if (pending.length > 0) {
-      const vectors = await this.embedder.embed(pending.map((p) => p.text));
-      const tx = conn.transaction(() => {
-        pending.forEach((p, i) => insVec.run(p.rowid, toBuffer(vectors[i])));
-      });
-      tx();
-    }
-    return { embedded: pending.length, total: nodes.length };
-  }
-  /** k-nearest-neighbour search within a session. Returns node ids + distances. */
-  async search(sessionId, query, k) {
-    if (!await this.init()) return [];
-    await this.index(sessionId);
-    const conn = this.db.rawConnection();
-    const [qv] = await this.embedder.embed([query]);
-    if (!qv) return [];
-    const overfetch = Math.max(k * 5, k);
-    const knn = conn.prepare(
-      "SELECT rowid, distance FROM vec_nodes WHERE embedding MATCH ? ORDER BY distance LIMIT ?"
-    ).all(toBuffer(qv), overfetch);
-    const meta = conn.prepare("SELECT node_id AS nodeId, session_id AS sessionId FROM vec_index WHERE rowid = ?");
-    const out = [];
-    for (const row of knn) {
-      const m = meta.get(row.rowid);
-      if (m && m.sessionId === sessionId) out.push({ nodeId: m.nodeId, distance: row.distance });
-      if (out.length >= k) break;
-    }
-    return out;
-  }
-};
-
-// src/semantic/search.ts
-var lexical = (db, sessionId, query, opts) => db.searchNodes(sessionId, query, { types: opts.types, limit: opts.limit }).map((node) => ({ node }));
-var lexicalSearch2 = () => async (d, sid, q, opts) => lexical(d, sid, q, opts);
-async function createSemanticSearch(db, embedder) {
-  const provider = embedder ?? await createLocalEmbedder();
-  if (!provider) return lexicalSearch2();
-  const store = new VectorStore(db, provider);
-  const ok = await store.init();
-  if (!ok) return lexicalSearch2();
-  return async (d, sid, query, opts) => {
-    const hits = await store.search(sid, query, opts.limit);
-    if (hits.length === 0) return lexical(d, sid, query, opts);
-    const byId = d.getNodesByIds(sid, hits.map((h) => h.nodeId));
-    const results = [];
-    for (const h of hits) {
-      const node = byId.get(h.nodeId);
-      if (!node) continue;
-      if (opts.types && opts.types.length > 0 && !opts.types.includes(node.type)) continue;
-      results.push({ node, score: Math.max(0, 1 - h.distance / 2) });
-    }
-    return results.length > 0 ? results : lexical(d, sid, query, opts);
-  };
-}
-
-// src/scanners/types.ts
-var ScannerRegistry = class {
-  scanners = /* @__PURE__ */ new Map();
-  register(scanner) {
-    if (this.scanners.has(scanner.id)) throw new Error(`scanner already registered: ${scanner.id}`);
-    this.scanners.set(scanner.id, scanner);
-    return this;
-  }
-  get(id) {
-    return this.scanners.get(id);
-  }
-  list() {
-    return [...this.scanners.values()];
-  }
-  /** Scanners whose `platforms` include the given platform. */
-  forPlatform(platform) {
-    return this.list().filter((s) => s.platforms === "all" || s.platforms.includes(platform));
-  }
-};
-
-// src/scanners/bookmarks.ts
-var PERSONAL = [
-  "facebook.",
-  "instagram.",
-  "twitter.",
-  "x.com",
-  "tiktok.",
-  "reddit.",
-  "youtube.",
-  "netflix.",
-  "spotify.",
-  "twitch.",
-  "pinterest.",
-  "snapchat.",
-  "whatsapp.",
-  "amazon.",
-  "ebay.",
-  "aliexpress.",
-  "cnn.",
-  "bbc.",
-  "nytimes.",
-  "espn.",
-  "booking.",
-  "airbnb.",
-  "tripadvisor.",
-  "wikipedia."
-];
-var BUSINESS = [
-  "github.",
-  "gitlab.",
-  "bitbucket.",
-  "atlassian.",
-  "jira.",
-  "confluence.",
-  "notion.",
-  "linear.",
-  "slack.",
-  "zoom.",
-  "figma.",
-  "miro.",
-  "vercel.",
-  "netlify.",
-  "heroku.",
-  "datadog",
-  "sentry.",
-  "grafana.",
-  "pagerduty.",
-  "aws.amazon.",
-  "console.cloud.google",
-  "portal.azure",
-  "cloudflare.",
-  "hubspot.",
-  "salesforce.",
-  "stripe.",
-  "twilio.",
-  "sendgrid.",
-  "mailchimp.",
-  "segment.",
-  "mixpanel.",
-  "amplitude.",
-  "looker.",
-  "tableau.",
-  "snowflake.",
-  "databricks.",
-  "mongodb.",
-  "redis.",
-  "elastic.",
-  "openai.",
-  "anthropic.",
-  "huggingface.",
-  "docker.",
-  "npmjs.",
-  "pypi.",
-  "circleci.",
-  "travis-ci.",
-  "jenkins.",
-  "terraform.",
-  "hashicorp.",
-  "okta.",
-  "auth0.",
-  "1password.",
-  "asana.",
-  "trello.",
-  "monday."
-];
-function classify(hostname) {
-  const h = hostname.toLowerCase();
-  if (PERSONAL.some((p) => h.includes(p))) return null;
-  if (BUSINESS.some((b) => h.includes(b))) return { type: "saas_tool", confidence: 0.7 };
-  if (/^\d+\.\d+\.\d+\.\d+$/.test(h) || /\.(internal|local|corp|lan)\b/.test(h)) {
-    return { type: "web_service", confidence: 0.6 };
-  }
-  return null;
-}
-var bookmarksScanner = {
-  id: "bookmarks",
-  title: "Browser bookmarks",
-  platforms: "all",
-  detect: () => true,
-  async scan() {
-    const hosts = await scanAllBookmarks();
-    const seen = /* @__PURE__ */ new Set();
-    const nodes = [];
-    for (const host of hosts) {
-      const klass = classify(host.hostname);
-      if (!klass) continue;
-      const id = `${klass.type}:${host.hostname}`;
-      if (seen.has(id)) continue;
-      seen.add(id);
-      nodes.push({
-        id,
-        type: klass.type,
-        name: host.hostname,
-        discoveredVia: "bookmark",
-        confidence: klass.confidence,
-        tags: ["bookmark"],
-        metadata: { protocol: host.protocol, ...host.port ? { port: host.port } : {} }
-      });
-    }
-    return { nodes, edges: [] };
-  }
-};
-
-// src/scanners/installed-apps.ts
-var KNOWN_TOOLS = {
-  ide: ["code", "code-insiders", "cursor", "windsurf", "zed", "nvim", "vim", "emacs", "idea", "webstorm", "pycharm", "goland", "datagrip", "clion", "rider", "phpstorm"],
-  "dev-tool": ["git", "gh", "docker", "docker-compose", "podman", "kubectl", "helm", "terraform", "ansible", "vagrant", "packer", "consul", "vault", "nomad"],
-  runtime: ["node", "npm", "pnpm", "yarn", "bun", "deno", "python", "python3", "pip", "poetry", "ruby", "rails", "java", "mvn", "gradle", "go", "cargo", "rustc", "php", "composer", "dotnet"],
-  database: ["psql", "mysql", "mongosh", "redis-cli", "sqlite3", "clickhouse-client"],
-  cloud: ["aws", "gcloud", "az", "heroku", "fly", "vercel", "netlify", "wrangler", "supabase"],
-  browser: ["google-chrome", "chromium", "firefox", "brave", "opera"],
-  observability: ["prometheus", "grafana-cli", "datadog-agent", "newrelic-agent"]
-};
-var installedAppsScanner = {
-  id: "installed-apps",
-  title: "Installed apps & developer tools",
-  platforms: "all",
-  allowedCommands: ["which", "command", "Get-Command"],
-  detect: () => true,
-  async scan(ctx) {
-    const nodes = [];
-    const hintTerms = (ctx.hint ?? "").toLowerCase().split(/[\s,]+/).filter(Boolean);
-    for (const [category, tools] of Object.entries(KNOWN_TOOLS)) {
-      for (const tool of tools) {
-        const path = commandExists(tool);
-        if (!path) continue;
-        const boosted = hintTerms.some((t) => tool.includes(t));
-        nodes.push({
-          id: `saas_tool:${tool}`,
-          type: "saas_tool",
-          name: tool,
-          discoveredVia: "installed-app",
-          confidence: boosted ? 0.95 : 0.9,
-          tags: [category],
-          metadata: { category, path }
-        });
-      }
-    }
-    return { nodes, edges: [] };
-  }
-};
-
-// src/scanners/ports.ts
-var PORT_MAP = {
-  5432: { type: "database_server", service: "postgresql" },
-  3306: { type: "database_server", service: "mysql" },
-  1433: { type: "database_server", service: "sqlserver" },
-  27017: { type: "database_server", service: "mongodb" },
-  9200: { type: "database_server", service: "elasticsearch" },
-  6379: { type: "cache_server", service: "redis" },
-  11211: { type: "cache_server", service: "memcached" },
-  9092: { type: "message_broker", service: "kafka" },
-  5672: { type: "message_broker", service: "rabbitmq" },
-  4222: { type: "message_broker", service: "nats" },
-  9090: { type: "web_service", service: "prometheus" },
-  3e3: { type: "web_service", service: "http-app" },
-  8080: { type: "web_service", service: "http-app" },
-  8e3: { type: "web_service", service: "http-app" },
-  80: { type: "web_service", service: "http" },
-  443: { type: "web_service", service: "https" },
-  8200: { type: "web_service", service: "vault" },
-  8500: { type: "web_service", service: "consul" },
-  2379: { type: "web_service", service: "etcd" },
-  5601: { type: "web_service", service: "kibana" },
-  15672: { type: "web_service", service: "rabbitmq-management" }
-};
-function extractListeningPorts(raw) {
-  const ports = /* @__PURE__ */ new Set();
-  for (const m of raw.matchAll(/[:.](\d{2,5})\b/g)) {
-    const p = Number(m[1]);
-    if (p in PORT_MAP) ports.add(p);
-  }
-  return [...ports];
-}
-var portsScanner = {
-  id: "local-ports",
-  title: "Local listening ports",
-  platforms: "all",
-  allowedCommands: ["ss", "lsof", "Get-NetTCPConnection"],
-  detect: () => true,
-  async scan() {
-    const raw = scanListeningPorts();
-    const nodes = [];
-    for (const port of extractListeningPorts(raw)) {
-      const { type, service } = PORT_MAP[port];
-      nodes.push({
-        id: `${type}:localhost:${port}`,
-        type,
-        name: `${service} (:${port})`,
-        discoveredVia: "listening-port",
-        confidence: 0.9,
-        tags: ["local", service],
-        metadata: { port, service, host: "localhost" }
-      });
-    }
-    return { nodes, edges: [] };
-  }
-};
-
-// src/scanners/registry.ts
-function defaultRegistry() {
-  return new ScannerRegistry().register(bookmarksScanner).register(installedAppsScanner).register(portsScanner);
-}
-
-// src/discovery/local.ts
-async function runLocalDiscovery(db, sessionId, opts = {}) {
-  const registry = opts.registry ?? defaultRegistry();
-  const ctx = { hint: opts.hint, platform: PLATFORM, run };
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = [];
-  const ran = [];
-  for (const scanner of registry.forPlatform(PLATFORM)) {
-    try {
-      if (!await scanner.detect(ctx)) continue;
-      const result = await scanner.scan(ctx);
-      ran.push(scanner.id);
-      for (const node of result.nodes) {
-        const prev = nodes.get(node.id);
-        if (!prev || node.confidence > prev.confidence) nodes.set(node.id, node);
-      }
-      edges.push(...result.edges);
-      opts.onProgress?.(`${scanner.title}: +${result.nodes.length} nodes`);
-    } catch (err) {
-      opts.onProgress?.(`${scanner.title}: failed (${err instanceof Error ? err.message : String(err)})`);
-    }
-  }
-  for (const node of nodes.values()) db.upsertNode(sessionId, node);
-  for (const edge of edges) {
-    if (nodes.has(edge.sourceId) && nodes.has(edge.targetId)) db.insertEdge(sessionId, edge);
-  }
-  return { nodes: nodes.size, edges: edges.length, scanners: ran };
-}
-function localDiscoveryFn(registry) {
-  return async (db, sessionId, opts) => {
-    const r = await runLocalDiscovery(db, sessionId, { hint: opts.hint, registry });
-    return { nodes: r.nodes, edges: r.edges };
-  };
-}
-
-// src/mcp/start.ts
-async function startMcp(opts = {}) {
-  const log = opts.log ?? ((m) => process.stderr.write(m + "\n"));
-  const db = new CartographyDB(opts.dbPath ?? defaultConfig().dbPath);
-  let search;
-  if (opts.semantic !== false) {
-    search = await createSemanticSearch(db);
-    log("semantic search: ready");
-  }
-  const discovery = localDiscoveryFn();
-  const factory = () => createMcpServer({ db, session: opts.session ?? "latest", search, discovery });
-  if (opts.transport === "http") {
-    const port = opts.port ?? 3737;
-    const host = opts.host ?? "127.0.0.1";
-    await runHttp(factory, { port, host });
-    log(`Cartography MCP server (Streamable HTTP) on http://${host}:${port}/mcp`);
-  } else {
-    log("Cartography MCP server (stdio) ready");
-    await runStdio(factory());
-  }
-}
-
-export {
-  CartographyDB,
-  startMcp
-};
-//# sourceMappingURL=chunk-W7YE6AAH.js.map