claude-launchpad 0.6.1 → 0.7.0

package/dist/tui-R25NTQ4K.js

@@ -0,0 +1,1100 @@
+#!/usr/bin/env node
+import {
+  MemoryRepo,
+  RelationRepo,
+  SearchRepo
+} from "./chunk-TALTTAMW.js";
+import {
+  DEFAULT_DECAY_PARAMS,
+  closeDatabase,
+  createDatabase,
+  loadConfig,
+  migrate,
+  resolveDataDir
+} from "./chunk-IILH26C7.js";
+import "./chunk-2H7UOFLK.js";
+
+// src/commands/memory/dashboard/tui.ts
+import blessed9 from "blessed";
+
+// src/commands/memory/dashboard/data/data-source.ts
+import { statSync, watchFile, unwatchFile } from "fs";
+import { join } from "path";
+var DashboardDataSource = class {
+  #memoryRepo;
+  #relationRepo;
+  #searchRepo;
+  #dbPath;
+  #cachedMemories = [];
+  constructor(memoryRepo, relationRepo, searchRepo, dataDir) {
+    this.#memoryRepo = memoryRepo;
+    this.#relationRepo = relationRepo;
+    this.#searchRepo = searchRepo;
+    this.#dbPath = join(dataDir, "memory.db");
+  }
+  /** Re-query all memories from DB and cache them. Excludes soft-deleted (importance=0). */
+  refresh() {
+    this.#cachedMemories = this.#memoryRepo.getAll().filter((m) => m.importance > 0);
+  }
+  /** Return cached memories, optionally filtered by type, project, or FTS query. */
+  getMemories(filter) {
+    if (!filter) return this.#cachedMemories;
+    let results = this.#cachedMemories;
+    if (filter.type) {
+      const t = filter.type;
+      results = results.filter((m) => m.type === t);
+    }
+    if (filter.project) {
+      const p = filter.project;
+      results = results.filter((m) => m.project === p);
+    }
+    if (filter.query) {
+      const matches = this.#searchRepo.searchFts({
+        query: filter.query,
+        limit: 100
+      });
+      const matchedIds = new Set(matches.map((m) => m.memoryId));
+      results = results.filter((m) => matchedIds.has(m.id));
+    }
+    return results;
+  }
+  /** Get all relations for a specific memory. */
+  getRelationsForMemory(id) {
+    return this.#relationRepo.getByMemory(id);
+  }
+  /** Compute aggregate stats from cached data + DB queries. */
+  getStats() {
+    const total = this.#memoryRepo.count();
+    const byType = this.#memoryRepo.countByType();
+    const relations = this.#relationRepo.count();
+    const { oldest, newest } = this.#memoryRepo.dateRange();
+    const dbSizeBytes = this.#getDbSize();
+    const byProject = this.#computeByProject();
+    return { total, byType, byProject, relations, dbSizeBytes, oldest, newest };
+  }
+  /** Derive unique project names from cached memories. */
+  getProjects() {
+    const projects = /* @__PURE__ */ new Set();
+    for (const m of this.#cachedMemories) {
+      if (m.project) {
+        projects.add(m.project);
+      }
+    }
+    return [...projects].sort();
+  }
+  /** Watch the DB file for changes (2s polling interval). Only fires on mtime change. */
+  startWatching(onChange) {
+    let lastMtime = 0;
+    watchFile(this.#dbPath, { interval: 2e3 }, (curr) => {
+      const mtime = curr.mtimeMs;
+      if (mtime === lastMtime) return;
+      lastMtime = mtime;
+      this.refresh();
+      onChange();
+    });
+  }
+  /** Stop watching the DB file. */
+  stopWatching() {
+    unwatchFile(this.#dbPath);
+  }
+  // -- Private helpers --------------------------------------------------------
+  #getDbSize() {
+    try {
+      return statSync(this.#dbPath).size;
+    } catch {
+      return 0;
+    }
+  }
+  #computeByProject() {
+    const counts = {};
+    for (const m of this.#cachedMemories) {
+      const key = m.project ?? "(none)";
+      counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return counts;
+  }
+};
+
+// src/commands/memory/dashboard/layout.ts
+import blessed8 from "blessed";
+
+// src/commands/memory/dashboard/widgets/header.ts
+import blessed from "blessed";
+function createHeader(screen) {
+  const box = blessed.box({
+    parent: screen,
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: 1,
+    tags: true,
+    style: { fg: "black", bg: "green", bold: true },
+    content: "{bold} agentic-memory cockpit {/bold}  {|} [/]=search [p]=project picker [[/]]=prev/next [1-5]=type [l]=life [s]=sort [tab]=focus [?]=help [q]=quit"
+  });
+  return {
+    widget: box,
+    setLabel(text) {
+      box.setContent(
+        `{bold} ${text} {/bold}  {|} [/]=search [p]=project picker [[/]]=prev/next [1-5]=type [l]=life [s]=sort [tab]=focus [?]=help [q]=quit`
+      );
+    }
+  };
+}
+
+// src/commands/memory/dashboard/widgets/memory-list.ts
+import blessed2 from "blessed";
+
+// src/commands/memory/dashboard/data/formatters.ts
+function escapeBlessedTags(text) {
+  return text.replace(/\{/g, "\uFF5B").replace(/\}/g, "\uFF5D");
+}
+var MINUTE = 6e4;
+var HOUR = 36e5;
+var DAY = 864e5;
+var MONTH = 30 * DAY;
+var YEAR = 365 * DAY;
+function formatRelativeTime(isoString) {
+  const diff = Date.now() - new Date(isoString).getTime();
+  if (diff < 0) return "just now";
+  if (diff < MINUTE) return "just now";
+  if (diff < HOUR) return `${Math.floor(diff / MINUTE)}m ago`;
+  if (diff < DAY) return `${Math.floor(diff / HOUR)}h ago`;
+  if (diff < MONTH) return `${Math.floor(diff / DAY)}d ago`;
+  if (diff < YEAR) return `${Math.floor(diff / MONTH)}mo ago`;
+  return `${Math.floor(diff / YEAR)}y ago`;
+}
+var FILLED = "\u2588";
+var EMPTY = "\u2591";
+function formatImportanceBar(value, width = 8) {
+  const clamped = Math.max(0, Math.min(1, value));
+  const filled = Math.round(clamped * width);
+  return FILLED.repeat(filled) + EMPTY.repeat(width - filled);
+}
+function truncate(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  if (maxLen <= 1) return "\u2026";
+  return text.slice(0, maxLen - 1) + "\u2026";
+}
+var UNITS = ["B", "KB", "MB", "GB"];
+function formatBytes(bytes) {
+  if (bytes < 0) return "0B";
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < UNITS.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  if (unitIndex === 0) return `${value}B`;
+  return `${value.toFixed(1)}${UNITS[unitIndex]}`;
+}
+function tauDaysForType(type) {
+  return DEFAULT_DECAY_PARAMS.tauByType[type];
+}
+function computeLifespan(memory) {
+  const tauDays = tauDaysForType(memory.type);
+  if (tauDays === 0) {
+    return {
+      status: "session",
+      tauDays,
+      ageDays: 0,
+      remaining: 0
+    };
+  }
+  const ageDays = Math.max(
+    0,
+    (Date.now() - new Date(memory.updatedAt).getTime()) / DAY
+  );
+  const remaining = Math.max(0, Math.min(1, 1 - ageDays / (tauDays * 2)));
+  const status = remaining > 0.62 ? "healthy" : remaining > 0.32 ? "fading" : "stale";
+  return { status, tauDays, ageDays, remaining };
+}
+function formatLifespanLabel(status) {
+  switch (status) {
+    case "healthy":
+      return "HEALTHY";
+    case "fading":
+      return "FADING ";
+    case "stale":
+      return "STALE  ";
+    case "session":
+      return "SESSION";
+  }
+}
+
+// src/commands/memory/dashboard/colors.ts
+var TYPE_COLORS = {
+  working: "red",
+  episodic: "yellow",
+  semantic: "cyan",
+  procedural: "green",
+  pattern: "magenta"
+};
+var TYPE_ABBREV = {
+  working: "WORK",
+  episodic: "EPIS",
+  semantic: "SEMA",
+  procedural: "PROC",
+  pattern: "PTRN"
+};
+var RELATION_COLORS = {
+  relates_to: "white",
+  depends_on: "blue",
+  contradicts: "red",
+  extends: "green",
+  implements: "cyan",
+  derived_from: "yellow"
+};
+
+// src/commands/memory/dashboard/widgets/memory-list.ts
+function createMemoryList(screen) {
+  const list = blessed2.list({
+    parent: screen,
+    top: 1,
+    left: 0,
+    width: "60%",
+    height: "100%-4",
+    keys: true,
+    vi: true,
+    mouse: true,
+    tags: true,
+    interactive: true,
+    scrollable: true,
+    alwaysScroll: true,
+    border: { type: "line" },
+    label: " Memories ",
+    style: {
+      border: { fg: "cyan" },
+      item: { fg: "white" },
+      selected: { fg: "black", bg: "green" }
+    },
+    scrollbar: {
+      style: { bg: "cyan" }
+    }
+  });
+  let currentMemories = [];
+  let selectCallback = null;
+  function colorForLife(status) {
+    switch (status) {
+      case "healthy":
+        return "green";
+      case "fading":
+        return "yellow";
+      case "stale":
+        return "red";
+      case "session":
+        return "magenta";
+    }
+  }
+  function buildRows(memories) {
+    return memories.map((m) => {
+      const life = computeLifespan(m);
+      const title = escapeBlessedTags(
+        truncate(m.title ?? m.content.replace(/\n/g, " "), 36)
+      );
+      const project = escapeBlessedTags(truncate(m.project ?? "(none)", 14));
+      const type = TYPE_ABBREV[m.type] ?? m.type;
+      const lifeColor = colorForLife(life.status);
+      const lifeLabel = formatLifespanLabel(life.status).trim();
+      const imp = `${Math.round(m.importance * 100)}%`;
+      const updated = formatRelativeTime(m.updatedAt);
+      return [
+        `{bold}${title}{/bold}`,
+        `{gray-fg}${project}{/gray-fg}`,
+        `{cyan-fg}${type}{/cyan-fg}`,
+        `{${lifeColor}-fg}${lifeLabel}{/${lifeColor}-fg}`,
+        `{white-fg}${imp}{/white-fg}`,
+        `{gray-fg}${updated}{/gray-fg}`,
+        `{blue-fg}acc:${m.accessCount}{/blue-fg}`
+      ].join("  ");
+    });
+  }
+  function emitCurrentSelection() {
+    const idx = list.selected;
+    const memory = currentMemories[idx];
+    if (memory && selectCallback) selectCallback(memory);
+  }
+  list.on("select", () => emitCurrentSelection());
+  list.on("select item", () => emitCurrentSelection());
+  return {
+    widget: list,
+    setData(memories) {
+      currentMemories = memories;
+      const rows = buildRows(memories);
+      list.setItems(rows);
+    },
+    onSelect(callback) {
+      selectCallback = callback;
+    },
+    focus() {
+      list.focus();
+      if (currentMemories.length > 0) {
+        list.select(0);
+        emitCurrentSelection();
+      }
+    }
+  };
+}
+
+// src/commands/memory/dashboard/widgets/memory-detail.ts
+import blessed3 from "blessed";
+function createMemoryDetail(screen) {
+  const box = blessed3.box({
+    parent: screen,
+    top: 1,
+    left: "45%",
+    width: "55%",
+    height: "100%-4",
+    keys: true,
+    vi: true,
+    mouse: true,
+    scrollable: true,
+    alwaysScroll: true,
+    tags: true,
+    border: { type: "line" },
+    label: " Detail ",
+    style: {
+      border: { fg: "blue" },
+      fg: "white"
+    },
+    scrollbar: {
+      style: { bg: "blue" }
+    }
+  });
+  return {
+    widget: box,
+    showMemory(memory, relations) {
+      const typeColor = TYPE_COLORS[memory.type] ?? "white";
+      const life = computeLifespan(memory);
+      const lines = [
+        `{bold}${escapeBlessedTags(memory.title ?? "(untitled)")}{/bold}`,
+        "",
+        `Type:       {${typeColor}-fg}${memory.type}{/${typeColor}-fg}`,
+        `Lifespan:   ${formatLifespanLabel(life.status)} | age ${Math.round(life.ageDays)}d | tau ${life.tauDays}d`,
+        `Health:     ${formatImportanceBar(life.remaining)} ${(life.remaining * 100).toFixed(0)}% remaining`,
+        `Importance: ${formatImportanceBar(memory.importance)} ${memory.importance.toFixed(2)}`,
+        `Project:    ${escapeBlessedTags(memory.project ?? "(none)")}`,
+        `Tags:       ${memory.tags.length > 0 ? memory.tags.map((t) => `[${escapeBlessedTags(t)}]`).join(" ") : "(none)"}`,
+        `Source:     ${memory.source ?? "unknown"}`,
+        "",
+        `Created:    ${formatRelativeTime(memory.createdAt)}`,
+        `Updated:    ${formatRelativeTime(memory.updatedAt)}`,
+        `Accessed:   ${memory.accessCount}x${memory.lastAccessed ? ` (last: ${formatRelativeTime(memory.lastAccessed)})` : ""}`,
+        `Injected:   ${memory.injectionCount}x`,
+        "",
+        "{bold}Content{/bold}",
+        "{gray-fg}" + "\u2500".repeat(40) + "{/gray-fg}",
+        escapeBlessedTags(memory.content)
+      ];
+      if (relations.length > 0) {
+        lines.push(
+          "",
+          "{bold}Relations{/bold}",
+          "{gray-fg}" + "\u2500".repeat(40) + "{/gray-fg}"
+        );
+        for (const r of relations) {
+          const relColor = RELATION_COLORS[r.relationType] ?? "white";
+          const direction = r.sourceId === memory.id ? "\u2192" : "\u2190";
+          const otherId = r.sourceId === memory.id ? r.targetId : r.sourceId;
+          lines.push(
+            `  ${direction} {${relColor}-fg}${r.relationType}{/${relColor}-fg} ${otherId}`
+          );
+        }
+      }
+      box.setContent(lines.join("\n"));
+      box.scrollTo(0);
+    },
+    clear() {
+      box.setContent("{gray-fg}Select a memory to view details{/gray-fg}");
+    }
+  };
+}
+
+// src/commands/memory/dashboard/widgets/stats-bar.ts
+import blessed4 from "blessed";
+function createStatsBar(screen) {
+  const box = blessed4.box({
+    parent: screen,
+    bottom: 0,
+    left: 0,
+    width: "100%",
+    height: 3,
+    tags: true,
+    border: { type: "line" },
+    style: {
+      border: { fg: "blue" },
+      fg: "white"
+    }
+  });
+  return {
+    widget: box,
+    setStats(stats, visibleMemories) {
+      const typeBreakdown = Object.entries(stats.byType).filter(([, count]) => count > 0).map(([type, count]) => {
+        const color = TYPE_COLORS[type] ?? "white";
+        return `{${color}-fg}${type}:${count}{/${color}-fg}`;
+      }).join("  ");
+      const projects = Object.entries(stats.byProject).map(([name, count]) => `${name}(${count})`).join(" ");
+      const lifeCounts = { healthy: 0, fading: 0, stale: 0, session: 0 };
+      for (const memory of visibleMemories) {
+        lifeCounts[computeLifespan(memory).status]++;
+      }
+      const lifeSummary = `Life H:${lifeCounts.healthy} F:${lifeCounts.fading} S:${lifeCounts.stale} Sess:${lifeCounts.session}`;
+      box.setContent(
+        `{bold}Total:{/bold} ${stats.total}  {bold}Relations:{/bold} ${stats.relations}  {bold}Visible:{/bold} ${visibleMemories.length}  {bold}DB:{/bold} ${formatBytes(stats.dbSizeBytes)}
+{bold}${lifeSummary}{/bold}  ${typeBreakdown}  ${projects}`
+      );
+    }
+  };
+}
+
+// src/commands/memory/dashboard/widgets/search-modal.ts
+import blessed5 from "blessed";
+function createSearchModal(screen) {
+  const box = blessed5.box({
+    top: "center",
+    left: "center",
+    width: 60,
+    height: 5,
+    border: { type: "line" },
+    label: " Search ",
+    tags: true,
+    hidden: true,
+    style: {
+      border: { fg: "yellow" },
+      bg: "black"
+    }
+  });
+  const input = blessed5.textbox({
+    parent: box,
+    top: 1,
+    left: 1,
+    right: 1,
+    height: 1,
+    inputOnFocus: true,
+    style: {
+      fg: "white",
+      bg: "black"
+    }
+  });
+  screen.append(box);
+  let submitCallback = null;
+  let cancelCallback = null;
+  let isOpenState = false;
+  let previousFocus = null;
+  function restoreFocus() {
+    if (previousFocus) {
+      previousFocus.focus();
+      previousFocus = null;
+    }
+  }
+  input.on("submit", (value) => {
+    isOpenState = false;
+    box.hide();
+    restoreFocus();
+    screen.render();
+    if (value.trim()) submitCallback?.(value.trim());
+  });
+  input.on("cancel", () => {
+    isOpenState = false;
+    box.hide();
+    restoreFocus();
+    screen.render();
+    cancelCallback?.();
+  });
+  return {
+    widget: box,
+    open() {
+      previousFocus = screen.focused;
+      input.clearValue();
+      isOpenState = true;
+      box.show();
+      input.focus();
+      screen.render();
+    },
+    close() {
+      isOpenState = false;
+      box.hide();
+      restoreFocus();
+      screen.render();
+    },
+    isOpen() {
+      return isOpenState;
+    },
+    onSubmit(callback) {
+      submitCallback = callback;
+    },
+    onCancel(callback) {
+      cancelCallback = callback;
+    }
+  };
+}
+
+// src/commands/memory/dashboard/widgets/project-list.ts
+import blessed6 from "blessed";
+function createProjectList(screen) {
+  const list = blessed6.list({
+    parent: screen,
+    top: 1,
+    left: "60%",
+    width: "40%",
+    height: "35%-1",
+    keys: true,
+    vi: true,
+    mouse: true,
+    tags: true,
+    border: { type: "line" },
+    label: " Projects ",
+    scrollable: true,
+    style: {
+      border: { fg: "magenta" },
+      item: { fg: "white" },
+      selected: { fg: "black", bg: "yellow" }
+    }
+  });
+  let rows = [];
+  let selectCallback = null;
+  let suppressSelect = false;
+  function buildRows(memories) {
+    const byProject = /* @__PURE__ */ new Map();
+    for (const memory of memories) {
+      const project = memory.project ?? "(none)";
+      const bucket = byProject.get(project);
+      if (bucket) {
+        bucket.push(memory);
+      } else {
+        byProject.set(project, [memory]);
+      }
+    }
+    const items = [];
+    for (const [project, projectMemories] of byProject.entries()) {
+      const avgRemaining = projectMemories.reduce(
+        (sum, m) => sum + computeLifespan(m).remaining,
+        0
+      ) / projectMemories.length;
+      items.push({
+        project,
+        total: projectMemories.length,
+        healthPct: Math.round(avgRemaining * 100)
+      });
+    }
+    items.sort((a, b) => b.total - a.total);
+    const allHealth = memories.length > 0 ? Math.round(
+      memories.reduce(
+        (sum, m) => sum + computeLifespan(m).remaining,
+        0
+      ) / memories.length * 100
+    ) : 0;
+    return [
+      { project: void 0, total: memories.length, healthPct: allHealth },
+      ...items
+    ];
+  }
+  function render(activeProject) {
+    const body = rows.map((row) => {
+      const isActive = row.project === activeProject || row.project === void 0 && !activeProject;
+      const projectName = row.project ?? "All projects";
+      const healthColor = row.healthPct > 62 ? "green" : row.healthPct > 32 ? "yellow" : "red";
+      const nameCol = projectName.padEnd(20, " ").slice(0, 20);
+      const countCol = String(row.total).padStart(3, " ");
+      const healthCol = `${String(row.healthPct).padStart(3, " ")}%`;
+      return [
+        isActive ? "{bold}> {/bold}" : "  ",
+        `{bold}${nameCol}{/bold}`,
+        `  {cyan-fg}${countCol} mem{/cyan-fg}`,
+        `  {${healthColor}-fg}${healthCol} health{/${healthColor}-fg}`
+      ].join("");
+    });
+    list.setItems(body);
+  }
+  function emitSelection() {
+    if (suppressSelect) return;
+    const selectedIndex = list.selected;
+    const row = rows[selectedIndex];
+    if (!row || !selectCallback) return;
+    selectCallback(row.project);
+  }
+  list.on("select", () => emitSelection());
+  return {
+    widget: list,
+    setData(memories, activeProject) {
+      rows = buildRows(memories);
+      render(activeProject);
+      if (rows.length > 0) {
+        suppressSelect = true;
+        const idx = rows.findIndex(
+          (r) => r.project === activeProject || r.project === void 0 && !activeProject
+        );
+        list.select(Math.max(0, idx));
+        setImmediate(() => {
+          suppressSelect = false;
+        });
+      }
+    },
+    onSelect(callback) {
+      selectCallback = callback;
+    }
+  };
+}
+
+// src/commands/memory/dashboard/widgets/project-picker-modal.ts
+import blessed7 from "blessed";
+function createProjectPickerModal(screen) {
+  const box = blessed7.box({
+    parent: screen,
+    top: "center",
+    left: "center",
+    width: 52,
+    height: 14,
+    border: { type: "line" },
+    label: " Project Picker ",
+    tags: true,
+    hidden: true,
+    style: {
+      border: { fg: "yellow" },
+      bg: "black"
+    }
+  });
+  const hint = blessed7.box({
+    parent: box,
+    top: 0,
+    left: 1,
+    right: 1,
+    height: 1,
+    tags: true,
+    content: "{gray-fg}Enter=select  Esc=close{/gray-fg}"
+  });
+  const list = blessed7.list({
+    parent: box,
+    top: 1,
+    left: 1,
+    right: 1,
+    bottom: 1,
+    keys: true,
+    vi: true,
+    mouse: true,
+    tags: true,
+    style: {
+      item: { fg: "white" },
+      selected: { fg: "black", bg: "yellow" }
+    },
+    scrollbar: {
+      style: { bg: "yellow" }
+    }
+  });
+  let isOpenState = false;
+  let options = [];
+  let submitCallback = null;
+  let previousFocus = null;
+  function restoreFocus() {
+    if (previousFocus) {
+      previousFocus.focus();
+      previousFocus = null;
+    }
+  }
+  function emitSelection() {
+    const selectedIndex = list.selected;
+    const selected = options[selectedIndex];
+    if (!selected || !submitCallback) return;
+    submitCallback(selected.project);
+    box.hide();
+    isOpenState = false;
+    restoreFocus();
+    screen.render();
+  }
+  list.key(["escape"], () => {
+    box.hide();
+    isOpenState = false;
+    restoreFocus();
+    screen.render();
+  });
+  list.on("select", () => emitSelection());
+  return {
+    open(projects, activeProject) {
+      options = [
+        { label: "All projects", project: void 0 },
+        ...projects.map((project) => ({ label: project, project }))
+      ];
+      const items = options.map((option) => {
+        const active = option.project === activeProject || option.project === void 0 && !activeProject;
+        return `${active ? "> " : "  "}${option.label}`;
+      });
+      list.setItems(items);
+      const activeIndex = options.findIndex(
+        (o) => o.project === activeProject || o.project === void 0 && !activeProject
+      );
+      list.select(Math.max(0, activeIndex));
+      previousFocus = screen.focused;
+      box.show();
+      isOpenState = true;
+      list.focus();
+      hint.setFront();
+      screen.render();
+    },
+    close() {
+      box.hide();
+      isOpenState = false;
+      restoreFocus();
+      screen.render();
+    },
+    isOpen() {
+      return isOpenState;
+    },
+    onSubmit(callback) {
+      submitCallback = callback;
+    }
+  };
+}
+
+// src/commands/memory/dashboard/keybindings.ts
+var TYPE_KEYS = {
+  "1": "working",
+  "2": "episodic",
+  "3": "semantic",
+  "4": "procedural",
+  "5": "pattern"
+};
+function registerKeybindings(screen, actions) {
+  screen.key(["q"], () => actions.quit());
+  screen.key(["C-c"], () => actions.quit());
+  screen.key(["r"], () => actions.refresh());
+  screen.key(["/"], () => actions.openSearch());
+  screen.key(["escape"], () => actions.closeSearch());
+  screen.key(["tab"], () => actions.focusNext());
+  screen.key(["p"], () => actions.openProjectPicker());
+  screen.key(["]", "right"], () => actions.cycleProjectNext());
+  screen.key(["[", "left"], () => actions.cycleProjectPrev());
+  screen.key(["s"], () => actions.cycleSort());
+  screen.key(["l"], () => actions.cycleLifespan());
+  screen.key(["?"], () => actions.showHelp());
+  screen.key(["0"], () => actions.filterByType(null));
+  for (const [key, type] of Object.entries(TYPE_KEYS)) {
+    screen.key([key], () => actions.filterByType(type));
+  }
+}
+
+// src/commands/memory/dashboard/layout.ts
+var SORT_MODES = [
+  "importance",
+  "age",
+  "access",
+  "lifespan"
+];
+var LIFESPAN_FILTERS = [
+  void 0,
+  "healthy",
+  "fading",
+  "stale",
+  "session"
+];
+function createDashboard(screen, dataSource, options) {
+  let currentTypeFilter;
+  let currentProject;
+  let currentProjectIndex = -1;
+  let currentLifespanFilter;
+  let currentSearchQuery = "";
+  let sortMode = "importance";
+  let currentMemories = [];
+  const header = createHeader(screen);
+  const memoryList = createMemoryList(screen);
+  const projectList = createProjectList(screen);
+  const memoryDetail = createMemoryDetail(screen);
+  const statsBar = createStatsBar(screen);
+  const searchModal = createSearchModal(screen);
+  const projectPickerModal = createProjectPickerModal(screen);
+  header.widget.top = 0;
+  header.widget.left = 0;
+  header.widget.width = "100%";
+  header.widget.height = 1;
+  memoryList.widget.top = 1;
+  memoryList.widget.left = 0;
+  memoryList.widget.width = "60%";
+  memoryList.widget.height = screen.rows - 4;
+  projectList.widget.top = 1;
+  projectList.widget.left = "60%";
+  projectList.widget.width = "40%";
+  projectList.widget.height = Math.max(
+    8,
+    Math.floor((screen.rows - 4) * 0.35)
+  );
+  memoryDetail.widget.top = projectList.widget.height + 1;
+  memoryDetail.widget.left = "60%";
+  memoryDetail.widget.width = "40%";
+  memoryDetail.widget.height = screen.rows - 4 - projectList.widget.height;
+  statsBar.widget.bottom = 0;
+  statsBar.widget.left = 0;
+  statsBar.widget.width = "100%";
+  statsBar.widget.height = 3;
+  memoryList.onSelect((memory) => {
+    const relations = dataSource.getRelationsForMemory(memory.id);
+    memoryDetail.showMemory(memory, relations);
+    screen.render();
+  });
+  projectList.onSelect((project) => {
+    if (project === currentProject) return;
+    currentProject = project;
+    currentProjectIndex = dataSource.getProjects().findIndex((p) => p === project);
+    refresh();
+  });
+  projectPickerModal.onSubmit((project) => {
+    if (project === currentProject) return;
+    currentProject = project;
+    currentProjectIndex = dataSource.getProjects().findIndex((p) => p === project);
+    refresh();
+  });
+  searchModal.onSubmit((query) => {
+    currentSearchQuery = query.trim();
+    refresh();
+  });
+  searchModal.onCancel(() => {
+    screen.render();
+  });
+  screen.on("resize", () => {
+    const listHeight = screen.rows - 4;
+    memoryList.widget.height = listHeight;
+    projectList.widget.height = Math.max(
+      8,
+      Math.floor(listHeight * 0.35)
+    );
+    memoryDetail.widget.top = projectList.widget.height + 1;
+    memoryDetail.widget.height = listHeight - projectList.widget.height;
+    screen.render();
+  });
+  function sortMemories(memories) {
+    const sorted = [...memories];
+    switch (sortMode) {
+      case "importance":
+        sorted.sort((a, b) => b.importance - a.importance);
+        break;
+      case "age":
+        sorted.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        break;
+      case "access":
+        sorted.sort((a, b) => b.accessCount - a.accessCount);
+        break;
+      case "lifespan":
+        sorted.sort(
+          (a, b) => computeLifespan(a).remaining - computeLifespan(b).remaining
+        );
+        break;
+    }
+    return sorted;
+  }
+  function getCurrentProject() {
+    return currentProject;
+  }
+  function applyTextFilter(memories, query) {
+    if (!query || query.trim().length === 0) return memories;
+    const lower = query.toLowerCase();
+    return memories.filter(
+      (m) => (m.title?.toLowerCase().includes(lower) ?? false) || m.content.toLowerCase().includes(lower) || m.tags.some((t) => t.toLowerCase().includes(lower))
+    );
+  }
+  function applyLifespanFilter(memories) {
+    if (!currentLifespanFilter) return memories;
+    return memories.filter(
+      (m) => computeLifespan(m).status === currentLifespanFilter
+    );
+  }
+  function refresh() {
+    const previousFocus = screen.focused;
+    dataSource.refresh();
+    const raw = dataSource.getMemories({
+      type: currentTypeFilter,
+      project: getCurrentProject()
+    });
+    const withLife = applyLifespanFilter(raw);
+    const withSearch = applyTextFilter(withLife, currentSearchQuery);
+    currentMemories = sortMemories(withSearch);
+    memoryList.setData(currentMemories);
+    projectList.setData(dataSource.getMemories(), currentProject);
+    if (currentMemories.length === 0) {
+      memoryDetail.clear();
+    }
+    const focusableWidgets = [memoryList.widget, projectList.widget, memoryDetail.widget];
+    if (previousFocus && focusableWidgets.includes(previousFocus)) {
+      previousFocus.focus();
+    } else {
+      memoryList.focus();
+    }
+    statsBar.setStats(dataSource.getStats(), currentMemories);
+    const project = getCurrentProject();
+    const label = [
+      project ? `project:${project}` : "all projects",
+      currentTypeFilter ? `type:${currentTypeFilter}` : "all types",
+      currentLifespanFilter ? `life:${currentLifespanFilter}` : "all life",
+      currentSearchQuery ? `search:${currentSearchQuery}` : "search:off",
+      `sort:${sortMode}`
+    ].join(" | ");
+    header.setLabel(`agentic-memory cockpit  [${label}]`);
+    screen.render();
+  }
+  function showHelp() {
+    const helpBox = blessed8.box({
+      parent: screen,
+      top: "center",
+      left: "center",
+      width: 50,
+      height: 18,
+      border: { type: "line" },
+      style: { border: { fg: "yellow" }, bg: "black" },
+      tags: true,
+      content: [
+        "{bold}{yellow-fg}Keybindings{/yellow-fg}{/bold}",
+        "",
+        "  j / k       Navigate list",
+        "  Enter       Select memory",
+        "  /           Search",
+        "  Esc         Close search / Clear search",
+        "  r           Refresh",
+        "  1-5         Filter by type (0 = all)",
+        "  l           Cycle lifespan filter",
+        "  p           Open project picker",
+        "  [ / ]       Previous / next project",
+        "  s           Cycle sort mode (incl lifespan)",
+        "  Tab         Focus next pane (list/projects/detail)",
+        "  ?           Show this help",
+        "  q           Quit",
+        "",
+        "{center}Press any key to close{/center}"
+      ].join("\n")
+    });
+    screen.render();
+    helpBox.once("keypress", () => {
+      helpBox.destroy();
+      screen.render();
+    });
+    helpBox.focus();
+  }
+  registerKeybindings(screen, {
+    refresh,
+    openSearch: () => searchModal.open(),
+    closeSearch: () => {
+      if (projectPickerModal.isOpen()) {
+        projectPickerModal.close();
+        return;
+      }
+      if (searchModal.isOpen()) {
+        searchModal.close();
+        return;
+      }
+      if (currentSearchQuery.length > 0) {
+        currentSearchQuery = "";
+        refresh();
+      }
+    },
+    openProjectPicker: () => {
+      projectPickerModal.open(
+        dataSource.getProjects(),
+        currentProject
+      );
+    },
+    filterByType: (type) => {
+      currentTypeFilter = type === null ? void 0 : type;
+      refresh();
+    },
+    cycleLifespan: () => {
+      const idx = LIFESPAN_FILTERS.findIndex(
+        (x) => x === currentLifespanFilter
+      );
+      currentLifespanFilter = LIFESPAN_FILTERS[(idx + 1) % LIFESPAN_FILTERS.length];
+      refresh();
+    },
+    cycleProjectNext: () => {
+      const projects = dataSource.getProjects();
+      if (projects.length === 0) return;
+      currentProjectIndex = currentProjectIndex >= projects.length - 1 ? -1 : currentProjectIndex + 1;
+      currentProject = currentProjectIndex < 0 ? void 0 : projects[currentProjectIndex];
+      refresh();
+      memoryList.focus();
+    },
+    cycleProjectPrev: () => {
+      const projects = dataSource.getProjects();
+      if (projects.length === 0) return;
+      currentProjectIndex = currentProjectIndex <= -1 ? projects.length - 1 : currentProjectIndex - 1;
+      currentProject = currentProjectIndex < 0 ? void 0 : projects[currentProjectIndex];
+      refresh();
+      memoryList.focus();
+    },
+    cycleSort: () => {
+      const idx = SORT_MODES.indexOf(sortMode);
+      sortMode = SORT_MODES[(idx + 1) % SORT_MODES.length];
+      refresh();
+    },
+    quit: () => options.onQuit(),
+    focusNext: () => {
+      if (screen.focused === memoryList.widget) {
+        projectList.widget.focus();
+      } else if (screen.focused === projectList.widget) {
+        memoryDetail.widget.focus();
+      } else {
+        memoryList.widget.focus();
+      }
+      screen.render();
+    },
+    showHelp
+  });
+  function destroy() {
+    header.widget.destroy();
+    memoryList.widget.destroy();
+    projectList.widget.destroy();
+    memoryDetail.widget.destroy();
+    statsBar.widget.destroy();
+    projectPickerModal.close();
+    screen.render();
+  }
+  return { refresh, destroy };
+}
+
+// src/commands/memory/dashboard/tui.ts
+async function startTui(options) {
+  if (process.env["TERM"]?.includes("256color")) {
+    process.env["TERM"] = "xterm";
+  }
+  const config = loadConfig(
+    options?.dbPath ? { dataDir: options.dbPath } : void 0
+  );
+  const dataDir = resolveDataDir(config.dataDir);
+  const db = createDatabase({ dataDir });
+  migrate(db);
+  const memoryRepo = new MemoryRepo(db);
+  const relationRepo = new RelationRepo(db);
+  const searchRepo = new SearchRepo(db);
+  const screen = blessed9.screen({
+    smartCSR: true,
+    title: "agentic-memory"
+  });
+  const dataSource = new DashboardDataSource(
+    memoryRepo,
+    relationRepo,
+    searchRepo,
+    dataDir
+  );
+  let shuttingDown = false;
+  function shutdown() {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    dataSource.stopWatching();
+    screen.destroy();
+    closeDatabase(db);
+  }
+  const dashboard = createDashboard(screen, dataSource, { onQuit: shutdown });
+  dashboard.refresh();
+  dataSource.startWatching(() => {
+    dashboard.refresh();
+  });
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("uncaughtException", (err) => {
+    dataSource.stopWatching();
+    screen.destroy();
+    closeDatabase(db);
+    process.stderr.write(
+      `[agentic-memory] dashboard crashed: ${err.message}
+`
+    );
+    process.exit(1);
+  });
+}
+export {
+  startTui
+};
+//# sourceMappingURL=tui-R25NTQ4K.js.map