becki 0.5.0

package/dist/vault.js

@@ -0,0 +1,357 @@
+/**
+ * vault.ts — local Becki vault read.
+ *
+ * Derives the splash data straight from the filesystem at ~/Documents/Becki/.
+ * No MCP call, no network, no auth.
+ *
+ * VAULT LAYOUT (verified on disk, 2026-05-18):
+ *   ~/Documents/Becki/
+ *     decisions/      *.md  — one file per entry, YAML frontmatter
+ *     dead-ends/      *.md
+ *     conversations/  *.md
+ *     meetings/       *.md
+ *     activity/       *.md
+ *     projects/<date|name>/...  *.md  (nested one level)
+ *     _meta/
+ *       open-loops.md — AGGREGATE file: a markdown checklist of open loops.
+ *                       "- [ ]" = unresolved, "- [x]" = resolved.
+ *     commitments/, open-loops/ — exist but empty (loops live in _meta).
+ *
+ * Entry files carry YAML frontmatter:
+ *   ---
+ *   origin: remote-mcp
+ *   source_type: decision
+ *   source_id: 2026-05-18-becki-shell-v0-2-reframe
+ *   created_at: 2026-05-18T13:53:13.191702+00:00
+ *   synced_at: 2026-05-18T13:53:27Z
+ *   ---
+ * Title is taken from the first "# Heading" line, falling back to source_id.
+ *
+ * Graceful: any read failure is reported via `warnings` and the rest of the
+ * splash still renders. A missing vault never blocks the CLI handoff.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+/** Per-type subdirectories that hold one entry per .md file. */
+const ENTRY_DIRS = ['decisions', 'dead-ends', 'conversations', 'meetings', 'activity'];
+/** Directories whose entries are nested one level deeper (per-day / per-project folders). */
+const NESTED_ENTRY_DIRS = ['projects'];
+/** The aggregate file that holds open loops. */
+const OPEN_LOOPS_REL = join('_meta', 'open-loops.md');
+/** Parse the YAML frontmatter block at the top of an entry file (shallow, string values only). */
+function parseFrontmatter(text) {
+    const fm = {};
+    if (!text.startsWith('---'))
+        return fm;
+    const end = text.indexOf('\n---', 3);
+    if (end === -1)
+        return fm;
+    const block = text.slice(3, end);
+    for (const line of block.split('\n')) {
+        const idx = line.indexOf(':');
+        if (idx === -1)
+            continue;
+        const key = line.slice(0, idx).trim();
+        const val = line.slice(idx + 1).trim();
+        if (key)
+            fm[key] = val;
+    }
+    return fm;
+}
+/**
+ * Turn an entry slug into a readable title when the file has no "# Heading".
+ * Strips a leading "YYYY-MM-DD-" date prefix, swaps hyphens/underscores for
+ * spaces, and sentence-cases the result.
+ * e.g. "2026-05-18-becki-shell-mvp-built" -> "Becki shell mvp built".
+ */
+function humanizeSlug(slug) {
+    const spaced = slug
+        .replace(/^\d{4}-\d{2}-\d{2}-/, '')
+        .replace(/[-_]+/g, ' ')
+        .trim();
+    if (!spaced)
+        return slug;
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+/** Extract the first markdown "# Heading" line from a file's body. */
+function firstHeading(text) {
+    for (const line of text.split('\n')) {
+        const t = line.trim();
+        if (t.startsWith('# '))
+            return t.slice(2).trim();
+    }
+    return null;
+}
+/**
+ * Read one entry file into a title + timestamp.
+ * Timestamp preference: frontmatter `created_at` → file mtime.
+ * Title preference: first "# Heading" → frontmatter `source_id` → filename.
+ */
+function readEntry(filePath, fileName) {
+    let text;
+    try {
+        text = readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const fm = parseFrontmatter(text);
+    let at = null;
+    let dated = false;
+    if (fm['created_at']) {
+        const parsed = new Date(fm['created_at']);
+        if (!Number.isNaN(parsed.getTime())) {
+            at = parsed;
+            dated = true;
+        }
+    }
+    if (!at) {
+        try {
+            at = statSync(filePath).mtime;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!at)
+        return null;
+    const heading = firstHeading(text);
+    const title = heading ??
+        humanizeSlug(fm['source_id'] ? fm['source_id'] : fileName.replace(/\.md$/i, ''));
+    return { title, at, dated };
+}
+/** List .md files directly inside a directory; missing dir yields []. */
+function listMarkdown(dir) {
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isFile() && d.name.toLowerCase().endsWith('.md'))
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+/** List .md files nested one directory level deep (e.g. projects/<name>/foo.md). */
+function listNestedMarkdown(dir) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    let subdirs;
+    try {
+        subdirs = readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+    for (const sub of subdirs) {
+        const subPath = join(dir, sub);
+        for (const name of listMarkdown(subPath)) {
+            out.push({ dirPath: subPath, name });
+        }
+    }
+    return out;
+}
+/**
+ * Parse the open-loops aggregate file into OpenThread records.
+ *
+ * Format (verified): a flat markdown checklist. Each loop starts a line with
+ * "- [ ]" (unresolved) or "- [x]" (resolved). A loop item may span many lines
+ * — only the first line is the headline. Loops are listed newest-last in the
+ * file, so we reverse to surface the most recent first.
+ *
+ * Age: many loop lines carry an inline date — either a trailing "— added
+ * YYYY-MM-DD" / "— YYYY-MM-DD ..." note or a "(paused YYYY-MM-DD" / "(Month
+ * YYYY)" marker. We pull the first YYYY-MM-DD we find on the item's lines;
+ * failing that we fall back to the file's "# Open Loops — YYYY-MM-DD" header.
+ */
+function parseOpenLoops(filePath, warnings) {
+    let text;
+    try {
+        text = readFileSync(filePath, 'utf8');
+    }
+    catch (err) {
+        warnings.push(`open loops unreadable (${err.message})`);
+        return [];
+    }
+    const lines = text.split('\n');
+    // File-level fallback date from the "# Open Loops — YYYY-MM-DD" header.
+    let headerDate = null;
+    const headerMatch = text.match(/^#\s*Open Loops\s*[—-]\s*(\d{4}-\d{2}-\d{2})/m);
+    if (headerMatch) {
+        const d = new Date(headerMatch[1] + 'T00:00:00Z');
+        if (!Number.isNaN(d.getTime()))
+            headerDate = d;
+    }
+    const DATE_RE = /(\d{4}-\d{2}-\d{2})/;
+    const threads = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const m = line.match(/^- \[( |x|X)\]\s?(.*)$/);
+        if (!m)
+            continue;
+        const resolved = m[1].toLowerCase() === 'x';
+        if (resolved)
+            continue; // only unresolved loops are open threads
+        let body = m[2];
+        // The leading "↑" is a priority/flag marker — strip it from the title.
+        const flagged = body.startsWith('↑');
+        if (flagged)
+            body = body.replace(/^↑\s*/, '');
+        // Collect this item's continuation lines (until the next "- [ ]"/"- [x]").
+        const itemLines = [body];
+        for (let j = i + 1; j < lines.length; j++) {
+            if (/^- \[( |x|X)\]/.test(lines[j]))
+                break;
+            itemLines.push(lines[j]);
+        }
+        // Title: first non-empty line of the item. Loop lines in the real vault
+        // often lead with a date or a status word ("OPEN —", "2026-05-16 —")
+        // before the substance. Strip those so the headline is the substance —
+        // the date is already surfaced separately as the age column.
+        let title = (itemLines.find((l) => l.trim() !== '') ?? body).trim();
+        title = title
+            .replace(/^Open loop\s*(\([^)]*\))?\s*[:—-]\s*/i, '')
+            .replace(/^OPEN\s*[—-]\s*/i, '')
+            .replace(/^\d{4}-\d{2}-\d{2}\s*(\([^)]*\))?\s*[:—-]\s*/, '')
+            .trim();
+        if (title === '')
+            title = (itemLines.find((l) => l.trim() !== '') ?? body).trim();
+        if (title.length > 96)
+            title = title.slice(0, 95).trimEnd() + '…';
+        // Age: first date found on the item's lines, else the file header date.
+        let date = headerDate;
+        for (const l of itemLines) {
+            const dm = l.match(DATE_RE);
+            if (dm) {
+                const d = new Date(dm[1] + 'T00:00:00Z');
+                if (!Number.isNaN(d.getTime())) {
+                    date = d;
+                    break;
+                }
+            }
+        }
+        let ageDays = null;
+        if (date) {
+            const ms = Date.now() - date.getTime();
+            ageDays = Math.max(0, Math.floor(ms / 86_400_000));
+        }
+        threads.push({ title, flagged, ageDays });
+    }
+    // Newest-first: the file appends new loops at the bottom, and loops with a
+    // smaller age (more recent date) should lead. Unknown ages sort last.
+    threads.reverse();
+    threads.sort((a, b) => {
+        if (a.ageDays === null && b.ageDays === null)
+            return 0;
+        if (a.ageDays === null)
+            return 1;
+        if (b.ageDays === null)
+            return -1;
+        return a.ageDays - b.ageDays;
+    });
+    return threads;
+}
+/**
+ * Read the vault and derive everything the splash needs.
+ * `maxOpenThreads` caps the open-threads list. `showOpenThreads` skips the
+ * (cheap, but pointless) loop parse when the splash won't show them.
+ *
+ * Never throws. A missing or unreadable vault returns ok:false with a warning.
+ */
+export function readVault(vaultPath, maxOpenThreads, showOpenThreads) {
+    const warnings = [];
+    const data = {
+        ok: false,
+        path: vaultPath,
+        entryCount: 0,
+        lastEntryTitle: null,
+        lastEntryAt: null,
+        openThreads: [],
+        openThreadsTotal: 0,
+        warnings,
+    };
+    if (!existsSync(vaultPath)) {
+        warnings.push('vault: not found — launching anyway');
+        return data;
+    }
+    try {
+        if (!statSync(vaultPath).isDirectory()) {
+            warnings.push('vault: path is not a directory — launching anyway');
+            return data;
+        }
+    }
+    catch (err) {
+        warnings.push(`vault: unreadable (${err.message}) — launching anyway`);
+        return data;
+    }
+    data.ok = true;
+    // --- Entry count + last ingested ---------------------------------------
+    let newest = null;
+    let count = 0;
+    for (const dir of ENTRY_DIRS) {
+        const dirPath = join(vaultPath, dir);
+        for (const name of listMarkdown(dirPath)) {
+            count++;
+            const entry = readEntry(join(dirPath, name), name);
+            if (entry?.dated && (!newest || entry.at > newest.at))
+                newest = entry;
+        }
+    }
+    for (const dir of NESTED_ENTRY_DIRS) {
+        const dirPath = join(vaultPath, dir);
+        for (const { dirPath: subPath, name } of listNestedMarkdown(dirPath)) {
+            count++;
+            const entry = readEntry(join(subPath, name), name);
+            if (entry?.dated && (!newest || entry.at > newest.at))
+                newest = entry;
+        }
+    }
+    data.entryCount = count;
+    if (newest) {
+        data.lastEntryTitle = newest.title;
+        data.lastEntryAt = newest.at;
+    }
+    else {
+        warnings.push('vault: no entries found');
+    }
+    // --- Open threads ------------------------------------------------------
+    if (showOpenThreads) {
+        const loopsPath = join(vaultPath, OPEN_LOOPS_REL);
+        if (existsSync(loopsPath)) {
+            const all = parseOpenLoops(loopsPath, warnings);
+            data.openThreadsTotal = all.length;
+            data.openThreads = all.slice(0, Math.max(0, maxOpenThreads));
+        }
+        else {
+            warnings.push('vault: no open-loops file (_meta/open-loops.md)');
+        }
+    }
+    return data;
+}
+/** Human-friendly relative age, e.g. "2h ago", "3d ago", "just now". */
+export function relativeAge(at) {
+    if (!at)
+        return 'unknown';
+    const ms = Date.now() - at.getTime();
+    if (ms < 0)
+        return 'just now';
+    const mins = Math.floor(ms / 60_000);
+    if (mins < 1)
+        return 'just now';
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `${months}mo ago`;
+    return `${Math.floor(months / 12)}y ago`;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "becki",
+  "version": "0.5.0",
+  "description": "Becki — cross-platform admin TUI for the Becki Core memory layer. Manage watch folders, run backfills, copy install tokens, check subscription, all from the terminal. Pairs with becki-mcp.",
+  "keywords": [
+    "becki",
+    "mcp",
+    "memory",
+    "ai",
+    "tui",
+    "ink",
+    "cli",
+    "neuravault",
+    "claude",
+    "cursor",
+    "codex"
+  ],
+  "homepage": "https://www.becki.io",
+  "bugs": {
+    "url": "https://github.com/bdsantosDEV/becki-vault/issues",
+    "email": "support@becki.io"
+  },
+  "license": "UNLICENSED",
+  "author": {
+    "name": "BECKI.IO LLC",
+    "url": "https://www.becki.io"
+  },
+  "type": "module",
+  "bin": {
+    "becki": "bin/becki.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "bundle": "node scripts/bundle.mjs",
+    "start": "node bin/becki.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.10.0",
+    "ink": "^5.0.1",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.9.0",
+    "@types/react": "^18.3.3",
+    "esbuild": "^0.28.0",
+    "typescript": "^5.5.4"
+  }
+}