@jhizzard/termdeck 0.2.5 → 0.3.0

package/packages/server/src/index.js

@@ -10,9 +10,37 @@ const fs = require('fs');
 const { v4: uuidv4 } = require('uuid');
 
 // Conditional imports (graceful fallback if not installed yet)
-let pty, Database;
+let pty, Database, pg;
 try { pty = require('@homebridge/node-pty-prebuilt-multiarch'); } catch { pty = null; }
 try { Database = require('better-sqlite3'); } catch { Database = null; }
+try { pg = require('pg'); } catch { pg = null; }
+
+// Module-level singleton Postgres pool for rumen_insights (petvetbid DB).
+// Lazy-initialized on first rumen endpoint hit so startup stays fast and
+// servers without DATABASE_URL never pay the connection cost.
+let _rumenPool = null;
+let _rumenPoolFailed = false;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function getRumenPool() {
+  if (_rumenPool || _rumenPoolFailed) return _rumenPool;
+  if (!pg || !process.env.DATABASE_URL) return null;
+  try {
+    _rumenPool = new pg.Pool({
+      connectionString: process.env.DATABASE_URL,
+      max: 4,
+      idleTimeoutMillis: 30000,
+      connectionTimeoutMillis: 5000
+    });
+    _rumenPool.on('error', (err) => {
+      console.warn('[rumen] pg pool error:', err.message);
+    });
+    return _rumenPool;
+  } catch (err) {
+    console.warn('[rumen] failed to create pg pool:', err.message);
+    _rumenPoolFailed = true;
+    return null;
+  }
+}
 
 const { SessionManager } = require('./session');
 const { initDatabase, logCommand, getSessionHistory, getProjectSessions } = require('./database');
@@ -171,9 +199,13 @@ function createServer(config) {
           rag.onStatusChanged(sess, oldStatus, newStatus);
         };
 
-        // Proactive Mnestra queries on error — fire-and-forget, respects rag.enabled
+        // Proactive Mnestra queries on error — fire-and-forget.
+        // Independent of rag.enabled — the push loop (rag.js) and the Flashback
+        // bridge (mnestra-bridge) are separate systems. rag.enabled gates only
+        // the telemetry push loop. Flashback has its own error handling via
+        // the catch below and should fire whenever the Mnestra bridge is
+        // configured, regardless of the push-loop flag.
         session.onErrorDetected = (sess, ctx) => {
-          if (!rag.enabled) return;
           const question = `${sess.meta.type} error ${ctx.lastCommand || ''} ${ctx.tail || ''}`.trim();
           mnestraBridge.queryMnestra({
             question,
@@ -415,6 +447,146 @@ function createServer(config) {
     });
   });
 
+  // ==================== Rumen insights (Sprint 4 T2) ====================
+  // Read-only access to rumen_insights + rumen_jobs in the petvetbid Postgres
+  // instance. Contract frozen in docs/sprint-4-rumen-integration/API-CONTRACT.md.
+
+  function rumenUnreachable(res) {
+    return res.status(503).json({ error: 'rumen database unreachable' });
+  }
+
+  // GET /api/rumen/insights
+  app.get('/api/rumen/insights', async (req, res) => {
+    const pool = getRumenPool();
+    if (!pool) {
+      return res.json({ insights: [], total: 0, enabled: false });
+    }
+
+    let limit = parseInt(req.query.limit, 10);
+    if (!Number.isFinite(limit)) limit = 20;
+    limit = Math.max(1, Math.min(100, limit));
+
+    const project = typeof req.query.project === 'string' && req.query.project.trim()
+      ? req.query.project.trim() : null;
+    const since = typeof req.query.since === 'string' && !Number.isNaN(Date.parse(req.query.since))
+      ? new Date(req.query.since).toISOString() : null;
+    const unseen = typeof req.query.unseen === 'string' &&
+      /^(1|true|yes)$/i.test(req.query.unseen);
+
+    const where = [];
+    const params = [];
+    if (project) { params.push(project); where.push(`$${params.length} = ANY(projects)`); }
+    if (since)   { params.push(since);   where.push(`created_at >= $${params.length}`); }
+    if (unseen)  { where.push(`acted_upon = FALSE`); }
+    const whereSql = where.length ? `WHERE ${where.join(' AND ')}` : '';
+
+    try {
+      const countSql = `SELECT COUNT(*)::int AS n FROM rumen_insights ${whereSql}`;
+      const listParams = params.slice();
+      listParams.push(limit);
+      const listSql =
+        `SELECT id, insight_text, confidence, projects, source_memory_ids, created_at, acted_upon
+           FROM rumen_insights
+           ${whereSql}
+           ORDER BY created_at DESC
+           LIMIT $${listParams.length}`;
+
+      const [countRes, listRes] = await Promise.all([
+        pool.query(countSql, params),
+        pool.query(listSql, listParams)
+      ]);
+
+      const insights = listRes.rows.map((r) => ({
+        id: r.id,
+        insight_text: r.insight_text,
+        confidence: r.confidence == null ? 0 : Number(r.confidence),
+        projects: r.projects || [],
+        source_memory_ids: r.source_memory_ids || [],
+        created_at: r.created_at instanceof Date ? r.created_at.toISOString() : r.created_at,
+        acted_upon: !!r.acted_upon
+      }));
+
+      res.json({ insights, total: countRes.rows[0]?.n || 0 });
+    } catch (err) {
+      console.warn('[rumen] GET /insights failed:', err.message);
+      return rumenUnreachable(res);
+    }
+  });
+
+  // GET /api/rumen/status
+  app.get('/api/rumen/status', async (req, res) => {
+    const pool = getRumenPool();
+    if (!pool) return res.json({ enabled: false });
+
+    try {
+      const jobSql =
+        `SELECT id, status, completed_at, sessions_processed, insights_generated
+           FROM rumen_jobs
+           ORDER BY started_at DESC
+           LIMIT 1`;
+      const insightSql =
+        `SELECT
+            COUNT(*)::int AS total,
+            COUNT(*) FILTER (WHERE acted_upon = FALSE)::int AS unseen,
+            MAX(created_at) AS latest
+           FROM rumen_insights`;
+
+      const [jobRes, insightRes] = await Promise.all([
+        pool.query(jobSql),
+        pool.query(insightSql)
+      ]);
+
+      const job = jobRes.rows[0] || null;
+      const stat = insightRes.rows[0] || { total: 0, unseen: 0, latest: null };
+
+      res.json({
+        enabled: true,
+        last_job_id: job ? job.id : null,
+        last_job_status: job ? job.status : null,
+        last_job_completed_at: job && job.completed_at
+          ? (job.completed_at instanceof Date ? job.completed_at.toISOString() : job.completed_at)
+          : null,
+        last_job_sessions_processed: job ? (job.sessions_processed || 0) : 0,
+        last_job_insights_generated: job ? (job.insights_generated || 0) : 0,
+        total_insights: stat.total || 0,
+        unseen_insights: stat.unseen || 0,
+        latest_insight_at: stat.latest
+          ? (stat.latest instanceof Date ? stat.latest.toISOString() : stat.latest)
+          : null
+      });
+    } catch (err) {
+      console.warn('[rumen] GET /status failed:', err.message);
+      return rumenUnreachable(res);
+    }
+  });
+
+  // POST /api/rumen/insights/:id/seen
+  app.post('/api/rumen/insights/:id/seen', async (req, res) => {
+    const pool = getRumenPool();
+    if (!pool) return res.status(503).json({ error: 'rumen not configured' });
+
+    const id = req.params.id;
+    if (!UUID_RE.test(id)) {
+      return res.status(400).json({ error: 'invalid insight id' });
+    }
+
+    try {
+      const result = await pool.query(
+        `UPDATE rumen_insights SET acted_upon = TRUE WHERE id = $1
+         RETURNING id, acted_upon`,
+        [id]
+      );
+      if (result.rowCount === 0) {
+        return res.status(404).json({ error: 'insight not found' });
+      }
+      const row = result.rows[0];
+      res.json({ id: row.id, acted_upon: !!row.acted_upon });
+    } catch (err) {
+      console.warn('[rumen] POST /insights/:id/seen failed:', err.message);
+      return rumenUnreachable(res);
+    }
+  });
+
   // POST /api/ai/query - query Mnestra memory via the bridge (direct|webhook|mcp)
   app.post('/api/ai/query', async (req, res) => {
     let { question, sessionId, project } = req.body;

package/packages/server/src/session.js

@@ -51,7 +51,11 @@ const PATTERNS = {
     command: /^[\$#%❯>]\s+(.+)$/m
   },
   // Broad error markers across shells, compilers, scripts, and HTTP servers.
-  error: /\b(error|Error|ERROR|exception|Exception|Traceback|fatal|FATAL|segmentation fault|panic|EACCES|ECONNREFUSED|ENOENT|command not found|undefined reference|cannot find module|failed with exit code|\b5\d\d\b)\b/
+  // Includes the literal "No such file or directory" phrase because many Unix
+  // tools (cat, ls, cd, rm, etc.) report filesystem misses in plain English
+  // without ever emitting the ENOENT errno code. Flagged as a gap by Rumen's
+  // first production kickstart insight on 2026-04-15.
+  error: /\b(error|Error|ERROR|exception|Exception|Traceback|fatal|FATAL|segmentation fault|panic|EACCES|ECONNREFUSED|ENOENT|command not found|undefined reference|cannot find module|failed with exit code|No such file or directory|Permission denied|\b5\d\d\b)\b/
 };
 
 class Session {

package/packages/server/src/setup/rumen/functions/rumen-tick/index.ts

@@ -20,7 +20,12 @@
 // @ts-ignore  Deno std import resolved at runtime.
 import { serve } from 'https://deno.land/std@0.224.0/http/server.ts';
 // @ts-ignore  npm specifier resolved at runtime.
-import { runRumenJob, createPoolFromUrl } from 'npm:@jhizzard/rumen@0.1.0';
+// NOTE: `__RUMEN_VERSION__` is a placeholder. `termdeck init --rumen` reads the
+// current published version from the npm registry at deploy time and rewrites
+// this line in a staged copy of the file before running `supabase functions
+// deploy`. This source file on disk MUST keep the placeholder — do not commit
+// a real version number here. See packages/cli/src/init-rumen.js.
+import { runRumenJob, createPoolFromUrl } from 'npm:@jhizzard/rumen@__RUMEN_VERSION__';
 
 // @ts-ignore  Deno global available at runtime.
 declare const Deno: { env: { get: (k: string) => string | undefined } };

package/packages/server/src/setup/rumen/migrations/001_rumen_tables.sql

@@ -1,9 +1,11 @@
--- Rumen v0.1 schema
--- Non-destructive: creates three new tables under the rumen_ namespace.
+-- Rumen schema — self-healing migration.
+-- Non-destructive: creates three new tables under the rumen_ namespace and
+-- brings any pre-existing tables (from partial prior installs) up to the
+-- current shape via ALTER TABLE ADD COLUMN IF NOT EXISTS.
 -- Does NOT modify or reference Mnestra's existing memory_items / memory_sessions tables.
 --
 -- Apply with:
---   psql "$DIRECT_URL" -f migrations/001_rumen_tables.sql
+--   psql "$DATABASE_URL" -f migrations/001_rumen_tables.sql
 
 BEGIN;
 
@@ -23,6 +25,21 @@ CREATE TABLE IF NOT EXISTS rumen_jobs (
   completed_at          TIMESTAMPTZ
 );
 
+-- Backfill columns for schema drift from earlier install attempts.
+-- CREATE TABLE IF NOT EXISTS is a no-op on existing tables, so without this
+-- block the subsequent CREATE INDEX statements would fail on columns that
+-- never got added.
+ALTER TABLE rumen_jobs
+  ADD COLUMN IF NOT EXISTS triggered_by         TEXT,
+  ADD COLUMN IF NOT EXISTS status               TEXT,
+  ADD COLUMN IF NOT EXISTS sessions_processed   INTEGER NOT NULL DEFAULT 0,
+  ADD COLUMN IF NOT EXISTS insights_generated   INTEGER NOT NULL DEFAULT 0,
+  ADD COLUMN IF NOT EXISTS questions_generated  INTEGER NOT NULL DEFAULT 0,
+  ADD COLUMN IF NOT EXISTS error_message        TEXT,
+  ADD COLUMN IF NOT EXISTS source_session_ids   UUID[] NOT NULL DEFAULT '{}',
+  ADD COLUMN IF NOT EXISTS started_at           TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  ADD COLUMN IF NOT EXISTS completed_at         TIMESTAMPTZ;
+
 CREATE INDEX IF NOT EXISTS idx_rumen_jobs_status
   ON rumen_jobs (status);
 
@@ -49,6 +66,15 @@ CREATE TABLE IF NOT EXISTS rumen_insights (
   created_at            TIMESTAMPTZ NOT NULL DEFAULT NOW()
 );
 
+ALTER TABLE rumen_insights
+  ADD COLUMN IF NOT EXISTS job_id               UUID,
+  ADD COLUMN IF NOT EXISTS source_memory_ids    UUID[] NOT NULL DEFAULT '{}',
+  ADD COLUMN IF NOT EXISTS projects             TEXT[] NOT NULL DEFAULT '{}',
+  ADD COLUMN IF NOT EXISTS insight_text         TEXT,
+  ADD COLUMN IF NOT EXISTS confidence           NUMERIC(4, 3) NOT NULL DEFAULT 0.000,
+  ADD COLUMN IF NOT EXISTS acted_upon           BOOLEAN NOT NULL DEFAULT FALSE,
+  ADD COLUMN IF NOT EXISTS created_at           TIMESTAMPTZ NOT NULL DEFAULT NOW();
+
 CREATE INDEX IF NOT EXISTS idx_rumen_insights_job_id
   ON rumen_insights (job_id);
 
@@ -78,6 +104,16 @@ CREATE TABLE IF NOT EXISTS rumen_questions (
   created_at            TIMESTAMPTZ NOT NULL DEFAULT NOW()
 );
 
+ALTER TABLE rumen_questions
+  ADD COLUMN IF NOT EXISTS job_id               UUID,
+  ADD COLUMN IF NOT EXISTS session_id           UUID,
+  ADD COLUMN IF NOT EXISTS question             TEXT,
+  ADD COLUMN IF NOT EXISTS context              TEXT,
+  ADD COLUMN IF NOT EXISTS asked_at             TIMESTAMPTZ,
+  ADD COLUMN IF NOT EXISTS answered_at          TIMESTAMPTZ,
+  ADD COLUMN IF NOT EXISTS answer               TEXT,
+  ADD COLUMN IF NOT EXISTS created_at           TIMESTAMPTZ NOT NULL DEFAULT NOW();
+
 CREATE INDEX IF NOT EXISTS idx_rumen_questions_job_id
   ON rumen_questions (job_id);