@whatasoda/agent-tools 0.1.0

package/dist/src/core/database.js

@@ -0,0 +1,209 @@
+import { Database as BunDatabase } from "bun:sqlite";
+import { ulid } from "ulid";
+import path from "path";
+import { readFileSync } from "fs";
+import { validateProperties } from "./kinds.js";
+import { SearchIndex } from "./search.js";
+function rowToNode(row) {
+  return {
+    body: row.body,
+    created_at: row.created_at,
+    id: row.id,
+    kind: row.kind,
+    properties: JSON.parse(row.properties),
+    updated_at: row.updated_at
+  };
+}
+
+export class Database {
+  db;
+  searchIndex;
+  constructor(dbPath = ":memory:") {
+    this.db = new BunDatabase(dbPath, { create: true, strict: true });
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.initSchema();
+    this.searchIndex = new SearchIndex(this.db);
+  }
+  initSchema() {
+    const schemaPath = path.join(import.meta.dir, "schema.sql");
+    const sql = readFileSync(schemaPath, "utf-8");
+    this.db.exec(sql);
+  }
+  getNodeWithRelations(id) {
+    const nodeRow = this.db.query("SELECT id, kind, body, properties, created_at, updated_at FROM nodes WHERE id = ?").get(id);
+    if (!nodeRow) {
+      return null;
+    }
+    const node = rowToNode(nodeRow);
+    const tagRows = this.db.query("SELECT tag FROM tags WHERE node_id = ?").all(id);
+    const tags = tagRows.map((r) => r.tag);
+    const linksFromRows = this.db.query("SELECT from_id, to_id, link_type, created_at FROM links WHERE from_id = ?").all(id);
+    const links_from = linksFromRows.map((r) => ({
+      created_at: r.created_at,
+      from_id: r.from_id,
+      link_type: r.link_type,
+      to_id: r.to_id
+    }));
+    const linksToRows = this.db.query("SELECT from_id, to_id, link_type, created_at FROM links WHERE to_id = ?").all(id);
+    const links_to = linksToRows.map((r) => ({
+      created_at: r.created_at,
+      from_id: r.from_id,
+      link_type: r.link_type,
+      to_id: r.to_id
+    }));
+    return { ...node, links_from, links_to, tags };
+  }
+  createNode(input) {
+    const { kind, body = "", properties = {}, tags = [] } = input;
+    const validatedProps = validateProperties(kind, properties);
+    const id = ulid();
+    const now = new Date().toISOString();
+    const insertTx = this.db.transaction(() => {
+      this.db.query("INSERT INTO nodes (id, kind, body, properties, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(id, kind, body, JSON.stringify(validatedProps), now, now);
+      for (const tag of tags) {
+        this.db.query("INSERT INTO tags (node_id, tag) VALUES (?, ?)").run(id, tag);
+      }
+    });
+    insertTx();
+    const result = this.getNodeWithRelations(id);
+    if (!result) {
+      throw new Error(`Failed to retrieve node after creation: ${id}`);
+    }
+    this.searchIndex.indexNode(result);
+    return result;
+  }
+  getNode(id) {
+    return this.getNodeWithRelations(id);
+  }
+  updateNode(input) {
+    const { id, body, kind, properties } = input;
+    const existing = this.getNodeWithRelations(id);
+    if (!existing) {
+      throw new Error(`Node not found: ${id}`);
+    }
+    this.searchIndex.removeNode(id, existing);
+    const newKind = kind === undefined ? existing.kind : kind;
+    const newProperties = properties === undefined ? existing.properties : properties;
+    let validatedProps = existing.properties;
+    if (kind !== undefined || properties !== undefined) {
+      validatedProps = validateProperties(newKind, newProperties);
+    }
+    const now = new Date().toISOString();
+    const setClauses = [];
+    const params = [];
+    if (body !== undefined) {
+      setClauses.push("body = ?");
+      params.push(body);
+    }
+    if (kind !== undefined) {
+      setClauses.push("kind = ?");
+      params.push(kind);
+    }
+    if (kind !== undefined || properties !== undefined) {
+      setClauses.push("properties = ?");
+      params.push(JSON.stringify(validatedProps));
+    }
+    setClauses.push("updated_at = ?");
+    params.push(now);
+    params.push(id);
+    const sql = `UPDATE nodes SET ${setClauses.join(", ")} WHERE id = ?`;
+    this.db.query(sql).run(...params);
+    const result = this.getNodeWithRelations(id);
+    if (!result) {
+      throw new Error(`Failed to retrieve node after update: ${id}`);
+    }
+    this.searchIndex.indexNode(result);
+    return result;
+  }
+  deleteNode(id) {
+    const existing = this.getNodeWithRelations(id);
+    if (!existing) {
+      throw new Error(`Node not found: ${id}`);
+    }
+    this.searchIndex.removeNode(id, existing);
+    this.db.query("DELETE FROM nodes WHERE id = ?").run(id);
+  }
+  addTags(nodeId, tags) {
+    const exists = this.db.query("SELECT id FROM nodes WHERE id = ?").get(nodeId);
+    if (!exists) {
+      throw new Error(`Node not found: ${nodeId}`);
+    }
+    const insertTx = this.db.transaction(() => {
+      for (const tag of tags) {
+        this.db.query("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)").run(nodeId, tag);
+      }
+    });
+    insertTx();
+  }
+  removeTags(nodeId, tags) {
+    const exists = this.db.query("SELECT id FROM nodes WHERE id = ?").get(nodeId);
+    if (!exists) {
+      throw new Error(`Node not found: ${nodeId}`);
+    }
+    const deleteTx = this.db.transaction(() => {
+      for (const tag of tags) {
+        this.db.query("DELETE FROM tags WHERE node_id = ? AND tag = ?").run(nodeId, tag);
+      }
+    });
+    deleteTx();
+  }
+  createLink(fromId, toId, linkType) {
+    const fromNode = this.db.query("SELECT id FROM nodes WHERE id = ?").get(fromId);
+    if (!fromNode) {
+      throw new Error(`Node not found: ${fromId}`);
+    }
+    const toNode = this.db.query("SELECT id FROM nodes WHERE id = ?").get(toId);
+    if (!toNode) {
+      throw new Error(`Node not found: ${toId}`);
+    }
+    const now = new Date().toISOString();
+    this.db.query("INSERT OR IGNORE INTO links (from_id, to_id, link_type, created_at) VALUES (?, ?, ?, ?)").run(fromId, toId, linkType, now);
+    const row = this.db.query("SELECT from_id, to_id, link_type, created_at FROM links WHERE from_id = ? AND to_id = ? AND link_type = ?").get(fromId, toId, linkType);
+    if (!row) {
+      throw new Error(`Failed to retrieve link after creation`);
+    }
+    return {
+      created_at: row.created_at,
+      from_id: row.from_id,
+      link_type: row.link_type,
+      to_id: row.to_id
+    };
+  }
+  deleteLink(fromId, toId, linkType) {
+    this.db.query("DELETE FROM links WHERE from_id = ? AND to_id = ? AND link_type = ?").run(fromId, toId, linkType);
+  }
+  getLinks(nodeId, direction) {
+    const rowToLink = (r) => ({
+      created_at: r.created_at,
+      from_id: r.from_id,
+      link_type: r.link_type,
+      to_id: r.to_id
+    });
+    if (direction === "from") {
+      const rows = this.db.query("SELECT from_id, to_id, link_type, created_at FROM links WHERE from_id = ?").all(nodeId);
+      return rows.map(rowToLink);
+    }
+    if (direction === "to") {
+      const rows = this.db.query("SELECT from_id, to_id, link_type, created_at FROM links WHERE to_id = ?").all(nodeId);
+      return rows.map(rowToLink);
+    }
+    const fromRows = this.db.query("SELECT from_id, to_id, link_type, created_at FROM links WHERE from_id = ?").all(nodeId);
+    const toRows = this.db.query("SELECT from_id, to_id, link_type, created_at FROM links WHERE to_id = ?").all(nodeId);
+    return [...fromRows.map(rowToLink), ...toRows.map(rowToLink)];
+  }
+  search(params) {
+    return this.searchIndex.search(params, (id) => this.getNodeWithRelations(id));
+  }
+  listKinds() {
+    const rows = this.db.query("SELECT kind, COUNT(*) as count FROM nodes GROUP BY kind ORDER BY count DESC").all();
+    return rows;
+  }
+  listTags() {
+    const rows = this.db.query("SELECT tag, COUNT(*) as count FROM tags GROUP BY tag ORDER BY count DESC").all();
+    return rows;
+  }
+  close() {
+    this.db.close();
+  }
+}

package/dist/src/core/ensure-dirs.js

@@ -0,0 +1,8 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+export function ensureDbDir(dbPath) {
+  if (dbPath === ":memory:") {
+    return;
+  }
+  mkdirSync(dirname(dbPath), { recursive: true });
+}

package/dist/src/core/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/kinds.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+const kindSchemas = new Map;
+export function registerKind(kind, schema) {
+  kindSchemas.set(kind, schema);
+}
+export function validateProperties(kind, props) {
+  const schema = kindSchemas.get(kind);
+  if (!schema) {
+    return props;
+  }
+  return schema.parse(props);
+}
+export function listRegisteredKinds() {
+  return Array.from(kindSchemas.keys());
+}
+registerKind("memo", z.object({}).passthrough());
+registerKind("todo", z.object({
+  deadline: z.string().datetime().optional(),
+  priority: z.enum(["low", "medium", "high"]).optional(),
+  status: z.enum(["pending", "in_progress", "done", "cancelled"]).default("pending")
+}));
+registerKind("conversation", z.object({
+  context: z.string(),
+  key_points: z.array(z.string()),
+  keywords_en: z.array(z.string()).optional(),
+  open_questions: z.array(z.string()),
+  session_ref: z.string().optional(),
+  summary_en: z.string().optional()
+}));
+registerKind("idea", z.object({
+  keywords_en: z.array(z.string()).optional(),
+  summary_en: z.string().optional()
+}));
+registerKind("decision", z.object({
+  constraint: z.string().describe("Specific design constraint established"),
+  why: z.string().describe("Reasoning behind the constraint"),
+  scope: z.string().describe("Where this constraint applies"),
+  rejected_alternatives: z.array(z.object({
+    what: z.string().describe("What was considered"),
+    why_rejected: z.string().describe("Why it was rejected")
+  })).optional().default([]),
+  repo_owner: z.string().optional().describe("Repository owner for scoping"),
+  repo_name: z.string().optional().describe("Repository name for scoping"),
+  summary_en: z.string().optional(),
+  keywords_en: z.array(z.string()).optional()
+}));

package/dist/src/core/schema.sql

@@ -0,0 +1,36 @@
+CREATE TABLE IF NOT EXISTS nodes (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  body TEXT NOT NULL DEFAULT '',
+  properties TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS tags (
+  node_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  tag TEXT NOT NULL,
+  PRIMARY KEY (node_id, tag)
+);
+
+CREATE TABLE IF NOT EXISTS links (
+  from_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  to_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  link_type TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (from_id, to_id, link_type)
+);
+
+CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);
+CREATE INDEX IF NOT EXISTS idx_nodes_updated ON nodes(updated_at);
+CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag);
+CREATE INDEX IF NOT EXISTS idx_links_to ON links(to_id);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
+  node_id UNINDEXED,
+  title,
+  summary,
+  keywords,
+  content='',
+  tokenize='unicode61'
+);

package/dist/src/core/schemas.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export const CreateNodeInput = z.object({
+  body: z.string().default("").describe("The text body of the node"),
+  kind: z.string().min(1).describe("The kind/type of the node"),
+  properties: z.record(z.string(), z.unknown()).default({}).describe("Structured properties for the node"),
+  tags: z.array(z.string()).optional().describe("Tags to apply to the node")
+});
+export const UpdateNodeInput = z.object({
+  body: z.string().optional().describe("New body text"),
+  id: z.string().length(26).describe("The node ID to update"),
+  kind: z.string().optional().describe("New kind for the node"),
+  properties: z.record(z.string(), z.unknown()).optional().describe("Updated properties")
+});
+export const SearchNodesInput = z.object({
+  kind: z.string().optional().describe("Filter by node kind"),
+  limit: z.number().int().min(1).max(100).default(20).describe("Maximum number of results (default 20)"),
+  offset: z.number().int().min(0).default(0).describe("Offset for pagination (default 0)"),
+  query: z.string().optional().describe("Full-text search query"),
+  tags: z.array(z.string()).optional().describe("Filter by tags")
+});
+export const GetLinksInput = z.object({
+  direction: z.enum(["from", "to", "both"]).default("both").describe("Direction of links to retrieve"),
+  node_id: z.string().length(26).describe("The node ID to get links for")
+});
+export const CreateLinkInput = z.object({
+  from_id: z.string().length(26).describe("The source node ID"),
+  link_type: z.string().min(1).describe("The type of link"),
+  to_id: z.string().length(26).describe("The target node ID")
+});
+export const TagsInput = z.object({
+  node_id: z.string().length(26).describe("The node ID to add/remove tags"),
+  tags: z.array(z.string().min(1)).min(1).describe("Tags to add or remove")
+});
+export const NodeIdInput = z.object({
+  id: z.string().length(26).describe("The node ID")
+});
+export const DeleteLinkInput = z.object({
+  from_id: z.string().length(26).describe("The source node ID"),
+  link_type: z.string().min(1).describe("The type of link"),
+  to_id: z.string().length(26).describe("The target node ID")
+});

package/dist/src/core/search.js

@@ -0,0 +1,80 @@
+export class SearchIndex {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.db.exec(`CREATE TABLE IF NOT EXISTS fts_rowid_map (
+        node_id TEXT PRIMARY KEY,
+        fts_rowid INTEGER NOT NULL
+      )`);
+  }
+  indexNode(node) {
+    const hasSummary = typeof node.properties.summary_en === "string";
+    const hasKeywords = Array.isArray(node.properties.keywords_en) && node.properties.keywords_en.length > 0;
+    if (!hasSummary && !hasKeywords) {
+      return;
+    }
+    const title = hasSummary ? node.properties.summary_en : "";
+    const summary = node.body ? node.body.slice(0, 200) : "";
+    const keywordsArr = hasKeywords ? node.properties.keywords_en : [];
+    const keywords = keywordsArr.join(" ");
+    this.db.query("INSERT INTO nodes_fts(node_id, title, summary, keywords) VALUES (?, ?, ?, ?)").run(node.id, title, summary, keywords);
+    const rowidRow = this.db.query("SELECT last_insert_rowid() as rowid").get();
+    if (rowidRow) {
+      this.db.query("INSERT OR REPLACE INTO fts_rowid_map(node_id, fts_rowid) VALUES (?, ?)").run(node.id, rowidRow.rowid);
+    }
+  }
+  removeNode(nodeId, node) {
+    const mapRow = this.db.query("SELECT fts_rowid FROM fts_rowid_map WHERE node_id = ?").get(nodeId);
+    if (!mapRow) {
+      return;
+    }
+    const title = typeof node.properties.summary_en === "string" ? node.properties.summary_en : "";
+    const summary = node.body ? node.body.slice(0, 200) : "";
+    const keywordsArr = Array.isArray(node.properties.keywords_en) ? node.properties.keywords_en : [];
+    const keywords = keywordsArr.join(" ");
+    this.db.query("INSERT INTO nodes_fts(nodes_fts, rowid, node_id, title, summary, keywords) VALUES('delete', ?, ?, ?, ?, ?)").run(mapRow.rowid, nodeId, title, summary, keywords);
+    this.db.query("DELETE FROM fts_rowid_map WHERE node_id = ?").run(nodeId);
+  }
+  search(params, getNodeWithRelations) {
+    const { query, kind, tags, limit, offset } = params;
+    const hasFts = query !== undefined && query.trim() !== "";
+    const hasKind = kind !== undefined && kind.trim() !== "";
+    const hasTags = tags !== undefined && tags.length > 0;
+    const whereConditions = [];
+    const queryParams = [];
+    let fromClause;
+    if (hasFts) {
+      fromClause = "FROM nodes JOIN fts_rowid_map ON nodes.id = fts_rowid_map.node_id " + "JOIN nodes_fts ON fts_rowid_map.fts_rowid = nodes_fts.rowid";
+      whereConditions.push("nodes_fts MATCH ?");
+      queryParams.push(query);
+    } else {
+      fromClause = "FROM nodes";
+    }
+    if (hasKind) {
+      whereConditions.push("nodes.kind = ?");
+      queryParams.push(kind);
+    }
+    if (hasTags) {
+      for (const tag of tags) {
+        whereConditions.push("nodes.id IN (SELECT node_id FROM tags WHERE tag = ?)");
+        queryParams.push(tag);
+      }
+    }
+    const whereClause = whereConditions.length > 0 ? `WHERE ${whereConditions.join(" AND ")}` : "";
+    const orderClause = hasFts ? "ORDER BY nodes_fts.rank" : "ORDER BY nodes.updated_at DESC";
+    const countSql = `SELECT COUNT(*) as total ${fromClause} ${whereClause}`;
+    const countRow = this.db.query(countSql).get(...queryParams);
+    const total = countRow ? countRow.total : 0;
+    const selectSql = `SELECT nodes.id ${fromClause} ${whereClause} ${orderClause} LIMIT ? OFFSET ?`;
+    const selectParams = [...queryParams, limit, offset];
+    const rows = this.db.query(selectSql).all(...selectParams);
+    const nodes = [];
+    for (const row of rows) {
+      const node = getNodeWithRelations(row.id);
+      if (node) {
+        nodes.push(node);
+      }
+    }
+    return { nodes, total };
+  }
+}

package/dist/src/tui/App.js

@@ -0,0 +1,130 @@
+import React, { useCallback, useState } from "react";
+import { Box, useApp, useInput } from "ink";
+import { FilterBar, parseFilter } from "./components/FilterBar.js";
+import { NodeList } from "./components/NodeList.js";
+import { NodeDetail } from "./components/NodeDetail.js";
+import { LinkList } from "./components/LinkList.js";
+import { StatusBar } from "./components/StatusBar.js";
+import { useNodes } from "./hooks/useNodes.js";
+import { useNavigation } from "./hooks/useNavigation.js";
+import { copyToClipboard, launchClaude } from "./actions.js";
+export function App() {
+  const { exit } = useApp();
+  const [filterInput, setFilterInput] = useState("");
+  const filter = parseFilter(filterInput);
+  const { nodes, loading, error } = useNodes(filter);
+  const nav = useNavigation();
+  const selectedNode = nodes[nav.selectedListIndex] ?? null;
+  const handleNavigate = useCallback((input, key) => {
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (input === "/") {
+      nav.focusFilter();
+      return;
+    }
+    if (key.tab) {
+      nav.cyclePanel();
+      return;
+    }
+    if (input === "j" || key.downArrow) {
+      if (nav.activePanel === "list") {
+        nav.navigateDown(nodes.length);
+      } else if (nav.activePanel === "links") {
+        const allLinks = selectedNode ? [...selectedNode.links_from, ...selectedNode.links_to] : [];
+        nav.navigateDown(allLinks.length);
+      }
+      return;
+    }
+    if (input === "k" || key.upArrow) {
+      nav.navigateUp();
+      return;
+    }
+    if (key.return) {
+      if (nav.activePanel === "list" && selectedNode) {} else if (nav.activePanel === "links" && selectedNode) {
+        const allLinks = [...selectedNode.links_from, ...selectedNode.links_to];
+        const targetLink = allLinks[nav.selectedLinkIndex];
+        if (targetLink) {
+          const targetId = targetLink.from_id === selectedNode.id ? targetLink.to_id : targetLink.from_id;
+          const targetIndex = nodes.findIndex((n) => n.id === targetId);
+          if (targetIndex >= 0) {
+            nav.setSelectedListIndex(targetIndex);
+            nav.setActivePanel("list");
+            nav.resetLinkIndex();
+          }
+        }
+      }
+      return;
+    }
+    if (input === "b") {
+      const nodeInfo = selectedNode ? `Node: ${selectedNode.kind} - ${selectedNode.body.slice(0, 100)}` : "No node selected";
+      launchClaude(exit, `Brainstorm ideas related to: ${nodeInfo}`);
+      return;
+    }
+    if (input === "r") {
+      launchClaude(exit, "Review all todo nodes and suggest priorities.");
+      return;
+    }
+    if (input === "y") {
+      if (selectedNode) {
+        const text = [
+          `ID: ${selectedNode.id}`,
+          `Kind: ${selectedNode.kind}`,
+          `Tags: ${selectedNode.tags.join(", ")}`,
+          `Body: ${selectedNode.body}`
+        ].join(`
+`);
+        copyToClipboard(text);
+      }
+      return;
+    }
+  }, [nav, nodes, selectedNode, exit]);
+  useInput(handleNavigate, { isActive: !nav.filterFocused });
+  useInput((_input, key) => {
+    if (key.escape) {
+      nav.blurFilter();
+    }
+  }, { isActive: nav.filterFocused });
+  const handleFilterChange = (value) => {
+    setFilterInput(value);
+  };
+  return jsxDEV_7x81h0kn(Box, {
+    flexDirection: "column",
+    flexGrow: 1,
+    children: [
+      jsxDEV_7x81h0kn(FilterBar, {
+        value: filterInput,
+        onChange: handleFilterChange,
+        focused: nav.filterFocused,
+        onBlur: nav.blurFilter
+      }, undefined, false, undefined, this),
+      jsxDEV_7x81h0kn(Box, {
+        flexDirection: "row",
+        flexGrow: 1,
+        children: [
+          jsxDEV_7x81h0kn(NodeList, {
+            nodes,
+            selectedIndex: nav.selectedListIndex,
+            focused: nav.activePanel === "list" && !nav.filterFocused,
+            loading,
+            error
+          }, undefined, false, undefined, this),
+          jsxDEV_7x81h0kn(NodeDetail, {
+            node: selectedNode,
+            focused: nav.activePanel === "detail" && !nav.filterFocused
+          }, undefined, false, undefined, this),
+          jsxDEV_7x81h0kn(LinkList, {
+            linksFrom: selectedNode?.links_from ?? [],
+            linksTo: selectedNode?.links_to ?? [],
+            selectedIndex: nav.selectedLinkIndex,
+            focused: nav.activePanel === "links" && !nav.filterFocused
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      jsxDEV_7x81h0kn(StatusBar, {
+        filterFocused: nav.filterFocused
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}

package/dist/src/tui/actions.js

@@ -0,0 +1,9 @@
+import { spawn } from "node:child_process";
+export function launchClaude(exit, prompt) {
+  exit();
+  spawn("claude", ["--prompt", prompt], { stdio: "inherit" });
+}
+export function copyToClipboard(text) {
+  const proc = spawn("pbcopy", [], { stdio: ["pipe"] });
+  proc.stdin?.end(text);
+}

package/dist/src/tui/components/FilterBar.js

@@ -0,0 +1,46 @@
+import { Box, Text } from "ink";
+import { TextInput } from "@inkjs/ui";
+export function FilterBar({ value, onChange, focused, onBlur }) {
+  return jsxDEV_7x81h0kn(Box, {
+    borderStyle: "single",
+    paddingX: 1,
+    flexShrink: 0,
+    children: [
+      jsxDEV_7x81h0kn(Text, {
+        bold: true,
+        color: focused ? "cyan" : "white",
+        children: [
+          "Filter:",
+          " "
+        ]
+      }, undefined, true, undefined, this),
+      focused ? jsxDEV_7x81h0kn(TextInput, {
+        defaultValue: value,
+        onChange,
+        onSubmit: () => onBlur()
+      }, undefined, false, undefined, this) : jsxDEV_7x81h0kn(Text, {
+        children: value || "(press / to filter)"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+export function parseFilter(input) {
+  const parts = input.trim().split(/\s+/);
+  let kind;
+  let tag;
+  const queryParts = [];
+  for (const part of parts) {
+    if (part.startsWith("kind:")) {
+      kind = part.slice(5);
+    } else if (part.startsWith("tag:")) {
+      tag = part.slice(4);
+    } else if (part.length > 0) {
+      queryParts.push(part);
+    }
+  }
+  return {
+    kind: kind || undefined,
+    query: queryParts.length > 0 ? queryParts.join(" ") : undefined,
+    tag: tag || undefined
+  };
+}

package/dist/src/tui/components/LinkList.js

@@ -0,0 +1,53 @@
+import React from "react";
+import { Box, Text } from "ink";
+export function LinkList({ linksFrom, linksTo, selectedIndex, focused }) {
+  const borderColor = focused ? "cyan" : undefined;
+  const allLinks = [
+    ...linksFrom.map((l) => ({ ...l, direction: "from" })),
+    ...linksTo.map((l) => ({ ...l, direction: "to" }))
+  ];
+  return jsxDEV_7x81h0kn(Box, {
+    flexDirection: "column",
+    borderStyle: "single",
+    borderColor,
+    flexGrow: 1,
+    overflow: "hidden",
+    children: [
+      jsxDEV_7x81h0kn(Text, {
+        bold: true,
+        underline: true,
+        children: [
+          " ",
+          "Links ",
+          focused ? "(active)" : ""
+        ]
+      }, undefined, true, undefined, this),
+      allLinks.length === 0 ? jsxDEV_7x81h0kn(Text, {
+        color: "gray",
+        children: " No links."
+      }, undefined, false, undefined, this) : allLinks.map((link, index) => {
+        const isSelected = index === selectedIndex;
+        const prefix = isSelected ? "> " : "  ";
+        const targetId = link.direction === "from" ? link.to_id.slice(0, 10) : link.from_id.slice(0, 10);
+        const dirSymbol = link.direction === "from" ? "->" : "<-";
+        const color = isSelected ? focused ? "cyan" : "white" : undefined;
+        return jsxDEV_7x81h0kn(Box, {
+          children: jsxDEV_7x81h0kn(Text, {
+            color,
+            bold: isSelected,
+            inverse: isSelected && focused,
+            children: [
+              prefix,
+              dirSymbol,
+              " ",
+              link.link_type,
+              " ",
+              targetId,
+              "..."
+            ]
+          }, undefined, true, undefined, this)
+        }, `${link.from_id}-${link.to_id}-${link.link_type}`, false, undefined, this);
+      })
+    ]
+  }, undefined, true, undefined, this);
+}