claude-launchpad 0.10.1-dev.7 → 0.11.1

package/dist/tui-ERRK7V4J.js

@@ -0,0 +1,1008 @@
+#!/usr/bin/env node
+import {
+  MemoryRepo,
+  RelationRepo,
+  SearchRepo
+} from "./chunk-JXFTVFPC.js";
+import {
+  DEFAULT_DECAY_PARAMS,
+  closeDatabase,
+  createDatabase,
+  loadConfig,
+  migrate,
+  resolveDataDir
+} from "./chunk-JTKRLIEV.js";
+import "./chunk-Z6FBT44W.js";
+import "./chunk-RJGXPH7P.js";
+
+// src/commands/memory/dashboard/tui.tsx
+import { render } from "ink";
+
+// 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/app.tsx
+import { Box as Box10, useApp } from "ink";
+
+// src/commands/memory/dashboard/hooks/use-dashboard-state.ts
+import { useState, useMemo, useEffect, useCallback } from "react";
+
+// src/commands/memory/dashboard/data/formatters.ts
+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/hooks/use-dashboard-state.ts
+var SORT_MODES = ["importance", "age", "access", "lifespan"];
+var LIFESPAN_FILTERS = [
+  void 0,
+  "healthy",
+  "fading",
+  "stale",
+  "session"
+];
+function useDashboardState(dataSource) {
+  const [revision, setRevision] = useState(0);
+  const [typeFilter, setTypeFilter] = useState();
+  const [lifespanFilter, setLifespanFilter] = useState();
+  const [searchQuery, setSearchQuery] = useState("");
+  const [searchActive, setSearchActive] = useState(false);
+  const [currentProject, setCurrentProject] = useState();
+  const [sortMode, setSortMode] = useState("importance");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [focusedPane, setFocusedPane] = useState("list");
+  const [showHelp, setShowHelp] = useState(false);
+  const [showProjectPicker, setShowProjectPicker] = useState(false);
+  useEffect(() => {
+    dataSource.refresh();
+    setRevision((r) => r + 1);
+    dataSource.startWatching(() => {
+      dataSource.refresh();
+      setRevision((r) => r + 1);
+    });
+    return () => dataSource.stopWatching();
+  }, [dataSource]);
+  const projects = useMemo(() => {
+    void revision;
+    return dataSource.getProjects();
+  }, [dataSource, revision]);
+  const filteredMemories = useMemo(() => {
+    void revision;
+    const raw = dataSource.getMemories({ type: typeFilter, project: currentProject });
+    const withLife = lifespanFilter ? raw.filter((m) => computeLifespan(m).status === lifespanFilter) : raw;
+    const withSearch = searchQuery ? withLife.filter(
+      (m) => (m.title?.toLowerCase().includes(searchQuery.toLowerCase()) ?? false) || m.content.toLowerCase().includes(searchQuery.toLowerCase()) || m.tags.some((t) => t.toLowerCase().includes(searchQuery.toLowerCase()))
+    ) : withLife;
+    return sortMemories(withSearch, sortMode);
+  }, [dataSource, revision, typeFilter, lifespanFilter, searchQuery, currentProject, sortMode]);
+  const selectedMemory = filteredMemories[selectedIndex];
+  const relations = useMemo(
+    () => selectedMemory ? dataSource.getRelationsForMemory(selectedMemory.id) : [],
+    [dataSource, selectedMemory, revision]
+  );
+  const stats = useMemo(() => {
+    void revision;
+    return dataSource.getStats();
+  }, [dataSource, revision]);
+  const navigateUp = useCallback(() => {
+    setSelectedIndex((i) => Math.max(0, i - 1));
+  }, []);
+  const navigateDown = useCallback(() => {
+    setSelectedIndex((i) => Math.min(filteredMemories.length - 1, i + 1));
+  }, [filteredMemories.length]);
+  const cycleSort = useCallback(() => {
+    setSortMode((m) => SORT_MODES[(SORT_MODES.indexOf(m) + 1) % SORT_MODES.length]);
+  }, []);
+  const cycleLifespan = useCallback(() => {
+    setLifespanFilter((f) => {
+      const idx = LIFESPAN_FILTERS.findIndex((x) => x === f);
+      return LIFESPAN_FILTERS[(idx + 1) % LIFESPAN_FILTERS.length];
+    });
+  }, []);
+  const cycleProjectNext = useCallback(() => {
+    setCurrentProject((curr) => {
+      const idx = curr ? projects.indexOf(curr) : -1;
+      return idx >= projects.length - 1 ? void 0 : projects[idx + 1];
+    });
+    setSelectedIndex(0);
+  }, [projects]);
+  const cycleProjectPrev = useCallback(() => {
+    setCurrentProject((curr) => {
+      const idx = curr ? projects.indexOf(curr) : -1;
+      return idx <= 0 ? idx === 0 ? void 0 : projects[projects.length - 1] : projects[idx - 1];
+    });
+    setSelectedIndex(0);
+  }, [projects]);
+  const focusNext = useCallback(() => {
+    setFocusedPane((p) => p === "list" ? "projects" : p === "projects" ? "detail" : "list");
+  }, []);
+  const filterByType = useCallback((type) => {
+    setTypeFilter(type);
+    setSelectedIndex(0);
+  }, []);
+  const openSearch = useCallback(() => setSearchActive(true), []);
+  const closeSearch = useCallback(() => {
+    setSearchActive(false);
+    setSearchQuery("");
+    setSelectedIndex(0);
+  }, []);
+  const refresh = useCallback(() => {
+    dataSource.refresh();
+    setRevision((r) => r + 1);
+  }, [dataSource]);
+  return {
+    typeFilter,
+    lifespanFilter,
+    searchQuery,
+    searchActive,
+    currentProject,
+    sortMode,
+    selectedIndex,
+    focusedPane,
+    showHelp,
+    showProjectPicker,
+    filteredMemories,
+    selectedMemory,
+    relations,
+    projects,
+    stats,
+    setSearchQuery,
+    setCurrentProject,
+    setSelectedIndex,
+    setShowHelp,
+    setShowProjectPicker,
+    navigateUp,
+    navigateDown,
+    cycleSort,
+    cycleLifespan,
+    cycleProjectNext,
+    cycleProjectPrev,
+    focusNext,
+    filterByType,
+    openSearch,
+    closeSearch,
+    refresh
+  };
+}
+function sortMemories(memories, mode) {
+  const sorted = [...memories];
+  const sorters = {
+    importance: (a, b) => b.importance - a.importance,
+    age: (a, b) => b.createdAt.localeCompare(a.createdAt),
+    access: (a, b) => b.accessCount - a.accessCount,
+    lifespan: (a, b) => computeLifespan(a).remaining - computeLifespan(b).remaining
+  };
+  sorted.sort(sorters[mode]);
+  return sorted;
+}
+
+// src/commands/memory/dashboard/hooks/use-keybindings.ts
+import { useInput } from "ink";
+var TYPE_KEYS = {
+  "1": "working",
+  "2": "episodic",
+  "3": "semantic",
+  "4": "procedural",
+  "5": "pattern"
+};
+function useKeybindings(actions, opts) {
+  useInput((input, key) => {
+    if (opts.searchActive) {
+      if (key.escape) actions.closeSearch();
+      return;
+    }
+    if (opts.pickerOpen) {
+      if (key.escape) actions.openProjectPicker();
+      return;
+    }
+    if (input === "j" || key.downArrow) actions.navigateDown();
+    if (input === "k" || key.upArrow) actions.navigateUp();
+    if (input === "/") actions.openSearch();
+    if (key.escape) actions.closeSearch();
+    if (input === "0") actions.filterByType(void 0);
+    if (input in TYPE_KEYS) actions.filterByType(TYPE_KEYS[input]);
+    if (input === "l") actions.cycleLifespan();
+    if (input === "s") actions.cycleSort();
+    if (input === "p") actions.openProjectPicker();
+    if (input === "]" || key.rightArrow) actions.cycleProjectNext();
+    if (input === "[" || key.leftArrow) actions.cycleProjectPrev();
+    if (key.tab) actions.focusNext();
+    if (input === "?") actions.showHelp();
+    if (input === "r") actions.refresh();
+    if (input === "q") actions.quit();
+  }, { isActive: !opts.searchActive });
+}
+
+// src/commands/memory/dashboard/hooks/use-terminal-size.ts
+import { useStdout } from "ink";
+import { useState as useState2, useEffect as useEffect2 } from "react";
+function useTerminalSize() {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState2({
+    columns: stdout.columns ?? 80,
+    rows: stdout.rows ?? 24
+  });
+  useEffect2(() => {
+    const handler = () => setSize({ columns: stdout.columns, rows: stdout.rows });
+    stdout.on("resize", handler);
+    return () => {
+      stdout.off("resize", handler);
+    };
+  }, [stdout]);
+  const layout = size.columns >= 120 ? "wide" : size.columns >= 80 ? "medium" : "narrow";
+  return { ...size, layout };
+}
+
+// src/commands/memory/dashboard/components/keybinding-bar.tsx
+import React from "react";
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var HINTS = [
+  ["j/k", "navigate"],
+  ["/", "search"],
+  ["p", "projects"],
+  ["1-5", "type"],
+  ["l", "life"],
+  ["s", "sort"],
+  ["Tab", "focus"],
+  ["?", "help"],
+  ["q", "quit"]
+];
+function KeybindingBar() {
+  return /* @__PURE__ */ jsx(Box, { children: HINTS.map(([key, label], i) => /* @__PURE__ */ jsxs(React.Fragment, { children: [
+    i > 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  " }),
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: key }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      " ",
+      label
+    ] })
+  ] }, key)) });
+}
+
+// src/commands/memory/dashboard/components/header.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function Header({ project, typeFilter, lifespanFilter, sortMode, searchQuery }) {
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: "green", children: " agentic-memory " }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " | " }),
+    /* @__PURE__ */ jsx2(Text2, { color: "white", children: project ?? "all projects" }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " | " }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: typeFilter ?? "all types" }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " | " }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: lifespanFilter ?? "all life" }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " | " }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "sort:",
+      sortMode
+    ] }),
+    searchQuery && /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " | " }),
+      /* @__PURE__ */ jsxs2(Text2, { color: "yellow", children: [
+        "search:",
+        searchQuery
+      ] })
+    ] })
+  ] });
+}
+
+// src/commands/memory/dashboard/components/search-bar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import TextInput from "ink-text-input";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function SearchBar({ query, onChange, onClose }) {
+  return /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "Search: " }),
+    /* @__PURE__ */ jsx3(TextInput, { value: query, onChange, onSubmit: onClose }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  (Esc to clear, Enter to keep)" })
+  ] });
+}
+
+// src/commands/memory/dashboard/components/memory-list.tsx
+import { useMemo as useMemo2 } from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+
+// 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/components/memory-list.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var LIFE_COLORS = {
+  healthy: "green",
+  fading: "yellow",
+  stale: "red",
+  session: "magenta"
+};
+function MemoryList({ memories, selectedIndex, isFocused, height }) {
+  const viewportHeight = Math.max(1, height - 2);
+  const scrollOffset = useMemo2(() => {
+    if (selectedIndex < 0) return 0;
+    if (memories.length <= viewportHeight) return 0;
+    const half = Math.floor(viewportHeight / 2);
+    const offset = Math.max(0, selectedIndex - half);
+    return Math.min(offset, memories.length - viewportHeight);
+  }, [selectedIndex, memories.length, viewportHeight]);
+  const visible = memories.slice(scrollOffset, scrollOffset + viewportHeight);
+  const label = ` Memories [${memories.length}] `;
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: isFocused ? "cyan" : "gray",
+      children: [
+        /* @__PURE__ */ jsx4(Text4, { bold: true, color: isFocused ? "cyan" : "gray", children: label }),
+        visible.length === 0 && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  No memories found" }),
+        visible.map((m, i) => {
+          const isSelected = scrollOffset + i === selectedIndex;
+          return /* @__PURE__ */ jsx4(MemoryRow, { memory: m, isSelected }, m.id);
+        })
+      ]
+    }
+  );
+}
+function MemoryRow({ memory, isSelected }) {
+  const life = computeLifespan(memory);
+  const title = truncate(memory.title ?? memory.content.replace(/\n/g, " "), 36);
+  const project = truncate(memory.project ?? "", 14);
+  const type = TYPE_ABBREV[memory.type] ?? memory.type;
+  const lifeColor = LIFE_COLORS[life.status] ?? "white";
+  const lifeLabel = formatLifespanLabel(life.status).trim();
+  const imp = `${Math.round(memory.importance * 100)}%`;
+  const updated = formatRelativeTime(memory.updatedAt);
+  return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { inverse: isSelected, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: isSelected ? "\u25B8 " : "  " }),
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: title.padEnd(38) }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: project.padEnd(16) }),
+    /* @__PURE__ */ jsxs4(Text4, { color: "cyan", children: [
+      type,
+      "  "
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { color: lifeColor, children: lifeLabel.padEnd(8) }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      imp.padStart(4),
+      "  "
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: updated.padEnd(8) }),
+    /* @__PURE__ */ jsxs4(Text4, { color: "blue", children: [
+      "acc:",
+      memory.accessCount
+    ] })
+  ] }) });
+}
+
+// src/commands/memory/dashboard/components/memory-detail.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function MemoryDetail({ memory, relations, isFocused }) {
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: isFocused ? "blue" : "gray",
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ jsx5(Text5, { bold: true, color: isFocused ? "blue" : "gray", children: " Detail " }),
+        !memory ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Select a memory to view details" }) : /* @__PURE__ */ jsx5(DetailContent, { memory, relations })
+      ]
+    }
+  );
+}
+function DetailContent({ memory, relations }) {
+  const life = computeLifespan(memory);
+  const typeColor = TYPE_COLORS[memory.type] ?? "white";
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: memory.title ?? "(untitled)" }),
+    /* @__PURE__ */ jsx5(Text5, { children: " " }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Type:       ",
+      /* @__PURE__ */ jsx5(Text5, { color: typeColor, children: memory.type })
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Lifespan:   ",
+      formatLifespanLabel(life.status),
+      " | age ",
+      Math.round(life.ageDays),
+      "d | tau ",
+      life.tauDays,
+      "d"
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Health:     ",
+      formatImportanceBar(life.remaining),
+      " ",
+      (life.remaining * 100).toFixed(0),
+      "%"
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Importance: ",
+      formatImportanceBar(memory.importance),
+      " ",
+      memory.importance.toFixed(2)
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Project:    ",
+      memory.project ?? "(none)"
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Tags:       ",
+      memory.tags.length > 0 ? memory.tags.map((t) => `[${t}]`).join(" ") : "(none)"
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Source:     ",
+      memory.source ?? "unknown"
+    ] }),
+    /* @__PURE__ */ jsx5(Text5, { children: " " }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Created:    ",
+      formatRelativeTime(memory.createdAt)
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Updated:    ",
+      formatRelativeTime(memory.updatedAt)
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Accessed:   ",
+      memory.accessCount,
+      "x",
+      memory.lastAccessed ? ` (last: ${formatRelativeTime(memory.lastAccessed)})` : ""
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Injected:   ",
+      memory.injectionCount,
+      "x"
+    ] }),
+    /* @__PURE__ */ jsx5(Text5, { children: " " }),
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Content" }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2500".repeat(40) }),
+    /* @__PURE__ */ jsx5(Text5, { children: memory.content }),
+    relations.length > 0 && /* @__PURE__ */ jsx5(RelationsList, { relations, memoryId: memory.id })
+  ] });
+}
+function RelationsList({ relations, memoryId }) {
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Relations" }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2500".repeat(40) }),
+    relations.map((r, i) => {
+      const relColor = RELATION_COLORS[r.relationType] ?? "white";
+      const direction = r.sourceId === memoryId ? "\u2192" : "\u2190";
+      const otherId = r.sourceId === memoryId ? r.targetId : r.sourceId;
+      return /* @__PURE__ */ jsxs5(Text5, { children: [
+        "  ",
+        direction,
+        " ",
+        /* @__PURE__ */ jsx5(Text5, { color: relColor, children: r.relationType }),
+        " ",
+        otherId
+      ] }, i);
+    })
+  ] });
+}
+
+// src/commands/memory/dashboard/components/project-list.tsx
+import { useMemo as useMemo3 } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function ProjectList({ memories, activeProject, isFocused }) {
+  const rows = useMemo3(() => buildProjectRows(memories), [memories]);
+  return /* @__PURE__ */ jsxs6(
+    Box6,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: isFocused ? "magenta" : "gray",
+      children: [
+        /* @__PURE__ */ jsx6(Text6, { bold: true, color: isFocused ? "magenta" : "gray", children: " Projects " }),
+        rows.map((row) => {
+          const isActive = row.project === activeProject || row.project === void 0 && !activeProject;
+          const name = (row.project ?? "All projects").padEnd(20).slice(0, 20);
+          const healthColor = row.healthPct > 62 ? "green" : row.healthPct > 32 ? "yellow" : "red";
+          return /* @__PURE__ */ jsxs6(Box6, { children: [
+            /* @__PURE__ */ jsx6(Text6, { bold: isActive, children: isActive ? "> " : "  " }),
+            /* @__PURE__ */ jsx6(Text6, { bold: isActive, children: name }),
+            /* @__PURE__ */ jsxs6(Text6, { color: "cyan", children: [
+              String(row.total).padStart(4),
+              " mem"
+            ] }),
+            /* @__PURE__ */ jsx6(Text6, { children: "  " }),
+            /* @__PURE__ */ jsxs6(Text6, { color: healthColor, children: [
+              String(row.healthPct).padStart(3),
+              "%"
+            ] })
+          ] }, row.project ?? "_all");
+        })
+      ]
+    }
+  );
+}
+function buildProjectRows(memories) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const m of memories) {
+    const key = m.project ?? "(none)";
+    const list = byProject.get(key) ?? [];
+    list.push(m);
+    byProject.set(key, list);
+  }
+  const rows = [];
+  for (const [project, mems] of byProject) {
+    const avg = mems.reduce((s, m) => s + computeLifespan(m).remaining, 0) / mems.length;
+    rows.push({ project, total: mems.length, healthPct: Math.round(avg * 100) });
+  }
+  rows.sort((a, b) => b.total - a.total);
+  const allHealth = memories.length > 0 ? Math.round(memories.reduce((s, m) => s + computeLifespan(m).remaining, 0) / memories.length * 100) : 0;
+  return [{ project: void 0, total: memories.length, healthPct: allHealth }, ...rows];
+}
+
+// src/commands/memory/dashboard/components/stats-bar.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function StatsBar({ stats, visible }) {
+  const lifeCounts = { healthy: 0, fading: 0, stale: 0, session: 0 };
+  for (const m of visible) {
+    lifeCounts[computeLifespan(m).status]++;
+  }
+  const typeEntries = Object.entries(stats.byType).filter(([, c]) => c > 0);
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs7(Box7, { gap: 2, children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Total:" }),
+        " ",
+        stats.total
+      ] }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Relations:" }),
+        " ",
+        stats.relations
+      ] }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Visible:" }),
+        " ",
+        visible.length
+      ] }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsx7(Text7, { bold: true, children: "DB:" }),
+        " ",
+        formatBytes(stats.dbSizeBytes)
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { gap: 2, children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
+          "H:",
+          lifeCounts.healthy
+        ] }),
+        " ",
+        /* @__PURE__ */ jsxs7(Text7, { color: "yellow", children: [
+          "F:",
+          lifeCounts.fading
+        ] }),
+        " ",
+        /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+          "S:",
+          lifeCounts.stale
+        ] }),
+        " ",
+        /* @__PURE__ */ jsxs7(Text7, { color: "magenta", children: [
+          "Sess:",
+          lifeCounts.session
+        ] })
+      ] }),
+      typeEntries.map(([type, count]) => /* @__PURE__ */ jsxs7(Text7, { color: TYPE_COLORS[type] ?? "white", children: [
+        type,
+        ":",
+        count
+      ] }, type))
+    ] })
+  ] });
+}
+
+// src/commands/memory/dashboard/components/help-overlay.tsx
+import { Box as Box8, Text as Text8, useInput as useInput2 } from "ink";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var BINDINGS = [
+  ["j / k / \u2191\u2193", "Navigate list"],
+  ["Enter", "Select memory"],
+  ["/", "Search (live filter)"],
+  ["Esc", "Clear search"],
+  ["1-5", "Filter by type (0 = all)"],
+  ["l", "Cycle lifespan filter"],
+  ["s", "Cycle sort mode"],
+  ["p", "Open project picker"],
+  ["[ / ]", "Previous / next project"],
+  ["Tab", "Focus next pane"],
+  ["r", "Refresh"],
+  ["?", "Show this help"],
+  ["q", "Quit"]
+];
+function HelpOverlay({ onClose }) {
+  useInput2(() => onClose());
+  return /* @__PURE__ */ jsxs8(
+    Box8,
+    {
+      flexDirection: "column",
+      borderStyle: "double",
+      borderColor: "yellow",
+      paddingX: 2,
+      paddingY: 1,
+      children: [
+        /* @__PURE__ */ jsx8(Text8, { bold: true, color: "yellow", children: "Keybindings" }),
+        /* @__PURE__ */ jsx8(Text8, { children: " " }),
+        BINDINGS.map(([key, desc]) => /* @__PURE__ */ jsxs8(Box8, { gap: 1, children: [
+          /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: key.padEnd(14) }),
+          /* @__PURE__ */ jsx8(Text8, { children: desc })
+        ] }, key)),
+        /* @__PURE__ */ jsx8(Text8, { children: " " }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Press any key to close" })
+      ]
+    }
+  );
+}
+
+// src/commands/memory/dashboard/components/project-picker.tsx
+import React4 from "react";
+import { Box as Box9, Text as Text9, useInput as useInput3 } from "ink";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function ProjectPicker({ projects, activeProject, onSelect, onClose }) {
+  const [selectedIdx, setSelectedIdx] = React4.useState(() => {
+    if (!activeProject) return 0;
+    const idx = projects.indexOf(activeProject);
+    return idx >= 0 ? idx + 1 : 0;
+  });
+  const options = [
+    { label: "All projects", project: void 0 },
+    ...projects.map((p) => ({ label: p, project: p }))
+  ];
+  useInput3((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (input === "j" || key.downArrow) setSelectedIdx((i) => Math.min(options.length - 1, i + 1));
+    if (input === "k" || key.upArrow) setSelectedIdx((i) => Math.max(0, i - 1));
+    if (key.return) {
+      onSelect(options[selectedIdx]?.project);
+      onClose();
+    }
+  });
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", borderStyle: "double", borderColor: "yellow", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx9(Text9, { bold: true, color: "yellow", children: "Project Picker" }),
+    /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "Enter=select  Esc=close" }),
+    /* @__PURE__ */ jsx9(Text9, { children: " " }),
+    options.map((opt, i) => {
+      const isSelected = i === selectedIdx;
+      const isActive = opt.project === activeProject || opt.project === void 0 && !activeProject;
+      return /* @__PURE__ */ jsxs9(Text9, { inverse: isSelected, children: [
+        isActive ? "> " : "  ",
+        opt.label
+      ] }, opt.label);
+    })
+  ] });
+}
+
+// src/commands/memory/dashboard/app.tsx
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+function App({ dataSource }) {
+  const { exit } = useApp();
+  const { rows, layout } = useTerminalSize();
+  const state = useDashboardState(dataSource);
+  useKeybindings({
+    navigateUp: state.navigateUp,
+    navigateDown: state.navigateDown,
+    openSearch: state.openSearch,
+    closeSearch: state.closeSearch,
+    filterByType: state.filterByType,
+    cycleLifespan: state.cycleLifespan,
+    cycleProjectNext: state.cycleProjectNext,
+    cycleProjectPrev: state.cycleProjectPrev,
+    cycleSort: state.cycleSort,
+    focusNext: state.focusNext,
+    openProjectPicker: () => state.setShowProjectPicker((v) => !v),
+    showHelp: () => state.setShowHelp((v) => !v),
+    refresh: state.refresh,
+    quit: exit
+  }, {
+    searchActive: state.searchActive,
+    pickerOpen: state.showProjectPicker
+  });
+  if (state.showHelp) {
+    return /* @__PURE__ */ jsx10(HelpOverlay, { onClose: () => state.setShowHelp(false) });
+  }
+  if (state.showProjectPicker) {
+    return /* @__PURE__ */ jsx10(
+      ProjectPicker,
+      {
+        projects: [...state.projects],
+        activeProject: state.currentProject,
+        onSelect: (p) => {
+          state.setCurrentProject(p);
+          state.setSelectedIndex(0);
+        },
+        onClose: () => state.setShowProjectPicker(false)
+      }
+    );
+  }
+  const contentHeight = Math.max(4, rows - 6);
+  const isNarrow = layout === "narrow";
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx10(KeybindingBar, {}),
+    /* @__PURE__ */ jsx10(
+      Header,
+      {
+        project: state.currentProject,
+        typeFilter: state.typeFilter,
+        lifespanFilter: state.lifespanFilter,
+        sortMode: state.sortMode,
+        searchQuery: state.searchQuery
+      }
+    ),
+    state.searchActive && /* @__PURE__ */ jsx10(
+      SearchBar,
+      {
+        query: state.searchQuery,
+        onChange: state.setSearchQuery,
+        onClose: () => state.setSearchQuery(state.searchQuery)
+      }
+    ),
+    /* @__PURE__ */ jsxs10(Box10, { flexDirection: isNarrow ? "column" : "row", children: [
+      /* @__PURE__ */ jsx10(Box10, { width: isNarrow ? "100%" : "60%", children: /* @__PURE__ */ jsx10(
+        MemoryList,
+        {
+          memories: state.filteredMemories,
+          selectedIndex: state.selectedIndex,
+          isFocused: state.focusedPane === "list",
+          height: contentHeight
+        }
+      ) }),
+      /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", width: isNarrow ? "100%" : "40%", children: [
+        !isNarrow && /* @__PURE__ */ jsx10(
+          ProjectList,
+          {
+            memories: state.filteredMemories,
+            activeProject: state.currentProject,
+            isFocused: state.focusedPane === "projects"
+          }
+        ),
+        /* @__PURE__ */ jsx10(
+          MemoryDetail,
+          {
+            memory: state.selectedMemory,
+            relations: state.relations,
+            isFocused: state.focusedPane === "detail"
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx10(StatsBar, { stats: state.stats, visible: state.filteredMemories })
+  ] });
+}
+
+// src/commands/memory/dashboard/tui.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+async function startTui(options) {
+  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 dataSource = new DashboardDataSource(
+    memoryRepo,
+    relationRepo,
+    searchRepo,
+    dataDir
+  );
+  let shuttingDown = false;
+  const { waitUntilExit, unmount } = render(
+    /* @__PURE__ */ jsx11(App, { dataSource })
+  );
+  function shutdown() {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    dataSource.stopWatching();
+    unmount();
+    closeDatabase(db);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await waitUntilExit();
+  } finally {
+    if (!shuttingDown) {
+      dataSource.stopWatching();
+      closeDatabase(db);
+    }
+  }
+}
+export {
+  startTui
+};
+//# sourceMappingURL=tui-ERRK7V4J.js.map