@unpolarize/knowledge-planning 0.1.0 → 0.2.0

package/src/cli/index.ts

@@ -1,189 +0,0 @@
-#!/usr/bin/env node
-import { homedir } from 'node:os';
-import { join, resolve, basename, dirname } from 'node:path';
-import { Store } from '../store/store.ts';
-import { PlanningIndex } from '../index/db.ts';
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import * as cmd from './commands.ts';
-
-const HELP = `knowledge-planning (kp) — durable, git-backed planning over a markdown SSOT
-
-Usage: kp <command> [options]
-
-  reindex                         Rebuild the .index/planning.db projection
-  list [--type T] [--status S]    List objects (idea/plan/task/...)
-  daily [--date today|YYYY-MM-DD] [--carry-over]   Render the daily board
-  board                           Alias for 'daily'
-  blocked                         Show objects blocked_by unresolved knowledge
-  graph [--json]                  Graph data (nodes/edges) for the CSV webview
-  capture "<text>" [--domain D]   Quick-capture an idea (status=capture)
-  promote <ideaId> [--to planId]  Promote an idea to a plan
-  link-session <objectId> <uuid>  Bidirectional session link (+planning_refs)
-  insight <file> --source S       Ingest digest/brief bullets into an Insight
-  ingest-gdoc [<file>] [--domain D] [--max N]  Diff-ingest NEW Google-Doc bullets →
-                                  capture ideas/inbox tasks (baselines on first run, caps per run)
-  set-status <objectId> <status>  Change an object's status (board lane / accept)
-  export [--date today|DATE]      One-shot JSON snapshot (for the CSV planning mode)
-  show <objectId>                 Rich JSON detail (body + resolved refs + children) for the dashboard
-  doctor                          Config, counts, fts, blocked, warnings
-
-Options:
-  --root <path>   Store root (default: package root or $KP_ROOT)
-  --help          This help
-`;
-
-function getFlag(argv: string[], name: string): string | undefined {
-  const i = argv.indexOf(name);
-  if (i >= 0 && i + 1 < argv.length && !argv[i + 1].startsWith('--')) return argv[i + 1];
-  const eq = argv.find((a) => a.startsWith(`${name}=`));
-  return eq ? eq.slice(name.length + 1) : undefined;
-}
-const hasFlag = (argv: string[], name: string): boolean => argv.includes(name);
-
-/**
- * Store root resolution. The DATA lives in the knowledge base (`~/docs/planning`),
- * not in this package — the package is tool source only. Override with `--root` or
- * `$KP_ROOT` (e.g. for tests or an alternate KB location).
- */
-export function defaultStoreRoot(): string {
-  return join(homedir(), 'docs', 'planning');
-}
-function resolveRoot(argv: string[]): string {
-  const flag = getFlag(argv, '--root');
-  if (flag) return resolve(flag);
-  if (process.env.KP_ROOT) return resolve(process.env.KP_ROOT);
-  return defaultStoreRoot();
-}
-
-function positionals(argv: string[]): string[] {
-  const out: string[] = [];
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a.startsWith('--')) {
-      if (i + 1 < argv.length && !argv[i + 1].startsWith('--') && !a.includes('=')) i++; // skip its value
-      continue;
-    }
-    out.push(a);
-  }
-  return out;
-}
-
-function main(): void {
-  const argv = process.argv.slice(2);
-  const command = argv[0];
-  if (!command || command === 'help' || hasFlag(argv, '--help')) {
-    console.log(HELP);
-    return;
-  }
-
-  const root = resolveRoot(argv);
-  const store = new Store(root);
-  const config = store.config();
-  const rest = positionals(argv).slice(1);
-  const idx = () => new PlanningIndex(store);
-
-  switch (command) {
-    case 'reindex':
-      console.log(cmd.cmdReindex(store, root));
-      break;
-    case 'list':
-      console.log(cmd.cmdList(store, { type: getFlag(argv, '--type'), status: getFlag(argv, '--status') }));
-      break;
-    case 'daily':
-    case 'board': {
-      const date = getFlag(argv, '--date');
-      console.log(cmd.cmdDaily(store, idx(), !date || date === 'today' ? cmd.today() : date, hasFlag(argv, '--carry-over')));
-      break;
-    }
-    case 'blocked':
-      console.log(cmd.cmdBlocked(idx(), config.kb_root));
-      break;
-    case 'graph':
-      console.log(cmd.cmdGraph(store, config.kb_root, hasFlag(argv, '--json')));
-      break;
-    case 'capture': {
-      if (!rest[0]) throw new Error('usage: kp capture "<text>" [--domain D]');
-      const res = cmd.cmdCapture(store, rest[0], getFlag(argv, '--domain'));
-      console.log(`captured ${res.id}`);
-      break;
-    }
-    case 'promote': {
-      if (!rest[0]) throw new Error('usage: kp promote <ideaId> [--to planId]');
-      const res = cmd.cmdPromote(store, rest[0], getFlag(argv, '--to'));
-      console.log(`promoted ${res.ideaId} → ${res.planId}`);
-      break;
-    }
-    case 'link-session': {
-      if (!rest[0] || !rest[1]) throw new Error('usage: kp link-session <objectId> <session-uuid>');
-      const res = cmd.cmdLinkSession(store, config.sessions_root, rest[0], rest[1]);
-      console.log(
-        `linked ${res.objectId} ↔ session ${res.uuid}\n  envelope: ${
-          res.envelopePath ? `${res.envelopeUpdated ? 'updated' : 'already linked'} (${res.envelopePath})` : 'not found in ' + config.sessions_root
-        }`,
-      );
-      break;
-    }
-    case 'insight': {
-      if (!rest[0]) throw new Error('usage: kp insight <file> --source S [--ref R]');
-      const text = readFileSync(resolve(rest[0]), 'utf8');
-      const res = cmd.cmdInsightIngest(store, text, getFlag(argv, '--source') ?? 'manual', getFlag(argv, '--ref'));
-      console.log(`created ${res.id} with ${res.suggested} suggested item(s)`);
-      break;
-    }
-    case 'export': {
-      const date = getFlag(argv, '--date');
-      console.log(JSON.stringify(cmd.cmdExport(store, idx(), config, !date || date === 'today' ? cmd.today() : date)));
-      break;
-    }
-    case 'show': {
-      if (!rest[0]) throw new Error('usage: kp show <objectId>');
-      console.log(JSON.stringify(cmd.cmdShow(store, config.kb_root, rest[0])));
-      break;
-    }
-    case 'ingest-gdoc': {
-      const file = rest[0] ? resolve(rest[0]) : join(homedir(), 'docs/raw/google-docs/personal-todo-notes.md');
-      const text = readFileSync(file, 'utf8');
-      // diff against a per-source snapshot so only NEW bullets ingest (baseline on first run)
-      const snapPath = join(root, '.ingest-state', `${basename(file)}.snapshot`);
-      const prevText = existsSync(snapPath) ? readFileSync(snapPath, 'utf8') : null;
-      const max = getFlag(argv, '--max');
-      const res = cmd.cmdIngestGdoc(store, text, {
-        domain: getFlag(argv, '--domain'),
-        prevText,
-        max: max ? Number(max) : undefined,
-      });
-      mkdirSync(dirname(snapPath), { recursive: true });
-      writeFileSync(snapPath, text, 'utf8');
-      if (res.baselined) {
-        console.log(`baselined ${file} (first run — no ingest). New bullets will be ingested on the next change.`);
-      } else {
-        console.log(
-          `ingested ${file}\n  ${res.newBullets} new bullet(s) → created ${res.created.length}, skipped ${res.skipped}` +
-            (res.capped ? `, capped ${res.capped} (raise with --max)` : ''),
-        );
-        if (res.created.length) console.log('  ' + res.created.join('\n  '));
-      }
-      break;
-    }
-    case 'set-status': {
-      if (!rest[0] || !rest[1]) throw new Error('usage: kp set-status <objectId> <status>');
-      cmd.cmdSetStatus(store, rest[0], rest[1]);
-      console.log(`set ${rest[0]} → ${rest[1]}`);
-      break;
-    }
-    case 'doctor':
-      console.log(cmd.cmdDoctor(store, idx(), config));
-      break;
-    default:
-      console.error(`unknown command: ${command}\n`);
-      console.log(HELP);
-      process.exitCode = 1;
-  }
-}
-
-try {
-  main();
-} catch (err) {
-  console.error(`error: ${(err as Error).message}`);
-  process.exitCode = 1;
-}

package/src/cli/sessions.ts

@@ -1,40 +0,0 @@
-import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-/** Locate a session envelope (`session.json`) by uuid under ~/.sessions/hosts/<host>/<month>/<uuid>/. */
-export function findSessionEnvelope(sessionsRoot: string, uuid: string): string | undefined {
-  const hostsDir = join(sessionsRoot, 'hosts');
-  if (!existsSync(hostsDir)) return undefined;
-  for (const host of safeDirs(hostsDir)) {
-    const hostDir = join(hostsDir, host);
-    for (const month of safeDirs(hostDir)) {
-      const candidate = join(hostDir, month, uuid, 'session.json');
-      if (existsSync(candidate)) return candidate;
-    }
-  }
-  return undefined;
-}
-
-function safeDirs(dir: string): string[] {
-  try {
-    return readdirSync(dir, { withFileTypes: true })
-      .filter((e) => e.isDirectory())
-      .map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Add a planning_ref to a session envelope (idempotent). This is the session side of
- * the bidirectional link — the planning object's `linked_sessions` is the other side.
- */
-export function addPlanningRef(envelopePath: string, planningId: string): boolean {
-  const env = JSON.parse(readFileSync(envelopePath, 'utf8')) as { planning_refs?: string[] };
-  const refs = new Set(env.planning_refs ?? []);
-  if (refs.has(planningId)) return false;
-  refs.add(planningId);
-  env.planning_refs = [...refs];
-  writeFileSync(envelopePath, JSON.stringify(env, null, 2) + '\n', 'utf8');
-  return true;
-}

package/src/graph/graph.ts

@@ -1,67 +0,0 @@
-import { existsSync } from 'node:fs';
-import { Store } from '../store/store.ts';
-import { resolveKnowledgeRef, readTitle } from '../kb-bridge/kb-bridge.ts';
-
-export interface GraphNode {
-  id: string;
-  label: string;
-  type: string; // domain|project|idea|plan|task|...|knowledge|session
-  group: string;
-  status?: string;
-  blocked?: boolean;
-}
-
-export interface GraphEdge {
-  from: string;
-  to: string;
-  kind: string;
-  status?: string;
-}
-
-export interface GraphData {
-  nodes: GraphNode[];
-  edges: GraphEdge[];
-}
-
-/**
- * GraphData for the CSV webview: planning objects + knowledge targets (red when an
- * unresolved blocker) + session evidence nodes, connected by typed edges.
- */
-export function buildGraph(store: Store, kbRoot: string): GraphData {
-  const nodes = new Map<string, GraphNode>();
-  const edges: GraphEdge[] = [];
-  const add = (n: GraphNode) => {
-    if (!nodes.has(n.id)) nodes.set(n.id, n);
-  };
-
-  for (const d of store.all()) {
-    const o = d.object as Record<string, unknown>;
-    add({
-      id: d.id,
-      label: (o.title as string) ?? d.id,
-      type: d.type,
-      group: (o.domain as string) ?? (o.project as string) ?? d.type,
-      status: (o.status as string) ?? undefined,
-    });
-  }
-
-  for (const e of store.allEdges()) {
-    if (e.kind === 'blocked_by' || e.kind === 'cites' || e.kind === 'implements') {
-      const abs = resolveKnowledgeRef(e.to, kbRoot);
-      const exists = existsSync(abs);
-      add({
-        id: e.to,
-        label: (exists ? readTitle(abs) : undefined) ?? e.to.split('/').pop() ?? e.to,
-        type: 'knowledge',
-        group: 'knowledge',
-        blocked: e.kind === 'blocked_by' && e.status !== 'resolved',
-      });
-    }
-    if (e.kind === 'evidence' && e.from.startsWith('session:')) {
-      add({ id: e.from, label: e.from.replace('session:', '').slice(0, 8), type: 'session', group: 'sessions' });
-    }
-    edges.push({ from: e.from, to: e.to, kind: e.kind, status: e.status });
-  }
-
-  return { nodes: [...nodes.values()], edges };
-}

package/src/index/db.test.ts

@@ -1,91 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Store } from '../store/store.ts';
-import { PlanningIndex, persistIndex } from './db.ts';
-import { buildGraph } from '../graph/graph.ts';
-
-let dir: string;
-let kb: string;
-
-function seed(): Store {
-  const s = new Store(dir);
-  s.write({ id: 'projects/cb', type: 'project', title: 'Code Build' });
-  s.write({ id: 'ideas/mm', type: 'idea', title: 'Memory maps', status: 'accepted', project: 'projects/cb' });
-  s.write({ id: 'ideas/raw', type: 'idea', title: 'Raw dump', status: 'capture' });
-  s.write({
-    id: 'plans/reloc',
-    type: 'plan',
-    title: 'Relocation decision',
-    kind: 'life',
-    status: 'plan',
-    blocked_by: [{ path: 'knowledge/life/relocation/x.md', reason: 'tax compare', status: 'open' }],
-  });
-  s.write({ id: 'daily/2026-06-21', type: 'daily_plan', title: 'Today', date: '2026-06-21' });
-  s.write({ id: 'tasks/scaffold', type: 'task', title: 'Scaffold repo', status: 'today', daily: 'daily/2026-06-21' });
-  s.write({ id: 'tasks/review', type: 'task', title: 'Review brief', status: 'done', daily: 'daily/2026-06-21' });
-  return s;
-}
-
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), 'kp-idx-'));
-  kb = mkdtempSync(join(tmpdir(), 'kp-idxkb-'));
-  mkdirSync(join(kb, 'knowledge/life/relocation'), { recursive: true });
-  writeFileSync(join(kb, 'knowledge/life/relocation/x.md'), '# Reloc\n\nopen\n');
-});
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true });
-  rmSync(kb, { recursive: true, force: true });
-});
-
-describe('PlanningIndex', () => {
-  it('projects objects and counts by type', () => {
-    const idx = new PlanningIndex(seed());
-    const counts = idx.counts();
-    expect(counts.idea).toBe(2);
-    expect(counts.task).toBe(2);
-    expect(counts.plan).toBe(1);
-    expect(idx.listByStatus('capture').map((r) => r.id)).toContain('ideas/raw');
-  });
-
-  it('searches titles', () => {
-    const idx = new PlanningIndex(seed());
-    expect(idx.search('memory').some((r) => r.id === 'ideas/mm')).toBe(true);
-  });
-
-  it('reports blocked_by knowledge edges with decision status', () => {
-    const idx = new PlanningIndex(seed());
-    const blocked = idx.blockedByKnowledge(kb);
-    expect(blocked.length).toBe(1);
-    expect(blocked[0]?.exists).toBe(true);
-    expect(blocked[0]?.decided).toBe(false);
-  });
-
-  it('builds a daily board grouped by lane', () => {
-    const idx = new PlanningIndex(seed());
-    const board = idx.dailyBoard('2026-06-21');
-    expect(board.daily_id).toBe('daily/2026-06-21');
-    expect(board.lanes.today.map((r) => r.id)).toContain('tasks/scaffold');
-    expect(board.lanes.done.map((r) => r.id)).toContain('tasks/review');
-  });
-
-  it('persists a file DB via reindex, idempotently (rebuild over existing fts)', () => {
-    const dbPath = join(dir, '.index/planning.db');
-    const res = persistIndex(seed(), dbPath);
-    expect(existsSync(dbPath)).toBe(true);
-    expect(res.objects).toBeGreaterThan(0);
-    // second reindex over the same file must not throw on objects_fts
-    expect(() => persistIndex(seed(), dbPath)).not.toThrow();
-  });
-});
-
-describe('buildGraph', () => {
-  it('includes planning + knowledge nodes and marks unresolved blockers', () => {
-    const g = buildGraph(seed(), kb);
-    expect(g.nodes.some((n) => n.id === 'ideas/mm' && n.type === 'idea')).toBe(true);
-    const knode = g.nodes.find((n) => n.type === 'knowledge');
-    expect(knode?.blocked).toBe(true);
-    expect(g.edges.some((e) => e.kind === 'blocked_by')).toBe(true);
-  });
-});

package/src/index/db.ts

@@ -1,196 +0,0 @@
-import { mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { Store } from '../store/store.ts';
-import { inspectKnowledgeRef, type BlockedInspection } from '../kb-bridge/kb-bridge.ts';
-import { TASK_STATUS } from '../schema/entities.ts';
-
-// `node:sqlite` is a prefix-only builtin that bundler-based runners (vitest/vite)
-// fail to resolve through a static import (they strip `node:` and hunt for a bare
-// `sqlite` package). `process.getBuiltinModule` loads it directly under both the
-// node-run CLI and vitest. A minimal local interface keeps us off @types/node.
-interface SqliteStatement {
-  run(...params: unknown[]): unknown;
-  all(...params: unknown[]): unknown[];
-  get(...params: unknown[]): unknown;
-}
-interface SqliteDB {
-  exec(sql: string): void;
-  prepare(sql: string): SqliteStatement;
-  close(): void;
-}
-const getBuiltinModule = (globalThis as { process: { getBuiltinModule: (id: string) => unknown } }).process
-  .getBuiltinModule;
-const { DatabaseSync } = getBuiltinModule('node:sqlite') as { DatabaseSync: new (path: string) => SqliteDB };
-
-export interface ObjectRow {
-  id: string;
-  type: string;
-  title: string | null;
-  status: string | null;
-  domain: string | null;
-  project: string | null;
-  path: string;
-  updated: string | null;
-}
-
-export interface DailyBoard {
-  date: string;
-  daily_id: string | null;
-  body: string;
-  lanes: Record<string, ObjectRow[]>;
-}
-
-/**
- * Read-side SQLite projection of the markdown store (node:sqlite, no native build).
- * Rebuilt from the store on construction, so it is always fresh and a clobber of the
- * persisted `.index/planning.db` is recoverable. FTS5 is used when the runtime has it,
- * else search degrades to LIKE.
- */
-export class PlanningIndex {
-  readonly db: SqliteDB;
-  readonly fts: boolean;
-  private store: Store;
-
-  constructor(store: Store, dbPath = ':memory:') {
-    this.store = store;
-    if (dbPath !== ':memory:') mkdirSync(dirname(dbPath), { recursive: true });
-    this.db = new DatabaseSync(dbPath);
-    this.fts = this.detectFts();
-    this.build();
-  }
-
-  private detectFts(): boolean {
-    try {
-      this.db.exec('CREATE VIRTUAL TABLE __fts_probe USING fts5(x); DROP TABLE __fts_probe;');
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  private build(): void {
-    this.db.exec(`
-      DROP TABLE IF EXISTS objects;
-      DROP TABLE IF EXISTS edges;
-      DROP TABLE IF EXISTS objects_fts;
-      CREATE TABLE objects (
-        id TEXT PRIMARY KEY, type TEXT, title TEXT, status TEXT,
-        domain TEXT, project TEXT, path TEXT, updated TEXT
-      );
-      CREATE TABLE edges (kind TEXT, from_id TEXT, to_id TEXT, reason TEXT, status TEXT);
-      CREATE INDEX idx_obj_type ON objects(type);
-      CREATE INDEX idx_obj_status ON objects(status);
-      CREATE INDEX idx_edge_kind ON edges(kind);
-    `);
-    if (this.fts) this.db.exec('CREATE VIRTUAL TABLE objects_fts USING fts5(id UNINDEXED, title, body);');
-
-    const insObj = this.db.prepare(
-      'INSERT OR REPLACE INTO objects (id,type,title,status,domain,project,path,updated) VALUES (?,?,?,?,?,?,?,?)',
-    );
-    const insFts = this.fts ? this.db.prepare('INSERT INTO objects_fts (id,title,body) VALUES (?,?,?)') : null;
-    for (const d of this.store.all()) {
-      const o = d.object as Record<string, unknown>;
-      insObj.run(
-        d.id,
-        d.type,
-        (o.title as string) ?? null,
-        (o.status as string) ?? null,
-        (o.domain as string) ?? null,
-        (o.project as string) ?? null,
-        d.relpath,
-        (o.updated as string) ?? null,
-      );
-      insFts?.run(d.id, (o.title as string) ?? '', d.body ?? '');
-    }
-
-    const insEdge = this.db.prepare('INSERT INTO edges (kind,from_id,to_id,reason,status) VALUES (?,?,?,?,?)');
-    for (const e of this.store.allEdges()) insEdge.run(e.kind, e.from, e.to, e.reason ?? null, e.status ?? null);
-  }
-
-  close(): void {
-    this.db.close();
-  }
-
-  // --- Queries -------------------------------------------------------------
-
-  all(): ObjectRow[] {
-    return this.db.prepare('SELECT * FROM objects ORDER BY type, id').all() as unknown as ObjectRow[];
-  }
-
-  byType(type: string): ObjectRow[] {
-    return this.db.prepare('SELECT * FROM objects WHERE type = ? ORDER BY id').all(type) as unknown as ObjectRow[];
-  }
-
-  listByStatus(status: string): ObjectRow[] {
-    return this.db.prepare('SELECT * FROM objects WHERE status = ? ORDER BY type, id').all(status) as unknown as ObjectRow[];
-  }
-
-  counts(): Record<string, number> {
-    const rows = this.db.prepare('SELECT type, COUNT(*) n FROM objects GROUP BY type').all() as Array<{
-      type: string;
-      n: number;
-    }>;
-    return Object.fromEntries(rows.map((r) => [r.type, r.n]));
-  }
-
-  /** All `blocked_by` knowledge edges, inspected against the KB for decision status. */
-  blockedByKnowledge(kbRoot: string): BlockedInspection[] {
-    const out: BlockedInspection[] = [];
-    for (const d of this.store.all()) {
-      for (const ref of d.object.blocked_by ?? []) out.push(inspectKnowledgeRef(d.id, ref, kbRoot));
-    }
-    return out;
-  }
-
-  /** Tasks linked to a day, grouped by lane, plus the daily plan body. */
-  dailyBoard(date: string): DailyBoard {
-    const dailyId = `daily/${date}`;
-    const daily = this.store.get(dailyId);
-    const tasks = this.store
-      .byType('task')
-      .filter((t) => {
-        const o = t.object as Record<string, unknown>;
-        return o.daily === dailyId || o.scheduled_for === dailyId;
-      })
-      .map((t) => this.rowOf(t.id))
-      .filter((r): r is ObjectRow => !!r);
-    const lanes: Record<string, ObjectRow[]> = {};
-    for (const lane of TASK_STATUS) lanes[lane] = [];
-    for (const t of tasks) (lanes[t.status ?? 'inbox'] ??= []).push(t);
-    return { date, daily_id: daily ? dailyId : null, body: daily?.body ?? '', lanes };
-  }
-
-  rowOf(id: string): ObjectRow | undefined {
-    return this.db.prepare('SELECT * FROM objects WHERE id = ?').get(id) as unknown as ObjectRow | undefined;
-  }
-
-  search(q: string): ObjectRow[] {
-    if (this.fts) {
-      try {
-        const ids = this.db.prepare('SELECT id FROM objects_fts WHERE objects_fts MATCH ? LIMIT 50').all(q) as Array<{
-          id: string;
-        }>;
-        if (ids.length === 0) return [];
-        const placeholders = ids.map(() => '?').join(',');
-        return this.db
-          .prepare(`SELECT * FROM objects WHERE id IN (${placeholders})`)
-          .all(...ids.map((r) => r.id)) as unknown as ObjectRow[];
-      } catch {
-        /* fall through to LIKE on malformed MATCH query */
-      }
-    }
-    const like = `%${q}%`;
-    return this.db
-      .prepare('SELECT * FROM objects WHERE title LIKE ? OR id LIKE ? ORDER BY type, id LIMIT 50')
-      .all(like, like) as unknown as ObjectRow[];
-  }
-}
-
-/** Persist the projection to a file DB (the `reindex` command). */
-export function persistIndex(store: Store, dbPath: string): { objects: number; edges: number } {
-  const idx = new PlanningIndex(store, dbPath);
-  const objects = store.all().length;
-  const edges = store.allEdges().length;
-  idx.close();
-  return { objects, edges };
-}

package/src/index.ts

@@ -1,14 +0,0 @@
-// Public API of @unpolarize/knowledge-planning — consumed by the CLI, agent skills,
-// and the Code Sessions VS Code planning mode.
-export * from './schema/index.ts';
-export * from './types.ts';
-export { Store, walkMarkdown } from './store/store.ts';
-export type { StoreDoc } from './store/store.ts';
-export { PlanningIndex, persistIndex } from './index/db.ts';
-export type { ObjectRow, DailyBoard } from './index/db.ts';
-export { buildGraph } from './graph/graph.ts';
-export type { GraphData, GraphNode, GraphEdge } from './graph/graph.ts';
-export * from './kb-bridge/kb-bridge.ts';
-export * from './migrate/gdoc.ts';
-export { findSessionEnvelope, addPlanningRef } from './cli/sessions.ts';
-export * as commands from './cli/commands.ts';

package/src/kb-bridge/kb-bridge.test.ts

@@ -1,44 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { inspectKnowledgeRef, readTitle, hasDecision } from './kb-bridge.ts';
-
-let kb: string;
-beforeEach(() => {
-  kb = mkdtempSync(join(tmpdir(), 'kp-kb-'));
-  mkdirSync(join(kb, 'knowledge/life/relocation'), { recursive: true });
-  writeFileSync(join(kb, 'knowledge/life/relocation/x.md'), '# Reloc research\n\nopen questions remain\n');
-  writeFileSync(join(kb, 'knowledge/life/relocation/y.md'), '---\ndecision: chose SLC\n---\n# Y\n');
-  writeFileSync(join(kb, 'knowledge/life/relocation/z.md'), '# Z\n\n## Decision\n\nGo with Coimbra.\n');
-});
-afterEach(() => rmSync(kb, { recursive: true, force: true }));
-
-describe('kb-bridge', () => {
-  it('reads titles from heading', () => {
-    expect(readTitle(join(kb, 'knowledge/life/relocation/x.md'))).toBe('Reloc research');
-  });
-
-  it('detects decision via frontmatter and via ## Decision section', () => {
-    expect(hasDecision(join(kb, 'knowledge/life/relocation/x.md'))).toBe(false);
-    expect(hasDecision(join(kb, 'knowledge/life/relocation/y.md'))).toBe(true);
-    expect(hasDecision(join(kb, 'knowledge/life/relocation/z.md'))).toBe(true);
-  });
-
-  it('marks a blocked_by edge resolvable only once the KB records a decision', () => {
-    const open = inspectKnowledgeRef('plans/reloc', { path: 'knowledge/life/relocation/x.md', status: 'open' }, kb);
-    expect(open.exists).toBe(true);
-    expect(open.decided).toBe(false);
-    expect(open.resolvable).toBe(false);
-
-    const decided = inspectKnowledgeRef('plans/reloc', { path: 'knowledge/life/relocation/y.md', status: 'open' }, kb);
-    expect(decided.decided).toBe(true);
-    expect(decided.resolvable).toBe(true);
-  });
-
-  it('flags missing KB targets', () => {
-    const miss = inspectKnowledgeRef('plans/x', { path: 'knowledge/nope.md', status: 'open' }, kb);
-    expect(miss.exists).toBe(false);
-    expect(miss.resolvable).toBe(false);
-  });
-});