stenotype 0.1.1 → 0.3.0

package/dist/dashboard/server.mjs

@@ -0,0 +1,479 @@
+import express from 'express';
+import session from 'express-session';
+import bcrypt from 'bcryptjs';
+import keytar from 'keytar';
+import { DatabaseSync } from 'node:sqlite';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const SERVICE_NAME = 'stenotype-dashboard';
+const PORT = parseInt(process.env.DASHBOARD_PORT || '3737', 10);
+const HOST = '0.0.0.0';
+
+// Load credentials from OS keychain
+let USERNAME, PASSWORD_HASH, SESSION_SECRET;
+try {
+  [USERNAME, PASSWORD_HASH, SESSION_SECRET] = await Promise.all([
+    keytar.getPassword(SERVICE_NAME, 'username'),
+    keytar.getPassword(SERVICE_NAME, 'password_hash'),
+    keytar.getPassword(SERVICE_NAME, 'session_secret'),
+  ]);
+} catch (err) {
+  console.error('Failed to load dashboard credentials from keychain:', err.message);
+  process.exit(1);
+}
+
+if (!USERNAME || !PASSWORD_HASH || !SESSION_SECRET) {
+  console.error('\n  Dashboard credentials not configured.');
+  console.error('  Run: stenotype dashboard setup\n');
+  process.exit(1);
+}
+
+// Stenotype config paths
+const STENO_DIR = path.join(os.homedir(), '.stenotype');
+const CONFIG_PATH = path.join(STENO_DIR, 'stenotype.config.json');
+const LICENSE_PATH = path.join(STENO_DIR, 'license.key');
+
+// DB path
+const DB_PATH = path.join(os.homedir(), '.stenotype', 'memories.db');
+
+let db;
+try {
+  db = new DatabaseSync(DB_PATH);
+  console.log(`Connected to DB: ${DB_PATH}`);
+} catch (err) {
+  console.error(`Failed to open DB at ${DB_PATH}:`, err.message);
+  console.error('Server will start but API routes will fail until DB is available.');
+}
+
+const app = express();
+
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+app.use(
+  session({
+    secret: SESSION_SECRET,
+    resave: false,
+    saveUninitialized: false,
+    cookie: {
+      secure: false,
+      httpOnly: true,
+      maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days
+    },
+  })
+);
+
+// Serve static files
+app.use(express.static(path.join(__dirname, 'public')));
+
+// Root redirect
+app.get('/', (req, res) => {
+  res.redirect('/login.html');
+});
+
+// Auth routes (no auth required)
+app.post('/auth/login', (req, res) => {
+  const { username, password } = req.body;
+  if (!username || !password) {
+    return res.status(400).json({ error: 'Username and password required.' });
+  }
+  if (username !== USERNAME) {
+    return res.status(401).json({ error: 'Invalid credentials.' });
+  }
+  const valid = bcrypt.compareSync(password, PASSWORD_HASH);
+  if (!valid) {
+    return res.status(401).json({ error: 'Invalid credentials.' });
+  }
+  req.session.user = { username };
+  res.json({ ok: true, user: { username } });
+});
+
+app.post('/auth/logout', (req, res) => {
+  req.session.destroy(() => {
+    res.json({ ok: true });
+  });
+});
+
+app.get('/auth/me', (req, res) => {
+  if (req.session && req.session.user) {
+    return res.json({ user: req.session.user });
+  }
+  res.json({ user: null });
+});
+
+// Auth-only middleware (no db check) for setup/settings routes
+function requireAuth(req, res, next) {
+  if (!req.session || !req.session.user) {
+    return res.status(401).json({ error: 'Unauthorized.' });
+  }
+  next();
+}
+
+// GET /api/setup-status
+app.get('/api/setup-status', requireAuth, (req, res) => {
+  try {
+    if (!existsSync(CONFIG_PATH)) return res.json({ needsSetup: true });
+    const cfg = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+    res.json({ needsSetup: !cfg.setup_complete });
+  } catch {
+    res.json({ needsSetup: true });
+  }
+});
+
+// POST /api/setup
+app.post('/api/setup', requireAuth, (req, res) => {
+  try {
+    const { licenseKey, geminiApiKey, embeddingChoice, platform } = req.body;
+    if (!licenseKey || !geminiApiKey) {
+      return res.status(400).json({ error: 'License key and Gemini API key are required.' });
+    }
+    mkdirSync(STENO_DIR, { recursive: true });
+    writeFileSync(LICENSE_PATH, licenseKey, { mode: 0o600 });
+
+    let existing = {};
+    if (existsSync(CONFIG_PATH)) {
+      try { existing = JSON.parse(readFileSync(CONFIG_PATH, 'utf8')); } catch {}
+    }
+
+    const config = {
+      ...existing,
+      database: DB_PATH,
+      extractionProvider: 'openai',
+      extractionModel: 'gemini-2.5-flash-lite',
+      extractionApiKey: geminiApiKey,
+      extractionApiBase: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+      embeddingProvider: embeddingChoice || 'none',
+      embeddingModel: embeddingChoice === 'local' ? 'Qwen3-Embedding-0.6B-Q8_0' : '',
+      embeddingApiKey: '',
+      embeddingApiBase: '',
+      systemIntegration: platform || 'ductor',
+      logWatchPaths: [path.join(os.homedir(), '.claude', 'projects')],
+      ductorSessionsWatch: true,
+      setup_complete: true,
+    };
+
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// GET /api/settings
+app.get('/api/settings', requireAuth, (req, res) => {
+  try {
+    if (!existsSync(CONFIG_PATH)) return res.json({ settings: null });
+    const cfg = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+    const masked = cfg.extractionApiKey
+      ? '••••••••' + cfg.extractionApiKey.slice(-4)
+      : '';
+    res.json({
+      settings: {
+        geminiApiKeyMasked: masked,
+        embeddingProvider: cfg.embeddingProvider || 'none',
+        systemIntegration: cfg.systemIntegration || 'ductor',
+        extractionModel: cfg.extractionModel || 'gemini-2.5-flash-lite',
+      },
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// PUT /api/settings
+app.put('/api/settings', requireAuth, (req, res) => {
+  try {
+    let existing = {};
+    if (existsSync(CONFIG_PATH)) {
+      try { existing = JSON.parse(readFileSync(CONFIG_PATH, 'utf8')); } catch {}
+    }
+
+    const { geminiApiKey, embeddingProvider, systemIntegration } = req.body;
+    if (geminiApiKey && geminiApiKey.length >= 10) {
+      existing.extractionApiKey = geminiApiKey;
+    }
+    if (embeddingProvider) {
+      existing.embeddingProvider = embeddingProvider;
+      existing.embeddingModel = embeddingProvider === 'local' ? 'Qwen3-Embedding-0.6B-Q8_0' : '';
+    }
+    if (systemIntegration) {
+      existing.systemIntegration = systemIntegration;
+    }
+
+    writeFileSync(CONFIG_PATH, JSON.stringify(existing, null, 2));
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Auth middleware for /api routes
+app.use('/api', (req, res, next) => {
+  if (!req.session || !req.session.user) {
+    return res.status(401).json({ error: 'Unauthorized.' });
+  }
+  if (!db) {
+    return res.status(503).json({ error: 'Database not available.' });
+  }
+  next();
+});
+
+// GET /api/stats
+app.get('/api/stats', (req, res) => {
+  try {
+    const totalRow = db.prepare('SELECT COUNT(*) as count FROM memories').get();
+    const activeRow = db.prepare('SELECT COUNT(*) as count FROM memories WHERE is_active = 1').get();
+    const recentRow = db.prepare(
+      "SELECT COUNT(*) as count FROM memories WHERE is_active = 1 AND created_at >= datetime('now', '-7 days')"
+    ).get();
+
+    const byCategory = db
+      .prepare('SELECT category, COUNT(*) as count FROM memories WHERE is_active = 1 GROUP BY category ORDER BY count DESC')
+      .all();
+
+    const byTemperature = db
+      .prepare('SELECT temperature, COUNT(*) as count FROM memories WHERE is_active = 1 GROUP BY temperature ORDER BY count DESC')
+      .all();
+
+    const byAgent = db
+      .prepare('SELECT agent_id, COUNT(*) as count FROM memories WHERE is_active = 1 GROUP BY agent_id ORDER BY count DESC')
+      .all();
+
+    const archivedRow = db.prepare('SELECT COUNT(*) as count FROM memories WHERE is_active = 0').get();
+
+    res.json({
+      total: totalRow.count,
+      active: activeRow.count,
+      archived: archivedRow.count,
+      recentCount: recentRow.count,
+      byCategory,
+      byTemperature,
+      byAgent,
+    });
+  } catch (err) {
+    console.error('Stats error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// GET /api/memories
+app.get('/api/memories', (req, res) => {
+  try {
+    const { category, temperature, agent_id, page = 1, limit = 20, q, archived, date_from } = req.query;
+    const isArchived = archived === 'true';
+    const activeFilter = isArchived ? 0 : 1;
+    const offset = (parseInt(page) - 1) * parseInt(limit);
+    const lim = parseInt(limit);
+
+    const SELECT_COLS = `
+      m.id, m.category, m.content, m.subject, m.confidence, m.importance,
+      m.tags, m.source_channel, m.agent_id, m.temperature, m.created_at,
+      m.updated_at, m.is_active, m.access_count, m.last_accessed_at,
+      m.supersedes_id, m.superseded_by, m.extracted_by
+    `;
+
+    if (q && q.trim()) {
+      // FTS search
+      const searchTerm = q.trim();
+      let ftsQuery = `
+        SELECT ${SELECT_COLS}
+        FROM memories m
+        JOIN memories_fts fts ON m.id = fts.rowid
+        WHERE memories_fts MATCH ? AND m.is_active = ?
+      `;
+      const params = [searchTerm, activeFilter];
+
+      if (category && category !== 'all') {
+        ftsQuery += ` AND m.category = ?`;
+        params.push(category);
+      }
+      if (temperature && temperature !== 'all') {
+        ftsQuery += ` AND m.temperature = ?`;
+        params.push(temperature);
+      }
+      if (agent_id && agent_id !== 'all') {
+        ftsQuery += ` AND m.agent_id = ?`;
+        params.push(agent_id);
+      }
+      if (date_from) {
+        ftsQuery += ` AND m.created_at >= ?`;
+        params.push(date_from);
+      }
+
+      ftsQuery += ` ORDER BY rank LIMIT ? OFFSET ?`;
+      params.push(lim, offset);
+
+      let memories;
+      try {
+        memories = db.prepare(ftsQuery).all(...params);
+      } catch (ftsErr) {
+        // FTS table might not exist or rowid join might fail - fall back to LIKE search
+        console.warn('FTS search failed, falling back to LIKE:', ftsErr.message);
+        const likePattern = `%${searchTerm}%`;
+        let fallbackQuery = `
+          SELECT ${SELECT_COLS}
+          FROM memories m
+          WHERE m.is_active = ? AND (m.content LIKE ? OR m.subject LIKE ? OR m.tags LIKE ?)
+        `;
+        const fbParams = [activeFilter, likePattern, likePattern, likePattern];
+        if (category && category !== 'all') { fallbackQuery += ` AND m.category = ?`; fbParams.push(category); }
+        if (temperature && temperature !== 'all') { fallbackQuery += ` AND m.temperature = ?`; fbParams.push(temperature); }
+        if (agent_id && agent_id !== 'all') { fallbackQuery += ` AND m.agent_id = ?`; fbParams.push(agent_id); }
+        if (date_from) { fallbackQuery += ` AND m.created_at >= ?`; fbParams.push(date_from); }
+        fallbackQuery += ` ORDER BY m.created_at DESC LIMIT ? OFFSET ?`;
+        fbParams.push(lim, offset);
+        memories = db.prepare(fallbackQuery).all(...fbParams);
+      }
+
+      // Count for pagination
+      let countQuery = `
+        SELECT COUNT(*) as count
+        FROM memories m
+        WHERE m.is_active = ? AND (m.content LIKE ? OR m.subject LIKE ? OR m.tags LIKE ?)
+      `;
+      const likePattern = `%${searchTerm}%`;
+      const countParams = [activeFilter, likePattern, likePattern, likePattern];
+      if (category && category !== 'all') { countQuery += ` AND m.category = ?`; countParams.push(category); }
+      if (temperature && temperature !== 'all') { countQuery += ` AND m.temperature = ?`; countParams.push(temperature); }
+      if (agent_id && agent_id !== 'all') { countQuery += ` AND m.agent_id = ?`; countParams.push(agent_id); }
+      if (date_from) { countQuery += ` AND m.created_at >= ?`; countParams.push(date_from); }
+      const countRow = db.prepare(countQuery).get(...countParams);
+
+      return res.json({ memories, total: countRow.count, page: parseInt(page) });
+    }
+
+    // Regular filtered query
+    let query = `SELECT ${SELECT_COLS} FROM memories m WHERE m.is_active = ?`;
+    const params = [activeFilter];
+
+    if (category && category !== 'all') {
+      query += ` AND m.category = ?`;
+      params.push(category);
+    }
+    if (temperature && temperature !== 'all') {
+      query += ` AND m.temperature = ?`;
+      params.push(temperature);
+    }
+    if (agent_id && agent_id !== 'all') {
+      query += ` AND m.agent_id = ?`;
+      params.push(agent_id);
+    }
+    if (date_from) {
+      query += ` AND m.created_at >= ?`;
+      params.push(date_from);
+    }
+
+    query += ` ORDER BY m.created_at DESC LIMIT ? OFFSET ?`;
+    params.push(lim, offset);
+
+    const memories = db.prepare(query).all(...params);
+
+    // Count
+    let countQuery = `SELECT COUNT(*) as count FROM memories m WHERE m.is_active = ?`;
+    const countParams = [activeFilter];
+    if (category && category !== 'all') { countQuery += ` AND m.category = ?`; countParams.push(category); }
+    if (temperature && temperature !== 'all') { countQuery += ` AND m.temperature = ?`; countParams.push(temperature); }
+    if (agent_id && agent_id !== 'all') { countQuery += ` AND m.agent_id = ?`; countParams.push(agent_id); }
+    if (date_from) { countQuery += ` AND m.created_at >= ?`; countParams.push(date_from); }
+
+    const countRow = db.prepare(countQuery).get(...countParams);
+
+    res.json({ memories, total: countRow.count, page: parseInt(page) });
+  } catch (err) {
+    console.error('Memories error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// GET /api/memories/:id
+app.get('/api/memories/:id', (req, res) => {
+  try {
+    const memory = db.prepare(`
+      SELECT id, category, content, subject, confidence, importance,
+             tags, source_channel, agent_id, temperature, created_at,
+             updated_at, is_active, access_count, last_accessed_at,
+             supersedes_id, superseded_by, extracted_by
+      FROM memories WHERE id = ?
+    `).get(req.params.id);
+
+    if (!memory) {
+      return res.status(404).json({ error: 'Memory not found.' });
+    }
+    res.json(memory);
+  } catch (err) {
+    console.error('Get memory error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// DELETE /api/memories/:id (soft delete)
+app.delete('/api/memories/:id', (req, res) => {
+  try {
+    const result = db.prepare(
+      `UPDATE memories SET is_active = 0, updated_at = datetime('now') WHERE id = ?`
+    ).run(req.params.id);
+
+    if (result.changes === 0) {
+      return res.status(404).json({ error: 'Memory not found.' });
+    }
+    res.json({ ok: true });
+  } catch (err) {
+    console.error('Delete memory error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// PUT /api/memories/:id/restore
+app.put('/api/memories/:id/restore', (req, res) => {
+  try {
+    const result = db.prepare(
+      `UPDATE memories SET is_active = 1, temperature = 'hot',
+       last_accessed_at = datetime('now'), access_count = access_count + 1,
+       updated_at = datetime('now') WHERE id = ?`
+    ).run(req.params.id);
+    if (result.changes === 0) return res.status(404).json({ error: 'Memory not found.' });
+    res.json({ ok: true });
+  } catch (err) {
+    console.error('Restore error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// GET /api/pinned
+app.get('/api/pinned', (req, res) => {
+  try {
+    const pinned = db.prepare(`
+      SELECT id, memory_id, content, category, agent_id, created_at, updated_at
+      FROM pinned_memories
+      ORDER BY created_at DESC
+    `).all();
+    res.json({ pinned });
+  } catch (err) {
+    console.error('Pinned error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// GET /api/commitments
+app.get('/api/commitments', (req, res) => {
+  try {
+    const commitments = db.prepare(`
+      SELECT id, commitment, source, state, agent_id, created_at, updated_at
+      FROM commitment_ledger
+      ORDER BY created_at DESC
+    `).all();
+    res.json({ commitments });
+  } catch (err) {
+    console.error('Commitments error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+app.listen(PORT, HOST, () => {
+  console.log(`Stenotype Dashboard running at http://localhost:${PORT}`);
+});

package/package.json

@@ -1,62 +1,41 @@
 {
   "name": "stenotype",
-  "version": "0.1.1",
-  "description": "Automatic memory capture and recall for AI agent systems",
+  "version": "0.3.0",
+  "description": "Automatic memory capture and recall for AI agent workflows",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
   "bin": {
     "stenotype": "dist/index.cjs"
   },
   "files": [
     "dist/index.cjs",
-    "dist/stenotype.jsc"
+    "dist/stenotype.jsc",
+    "dist/dashboard"
   ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
   "scripts": {
     "build": "tsc",
     "build:protected": "node scripts/build-protected.mjs",
-    "start": "node dist/index.js",
-    "status": "node dist/index.js status",
-    "recall": "node dist/index.js recall",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:recall-harness": "vitest run tests/recall-harness.test.ts --reporter=verbose",
-    "typecheck": "tsc --noEmit",
-    "baseline:report": "node scripts/generate-baseline-report.mjs main ./artifacts/baseline",
-    "bench:local-vs-cloud": "node scripts/benchmark-local-vs-cloud.mjs --dataset ./bench/benchmark-dataset.json"
-  },
-  "openclaw": {
-    "extensions": [
-      "./index.ts"
-    ]
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "node scripts/preflight-publish.mjs"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@types/express": "^5.0.6",
-    "@types/pg": "^8.18.0",
-    "better-sqlite3": "^11.9.1",
-    "express": "^5.2.1",
-    "jose": "^6.2.3",
+    "@anthropic-ai/sdk": "^0.90.0",
+    "bcryptjs": "^2.4.3",
+    "bytenode": "^1.5.7",
+    "express": "^4.18.2",
+    "express-session": "^1.17.3",
     "keytar": "^7.9.0",
-    "node-llama-cpp": "^3.17.1",
-    "openai": "^4.80.0",
-    "pg": "^8.20.0",
-    "pgvector": "^0.2.1",
-    "prompts": "^2.4.2",
-    "bytenode": "^1.5.7"
+    "openai": "^4.78.1",
+    "sqlite-vec": "^0.1.7",
+    "sqlite-vec-linux-x64": "^0.1.7"
   },
   "devDependencies": {
-    "@sinclair/typebox": "^0.34.0",
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/keytar": "^4.4.0",
-    "@types/prompts": "^2.4.9",
-    "@types/supertest": "^7.2.0",
-    "bytenode": "^1.5.7",
-    "esbuild": "^0.28.0",
-    "supertest": "^7.2.2",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.24.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Stenotype contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-/**
- * Stenotype standalone entrypoint (post-OpenClaw port).
- *
- * The original OpenClaw plugin registration lives in index.openclaw.ts.archive
- * for reference. That file depended on `openclaw/plugin-sdk` and assumed an
- * in-process runtime. Ductor runs Stenotype out-of-process as a CLI, so this
- * file simply delegates to the subcommand dispatcher in src/cli.ts.
- */
-import "./src/cli.js";