dude-claude-plugin 2026.2.18 → 2026.2.20

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dude",
-  "version": "2026.2.18",
+  "version": "2026.2.20",
   "description": "Ultra-minimal RAG and cross-project memory for Claude CLI",
   "author": {
     "name": "Fingerskier"

package/README.md

@@ -63,7 +63,17 @@ npx dude-claude-plugin serve
 dude-claude serve
 ```
 
-Opens a local dashboard on port 3456 for browsing and editing projects, issues, and specifications.
+Opens a local dashboard at `http://127.0.0.1:3456` (auto-opens in your browser). The UI has two panels: a sidebar listing records with filters, and a main panel for viewing and editing.
+
+**What you can do:**
+
+- **Project selector** — filter records by project or view all projects at once
+- **Semantic search** — type in the search bar to find records by meaning, not just keywords (results ranked by similarity)
+- **Filter by kind** — narrow to issues, specs, arch decisions, updates, or tests
+- **Filter by status** — open, resolved, archived, active, or inactive
+- **Create / edit / delete** — click "+ New" to add a record, click any record to edit it, or delete from the detail view
+
+Set `DUDE_PORT` to change the default port (see [Configuration](#configuration)).
 
 ## Configuration
 

package/bin/dude-claude.js

@@ -1,32 +1,43 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
+
+process.on('uncaughtException', (err) => {
+  console.error(`[dude] Fatal error: ${err.message}`);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (err) => {
+  console.error(`[dude] Unhandled rejection: ${err?.message || err}`);
+  process.exit(1);
+});
 
 const command = process.argv[2] || 'mcp';
 
-switch (command) {
-  case 'mcp': {
-    const { startServer } = await import('../src/server.js');
-    await startServer();
-    break;
-  }
-  case 'serve': {
-    const { startWebServer } = await import('../src/web.js');
-    await startWebServer();
-    break;
-  }
-  case 'auto-retrieve': {
-    await import('../hooks/auto-retrieve.js');
-    break;
-  }
-  case 'auto-persist': {
-    await import('../hooks/auto-persist.js');
-    break;
-  }
-  case 'auto-persist-plan': {
-    await import('../hooks/auto-persist-plan.js');
-    break;
-  }
-  default:
-    console.error(`Usage: dude-claude [mcp|serve|auto-retrieve|auto-persist|auto-persist-plan]
+try {
+  switch (command) {
+    case 'mcp': {
+      const { startServer } = await import('../src/server.js');
+      await startServer();
+      break;
+    }
+    case 'serve': {
+      const { startWebServer } = await import('../src/web.js');
+      await startWebServer();
+      break;
+    }
+    case 'auto-retrieve': {
+      await import('../hooks/auto-retrieve.js');
+      break;
+    }
+    case 'auto-persist': {
+      await import('../hooks/auto-persist.js');
+      break;
+    }
+    case 'auto-persist-plan': {
+      await import('../hooks/auto-persist-plan.js');
+      break;
+    }
+    default:
+      console.error(`Usage: dude-claude [mcp|serve|auto-retrieve|auto-persist|auto-persist-plan]
 
 Commands:
   mcp               Start the MCP stdio server (default)
@@ -34,5 +45,9 @@ Commands:
   auto-retrieve     Run the auto-retrieve hook (reads prompt from stdin)
   auto-persist      Run the auto-persist utility (reads classification JSON from stdin)
   auto-persist-plan Run the auto-persist-plan utility (reads classification JSON from stdin)`);
-    process.exit(1);
+      process.exit(1);
+  }
+} catch (err) {
+  console.error(`[dude] Startup failed: ${err.message}`);
+  process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dude-claude-plugin",
-  "version": "2026.2.18",
+  "version": "2026.2.20",
   "description": "Ultra-minimal RAG and cross-project memory for Claude CLI",
   "type": "module",
   "bin": {

package/scripts/dump-local.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * Export the local libsql database as SQL INSERT statements.
+ *
+ * Usage:
+ *   node scripts/dump-local.js > dump.sql
+ *   turso db shell <dbname> < dump.sql
+ *
+ * Reads from ~/.dude-claude/dude-libsql.db (or DUDE_DB_PATH env override).
+ * Outputs projects first, then records (with vector embeddings), to stdout.
+ */
+
+import { createClient } from '@libsql/client';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const DATA_DIR = join(homedir(), '.dude-claude');
+const DB_PATH = process.env.DUDE_DB_PATH || join(DATA_DIR, 'dude-libsql.db');
+
+function esc(str) {
+  if (str == null) return 'NULL';
+  return "'" + String(str).replace(/'/g, "''") + "'";
+}
+
+function parseEmbedding(blob) {
+  if (!blob) return null;
+  if (blob instanceof Float32Array) return blob;
+  if (blob instanceof ArrayBuffer) return new Float32Array(blob);
+  if (ArrayBuffer.isView(blob)) {
+    return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
+  }
+  if (typeof blob === 'string') return new Float32Array(JSON.parse(blob));
+  return null;
+}
+
+async function main() {
+  const db = createClient({ url: `file:${DB_PATH}` });
+
+  // -- Projects --
+  const projects = await db.execute('SELECT * FROM project ORDER BY id');
+  for (const p of projects.rows) {
+    console.log(
+      `INSERT INTO project (id, name, created_at, updated_at) VALUES (${p.id}, ${esc(p.name)}, ${esc(p.created_at)}, ${esc(p.updated_at)});`
+    );
+  }
+
+  // -- Records (with embeddings) --
+  const records = await db.execute('SELECT * FROM record ORDER BY id');
+  for (const r of records.rows) {
+    const emb = parseEmbedding(r.embedding);
+    const embExpr = emb
+      ? `vector('${JSON.stringify(Array.from(emb))}')`
+      : 'NULL';
+
+    console.log(
+      `INSERT INTO record (id, project_id, kind, title, body, status, embedding, created_at, updated_at) VALUES (${r.id}, ${r.project_id}, ${esc(r.kind)}, ${esc(r.title)}, ${esc(r.body)}, ${esc(r.status)}, ${embExpr}, ${esc(r.created_at)}, ${esc(r.updated_at)});`
+    );
+  }
+
+  db.close();
+  console.error(`[dump] Exported ${projects.rows.length} projects, ${records.rows.length} records`);
+}
+
+main().catch(err => {
+  console.error('dump-local failed:', err);
+  process.exit(1);
+});

package/src/db-libsql.js

@@ -1,6 +1,6 @@
 import { createClient } from '@libsql/client';
 import { execSync } from 'node:child_process';
-import { existsSync, mkdirSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { DbAdapter } from './db-adapter.js';
@@ -21,6 +21,7 @@ export class LibsqlAdapter extends DbAdapter {
     this.config = config;
     this.db = null;
     this.currentProject = null;
+    this._syncError = null;
   }
 
   // ---------------------------------------------------------------------------
@@ -30,13 +31,38 @@ export class LibsqlAdapter extends DbAdapter {
   async init() {
     if (this.db) return;
     this._ensureDataDir();
-    this.db = this._createClient();
-    await this._runSchema();
+    this._syncError = null;
+
+    if (this._hasSyncConfig()) {
+      try {
+        this.db = this._createClient();  // tries sync-enabled client
+        await this._runSchema();
+      } catch (err) {
+        // Close the bad client if it was created
+        if (this.db) try { this.db.close(); } catch {}
+        this._syncError = err.message;
+        this._logToFile(`Cloud sync failed: ${err.message}\n${err.stack}`);
+        console.error(`[dude] Cloud sync failed: ${err.message}`);
+        console.error('[dude] Falling back to local-only mode. Details in ~/.dude-claude/dude.log');
+        // Recreate with local-only client
+        this.db = this._createLocalOnlyClient();
+        await this._runSchema();
+      }
+    } else {
+      this.db = this._createLocalOnlyClient();
+      await this._runSchema();
+    }
+
     const projectName = this._detectProject();
     this.currentProject = await this._upsertProject(projectName);
     await this._migrateProjectNames(projectName);
+
     const syncInfo = await this.syncStatus();
-    const syncMsg = syncInfo.enabled ? ` | cloud sync → ${syncInfo.syncUrl}` : '';
+    const syncMsg = syncInfo.enabled
+      ? ` | cloud sync → ${syncInfo.syncUrl}`
+      : syncInfo.error
+        ? ' | cloud sync FAILED — local-only mode'
+        : '';
     console.error(`[dude] LibSQL DB ready — project "${this.currentProject.name}" (id=${this.currentProject.id})${syncMsg}`);
   }
 
@@ -46,6 +72,23 @@ export class LibsqlAdapter extends DbAdapter {
     }
   }
 
+  _logToFile(message) {
+    try {
+      const logPath = join(DATA_DIR, 'dude.log');
+      const timestamp = new Date().toISOString();
+      appendFileSync(logPath, `[${timestamp}] ${message}\n`);
+    } catch { /* never let logging crash the server */ }
+  }
+
+  _hasSyncConfig() {
+    return !!(this.config.syncUrl || process.env.DUDE_TURSO_URL);
+  }
+
+  _createLocalOnlyClient() {
+    const url = this.config.url || `file:${this.config.dbPath || DB_PATH}`;
+    return createClient({ url });
+  }
+
   _createClient() {
     const url = this.config.url
       || `file:${this.config.dbPath || DB_PATH}`;
@@ -55,8 +98,8 @@ export class LibsqlAdapter extends DbAdapter {
     if (this.config.syncUrl || process.env.DUDE_TURSO_URL) {
       opts.syncUrl = this.config.syncUrl || process.env.DUDE_TURSO_URL;
       opts.authToken = this.config.authToken || process.env.DUDE_TURSO_TOKEN;
-      const interval = this.config.syncInterval || process.env.DUDE_SYNC_INTERVAL;
-      if (interval) opts.syncInterval = parseInt(interval);
+      const interval = this.config.syncInterval || process.env.DUDE_SYNC_INTERVAL || 60000;
+      opts.syncInterval = parseInt(interval);
     }
 
     return createClient(opts);
@@ -419,22 +462,39 @@ export class LibsqlAdapter extends DbAdapter {
     const syncUrl = this.config.syncUrl || process.env.DUDE_TURSO_URL || null;
     const syncInterval = this.config.syncInterval
       || process.env.DUDE_SYNC_INTERVAL
-      || null;
+      || (syncUrl ? 60000 : null);
     return {
-      enabled: !!syncUrl,
+      enabled: !!syncUrl && !this._syncError,
       ...(syncUrl ? { syncUrl } : {}),
       ...(syncInterval ? { syncInterval: parseInt(syncInterval) } : {}),
+      ...(this._syncError ? { error: this._syncError, degraded: true } : {}),
     };
   }
 
   async sync() {
-    const status = await this.syncStatus();
-    if (!status.enabled) {
+    if (!this._hasSyncConfig()) {
       return { synced: false, message: 'Cloud sync not configured. Set DUDE_TURSO_URL and DUDE_TURSO_TOKEN to enable.' };
     }
+
+    // If degraded, attempt to reconnect with sync-enabled client
+    if (this._syncError) {
+      try {
+        const newClient = this._createClient();
+        // Run a test query to verify the connection works
+        await newClient.execute('SELECT 1');
+        this.db.close();
+        this.db = newClient;
+        this._syncError = null;
+        console.error('[dude] Cloud sync reconnected successfully.');
+        return { synced: true, message: `Reconnected and synced with ${this.config.syncUrl || process.env.DUDE_TURSO_URL}` };
+      } catch (err) {
+        return { synced: false, message: `Reconnection failed: ${err.message}` };
+      }
+    }
+
     try {
       await this.db.sync();
-      return { synced: true, message: `Synced with ${status.syncUrl}` };
+      return { synced: true, message: `Synced with ${this.config.syncUrl || process.env.DUDE_TURSO_URL}` };
     } catch (err) {
       return { synced: false, message: `Sync failed: ${err.message}` };
     }