memhouse 0.0.1 → 0.3.1

package/editors/gsd.js

@@ -0,0 +1,366 @@
+const path = require('path');
+const fs = require('fs');
+
+const name = 'gsd';
+const labels = { gsd: 'GSD Workflow' };
+
+// ============================================================
+// Helpers
+// ============================================================
+
+function readFileSafe(filePath) {
+  try { return fs.readFileSync(filePath, 'utf-8'); } catch { return null; }
+}
+
+function statSafe(filePath) {
+  try { return fs.statSync(filePath); } catch { return null; }
+}
+
+function countFiles(dir) {
+  try { return fs.readdirSync(dir).filter(f => !f.startsWith('.')).length; } catch { return 0; }
+}
+
+/**
+ * Parse YAML frontmatter from STATE.md.
+ * Returns { status, milestone, stoppedAt, progress } or null.
+ */
+function parseStateMd(content) {
+  if (!content) return null;
+  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  const yaml = m[1];
+  function get(key) {
+    const r = yaml.match(new RegExp(`^${key}:\\s*(.+)`, 'm'));
+    return r ? r[1].trim().replace(/^["']|["']$/g, '') : null;
+  }
+  function getInt(key) { const v = get(key); return v ? parseInt(v) : null; }
+  const progressBlock = yaml.match(/^progress:\s*\n((?:[ \t]+.+\n?)*)/m);
+  let progress = null;
+  if (progressBlock) {
+    const pb = progressBlock[1];
+    function pgGet(key) {
+      const r = pb.match(new RegExp(`${key}:\\s*(\\d+)`));
+      return r ? parseInt(r[1]) : null;
+    }
+    progress = {
+      total_phases: pgGet('total_phases'),
+      completed_phases: pgGet('completed_phases'),
+      total_plans: pgGet('total_plans'),
+      completed_plans: pgGet('completed_plans'),
+    };
+  }
+  return {
+    status: get('status'),
+    milestone: get('milestone'),
+    stoppedAt: get('stopped_at'),
+    lastUpdated: get('last_updated'),
+    progress,
+  };
+}
+
+/**
+ * Parse ROADMAP.md phase checkboxes into a map of phase_number → completed.
+ * Phase lines look like: - [x] **Phase 1: Name** or - [ ] Phase 2: Name
+ */
+function parseRoadmapPhaseStatus(content) {
+  if (!content) return new Map();
+  const statusMap = new Map(); // phase_number (int) → 'completed' | 'planned'
+  for (const line of content.split('\n')) {
+    const cbMatch = line.match(/^[-*]\s+\[([x ])\]\s+(.+)/i);
+    if (!cbMatch) continue;
+    const text = cbMatch[2];
+    if (/\d+-\d+-PLAN\.md/i.test(text) || /PLAN\.md\s*[—–-]/i.test(text)) continue;
+    // Extract phase number from patterns: "Phase 1:", "Phase 01:", "**Phase 2:**"
+    const numMatch = text.match(/phase\s+(\d+)/i);
+    if (!numMatch) continue;
+    const num = parseInt(numMatch[1]);
+    if (!isNaN(num)) {
+      statusMap.set(num, cbMatch[1].toLowerCase() === 'x' ? 'completed' : 'planned');
+    }
+  }
+  return statusMap;
+}
+
+/**
+ * Parse PROJECT.md — first # heading = project name, rest = description.
+ */
+function parseProjectMd(content) {
+  if (!content) return { name: null, description: null };
+  const lines = content.split('\n');
+  let projectName = null;
+  const descLines = [];
+  for (const line of lines) {
+    const h1 = line.match(/^#\s+(.+)/);
+    if (h1 && !projectName) {
+      projectName = h1[1].trim();
+      continue;
+    }
+    if (projectName && line.trim()) descLines.push(line.trim());
+  }
+  return {
+    name: projectName,
+    description: descLines.slice(0, 3).join(' ').substring(0, 300) || null,
+  };
+}
+
+/**
+ * Parse ROADMAP.md for phase completion.
+ * Supports: - [ ] **Phase N: Name** ...  and  - [x] **Phase N: Name** ...
+ * Also supports emoji: ✅ completed, 🚧 in-progress, □ planned
+ */
+function parseRoadmapMd(content) {
+  if (!content) return [];
+  const phases = [];
+  for (const line of content.split('\n')) {
+    // Checkbox style: - [ ] or - [x]
+    // Only count lines that look like phase entries, NOT plan file listings (e.g. "01-01-PLAN.md")
+    const cbMatch = line.match(/^[-*]\s+\[([x ])\]\s+(.+)/i);
+    if (cbMatch) {
+      const text = cbMatch[2];
+      // Skip plan file entries like "01-01-PLAN.md — description"
+      if (/\d+-\d+-PLAN\.md/i.test(text) || /PLAN\.md\s*[—–-]/i.test(text)) continue;
+      phases.push({ text: text.replace(/\*\*/g, '').trim(), completed: cbMatch[1].toLowerCase() === 'x' });
+      continue;
+    }
+    // Emoji style: ✅ completed, 🚧 in-progress (milestone-level)
+    const emojiMatch = line.match(/^[-*]\s+(✅|🚧|⬜|□)\s+(.+)/);
+    if (emojiMatch) {
+      phases.push({ text: emojiMatch[2].replace(/\*\*/g, '').trim(), completed: emojiMatch[1] === '✅' });
+    }
+  }
+  return phases;
+}
+
+/**
+ * Detect the currently active milestone name from ROADMAP.md.
+ * Looks for 🚧 milestone entries or the first uncompleted milestone block.
+ */
+function detectActiveMilestone(content) {
+  if (!content) return null;
+  for (const line of content.split('\n')) {
+    const m = line.match(/🚧\s+\*?\*?([^*\n-]+)/);
+    if (m) return m[1].trim().split(' - ')[0].trim();
+    // Also handle "in progress" text
+    if (/in.progress/i.test(line)) {
+      const nm = line.match(/\*?\*?([vV][\d.]+[^*]*)\*?\*?/);
+      if (nm) return nm[1].trim();
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract phase number prefix from a phase directory name.
+ * e.g. "01-auth-ve-giris" → "01"
+ * e.g. "999.1-backlog-item" → "999.1"
+ */
+function extractPhasePrefix(dirName) {
+  const m = dirName.match(/^(\d+(?:\.\d+)?)-/);
+  return m ? m[1] : null;
+}
+
+/**
+ * Parse checkbox tasks from a PLAN.md file.
+ */
+function parseCheckboxes(content) {
+  if (!content) return { total: 0, completed: 0, tasks: [] };
+  const tasks = [];
+  for (const line of content.split('\n')) {
+    const m = line.match(/^[-*]\s+\[([x ])\]\s+(.+)/i);
+    if (!m) continue;
+    tasks.push({ name: m[2].trim(), completed: m[1].toLowerCase() === 'x' });
+  }
+  return { total: tasks.length, completed: tasks.filter(t => t.completed).length, tasks };
+}
+
+// ============================================================
+// Public API
+// ============================================================
+
+/**
+ * Scan known project folders for GSD .planning/ directories.
+ * Returns project-level summary for each GSD project found.
+ */
+function getGSDProjects(knownFolders) {
+  const results = [];
+
+  for (const folder of knownFolders) {
+    if (!folder) continue;
+    const planningDir = path.join(folder, '.planning');
+    if (!fs.existsSync(planningDir)) continue;
+
+    // Must have at least PROJECT.md or ROADMAP.md to be a GSD project
+    const hasProject = fs.existsSync(path.join(planningDir, 'PROJECT.md'));
+    const hasRoadmap = fs.existsSync(path.join(planningDir, 'ROADMAP.md'));
+    if (!hasProject && !hasRoadmap) continue;
+
+    const projectContent = readFileSafe(path.join(planningDir, 'PROJECT.md'));
+    const roadmapContent = readFileSafe(path.join(planningDir, 'ROADMAP.md'));
+    const stateContent = readFileSafe(path.join(planningDir, 'STATE.md'));
+    const stateData = parseStateMd(stateContent);
+
+    const { name: projectName, description } = parseProjectMd(projectContent);
+
+    // Use filesystem as source of truth for phase counts
+    // Filter out malformed directory names (e.g. dirs with JSON content in name)
+    const phases = getGSDPhases(folder, roadmapContent);
+    const validPhases = phases.filter(ph => ph.number !== null);
+
+    const totalPhases = validPhases.length;
+    const completedPhases = validPhases.filter(p => p.status === 'completed').length;
+    const firstIncomplete = validPhases.find(p => p.status !== 'completed');
+    const activePhase = stateData?.stoppedAt || (firstIncomplete ? firstIncomplete.name : null);
+
+    // Prefer STATE.md milestone, fallback to ROADMAP detection
+    const activeMilestone = stateData?.milestone || detectActiveMilestone(roadmapContent);
+
+    // Count todos/seeds/quick (common GSD directories)
+    const todos = countFiles(path.join(planningDir, 'todos'))
+      + countFiles(path.join(planningDir, 'seeds'));
+    const notes = countFiles(path.join(planningDir, 'quick'));
+    const backlog = countFiles(path.join(planningDir, 'backlog'));
+
+    const planStat = statSafe(planningDir);
+    const lastModified = planStat ? Math.round(planStat.mtimeMs) : null;
+
+    results.push({
+      folder,
+      name: projectName || path.basename(folder),
+      description,
+      milestone: activeMilestone,
+      totalPhases,
+      completedPhases,
+      activePhase,
+      todos,
+      backlog,
+      notes,
+      lastModified,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Return phase details for a single GSD project.
+ * Phases live in .planning/phases/<phaseDir>/
+ * roadmapContent is optionally passed to cross-reference checkbox status.
+ */
+function getGSDPhases(folder, roadmapContent) {
+  if (roadmapContent === undefined) {
+    roadmapContent = readFileSafe(path.join(folder, '.planning', 'ROADMAP.md'));
+  }
+  const roadmapStatus = parseRoadmapPhaseStatus(roadmapContent);
+  const phasesDir = path.join(folder, '.planning', 'phases');
+  let phaseDirs;
+  try {
+    phaseDirs = fs.readdirSync(phasesDir)
+      .filter(f => {
+        try { return fs.statSync(path.join(phasesDir, f)).isDirectory(); } catch { return false; }
+      })
+      .sort((a, b) => {
+        // Sort by numeric prefix (supports decimals like 999.1)
+        const na = parseFloat(extractPhasePrefix(a) || '9999');
+        const nb = parseFloat(extractPhasePrefix(b) || '9999');
+        return na - nb;
+      });
+  } catch { return []; }
+
+  const phases = [];
+  for (const phaseDir of phaseDirs) {
+    const phaseFullDir = path.join(phasesDir, phaseDir);
+    const prefix = extractPhasePrefix(phaseDir);
+
+    // Phase name: everything after the leading number prefix
+    const nameRaw = phaseDir.replace(/^\d+(?:\.\d+)?-/, '').replace(/-/g, ' ');
+    const phaseName = nameRaw.length > 0 ? nameRaw : phaseDir;
+
+    // Phase number (numeric value for display)
+    const phaseNumber = prefix ? parseFloat(prefix) : null;
+
+    // Detect artifact files using the phase prefix pattern
+    let hasPlan = false, hasResearch = false, hasVerification = false;
+    let planCount = 0, summaryCount = 0;
+    let latestMtime = 0;
+
+    try {
+      const files = fs.readdirSync(phaseFullDir);
+      for (const f of files) {
+        const fPath = path.join(phaseFullDir, f);
+        const st = statSafe(fPath);
+        if (st && st.mtimeMs > latestMtime) latestMtime = st.mtimeMs;
+
+        // PLAN files: {prefix}-{n}-PLAN.md
+        if (f.match(/PLAN\.md$/i)) { hasPlan = true; planCount++; }
+        // SUMMARY files: indicates a plan was executed
+        if (f.match(/SUMMARY\.md$/i)) summaryCount++;
+        // VERIFICATION
+        if (f.match(/VERIFICATION\.md$/i)) hasVerification = true;
+        // RESEARCH
+        if (f.match(/RESEARCH\.md$/i)) hasResearch = true;
+      }
+    } catch { /* skip */ }
+
+    // Determine status: file-based first, then cross-reference ROADMAP.md checkboxes
+    let status = 'planned';
+    if (hasVerification) {
+      status = 'completed';
+    } else if (roadmapStatus.get(phaseNumber) === 'completed') {
+      // ROADMAP.md marks this phase [x] even without VERIFICATION.md
+      status = 'completed';
+    } else if (summaryCount > 0) {
+      status = 'executing';
+    } else if (hasPlan) {
+      status = 'planned';
+    }
+
+    phases.push({
+      phaseDir,
+      number: phaseNumber,
+      name: phaseName,
+      status,
+      tasks: { total: planCount, completed: summaryCount },
+      hasVerification,
+      hasPlan,
+      hasResearch,
+      lastModified: latestMtime || null,
+    });
+  }
+
+  return phases;
+}
+
+/**
+ * Return combined PLAN.md content for a phase.
+ * Aggregates all *-PLAN.md files in order.
+ */
+function getGSDPlanDetail(folder, phaseDir) {
+  const phaseFullDir = path.join(folder, '.planning', 'phases', phaseDir);
+  if (!fs.existsSync(phaseFullDir)) return null;
+
+  let files;
+  try { files = fs.readdirSync(phaseFullDir).filter(f => f.match(/PLAN\.md$/i)).sort(); }
+  catch { return null; }
+  if (files.length === 0) return null;
+
+  const sections = [];
+  const allTasks = [];
+
+  for (const f of files) {
+    const content = readFileSafe(path.join(phaseFullDir, f));
+    if (!content) continue;
+    sections.push(`## ${f}\n\n${content}`);
+    const { tasks } = parseCheckboxes(content);
+    allTasks.push(...tasks);
+  }
+
+  return { content: sections.join('\n\n---\n\n'), tasks: allTasks };
+}
+
+module.exports = {
+  name,
+  labels,
+  getGSDProjects,
+  getGSDPhases,
+  getGSDPlanDetail,
+};

package/editors/index.js

@@ -0,0 +1,274 @@
+const cursor = require('./cursor');
+const devin = require('./windsurf');
+const antigravity = require('./antigravity');
+const claude = require('./claude');
+const vscode = require('./vscode');
+const zed = require('./zed');
+const opencode = require('./opencode');
+const codex = require('./codex');
+const gemini = require('./gemini');
+const copilot = require('./copilot');
+const copilotJetbrains = require('./copilot-jetbrains');
+const cursorAgent = require('./cursor-agent');
+const commandcode = require('./commandcode');
+const goose = require('./goose');
+const kiro = require('./kiro');
+const codebuff = require('./codebuff');
+const adapterErrorSink = require('./adapter-errors');
+
+const editors = [cursor, devin, antigravity, claude, vscode, zed, opencode, codex, gemini, copilot, copilotJetbrains, cursorAgent, commandcode, goose, kiro, codebuff];
+
+// Build a unified source → display-label map from all editor modules
+const editorLabels = {};
+for (const editor of editors) {
+  if (editor.labels) Object.assign(editorLabels, editor.labels);
+}
+
+// Per-adapter failures from the last getAllChats() pass. An adapter that throws is
+// skipped so one broken editor cannot take down a scan, but the failure is recorded
+// here rather than discarded: a missing better-sqlite3 native binding and an editor
+// the user simply does not have both produce zero sessions, and only this tells them
+// apart. See getAdapterErrors().
+let adapterErrors = [];
+
+// better-sqlite3 ships a prebuilt binary via an install script. npm >= 12 blocks
+// install scripts by default, so a plain `npm i -g memhouse` leaves no binding and
+// every SQLite-backed adapter reads zero sessions.
+const MISSING_BINDING = /Could not locate the bindings file|Cannot find module 'better-sqlite3'/;
+
+// Adapters that read sessions out of a SQLite store, so a dead binding costs
+// sessions. Membership is narrower than `grep -l better-sqlite3 editors/*.js`:
+// windsurf/devin also requires better-sqlite3, but only in getDevinApiKey() for
+// usage — its getChats() is pure language-server RPC, so its sessions survive a
+// broken binding and listing it here would raise a false alarm. antigravity is
+// listed because its *offline* chats come from SQLite, though its live cascades,
+// like devin's, come over RPC — a failure there is partial.
+// Held as module references, not strings, so the reported name always matches the
+// adapter's own `name`.
+const SQLITE_BACKED = [antigravity, cursor, goose, opencode, zed].map((m) => m.name);
+
+// Construct an in-memory database. Loading the module is not enough — better-sqlite3
+// resolves the native binding lazily, on first open.
+//
+// This only answers "can SQLite work at all". It deliberately cannot tell whether a
+// given editor's real store is readable: permissions, locking, corruption, and
+// SQLCipher all pass this probe and fail later. Those are reported by the adapters
+// themselves through adapter-errors.
+function probeSqlite() {
+  try {
+    const Database = require('better-sqlite3');
+    const db = new Database(':memory:');
+    db.close();
+    return { available: true };
+  } catch (e) {
+    const message = ((e && e.message) || String(e)).split('\n')[0];
+    return { available: false, message, missingBinding: MISSING_BINDING.test(message) };
+  }
+}
+
+// Cache only success. A failed probe must be retried: a long-running shipper daemon
+// that warned about a missing binding should notice once the user installs it,
+// rather than repeating the warning for the life of the process.
+let sqliteProbe = null;
+function sqliteStatus() {
+  if (sqliteProbe === null) {
+    const result = probeSqlite();
+    if (result.available) sqliteProbe = result;
+    return result;
+  }
+  return sqliteProbe;
+}
+
+/**
+ * Get all chats from all editor adapters, sorted by most recent first.
+ */
+function getAllChats() {
+  const chats = [];
+  adapterErrors = [];
+  adapterErrorSink.reset();
+  for (const editor of editors) {
+    try {
+      const editorChats = editor.getChats();
+      chats.push(...editorChats);
+    } catch (e) {
+      const message = (e && e.message) || String(e);
+      adapterErrors.push({
+        source: editor.name,
+        message: message.split('\n')[0],
+        missingBinding: MISSING_BINDING.test(message),
+      });
+    }
+  }
+
+  chats.sort((a, b) => {
+    const ta = a.lastUpdatedAt || a.createdAt || 0;
+    const tb = b.lastUpdatedAt || b.createdAt || 0;
+    return tb - ta;
+  });
+
+  return chats;
+}
+
+/**
+ * Adapters that could not report their sessions: [{ source, message, missingBinding }].
+ * Empty when every adapter ran clean.
+ *
+ * Two sources, because there are two ways an adapter goes quiet. One throws out of
+ * getChats() and is recorded during the pass. The other is a dead SQLite binding,
+ * which throws nowhere at all — the adapters catch it internally — so it is probed
+ * for directly and reported against every SQLite-backed adapter at once.
+ */
+function getAdapterErrors() {
+  const errors = adapterErrors.slice();
+  for (const e of adapterErrorSink.recorded()) {
+    errors.push({ source: e.source, message: e.message, detail: e.detail, missingBinding: MISSING_BINDING.test(e.message) });
+  }
+  const sqlite = sqliteStatus();
+  if (!sqlite.available) {
+    const already = new Set(errors.map((e) => e.source));
+    for (const source of SQLITE_BACKED) {
+      if (!already.has(source)) {
+        errors.push({ source, message: sqlite.message, missingBinding: sqlite.missingBinding });
+      }
+    }
+  }
+  // One line per adapter, not one per failed query — a broken store is usually hit
+  // many times in a single scan.
+  const bySource = new Map();
+  for (const e of errors) if (!bySource.has(e.source)) bySource.set(e.source, e);
+  return Array.from(bySource.values());
+}
+
+/**
+ * Get messages for a chat object, dispatching to the right editor adapter.
+ */
+function getMessages(chat) {
+  const editor = editors.find((e) => e.name === chat.source);
+  // Match variants: devin-next, antigravity, claude-code, vscode-insiders, plus legacy aliases.
+  const resolvedEditor = editor || editors.find((e) =>
+    chat.source && (
+      chat.source.startsWith(e.name) ||
+      (e.sources && e.sources.includes(chat.source)) ||
+      (e.legacySources && e.legacySources.includes(chat.source))
+    )
+  );
+  if (!resolvedEditor) return [];
+  return resolvedEditor.getMessages(chat);
+}
+
+function resetCaches() {
+  for (const editor of editors) {
+    if (typeof editor.resetCache === 'function') editor.resetCache();
+  }
+}
+
+/**
+ * Get usage / quota data from all editors that support it.
+ * Returns an array of usage objects, one per editor/variant.
+ */
+async function getAllUsage() {
+  const results = [];
+  for (const editor of editors) {
+    if (typeof editor.getUsage !== 'function') continue;
+    try {
+      const usage = await editor.getUsage();
+      if (!usage) continue;
+      // Devin returns an array (one per variant), Cursor returns a single object
+      if (Array.isArray(usage)) results.push(...usage);
+      else results.push(usage);
+    } catch { /* skip broken adapters */ }
+  }
+  return results;
+}
+
+/**
+ * Get all artifacts for a given project folder from all editors.
+ * Also scans for general/shared artifact files (plan.md, etc.).
+ */
+function getAllArtifacts(folder) {
+  const { scanArtifacts } = require('./base');
+  const artifacts = [];
+
+  // Collect from each editor that implements getArtifacts
+  for (const editor of editors) {
+    if (typeof editor.getArtifacts !== 'function') continue;
+    try {
+      artifacts.push(...editor.getArtifacts(folder));
+    } catch { /* skip broken adapters */ }
+  }
+
+  // General / shared artifact files (not tied to any specific editor)
+  if (folder) {
+    try {
+      artifacts.push(...scanArtifacts(folder, {
+        editor: '_general',
+        label: 'General',
+        files: ['AGENTS.md', '.mcp.json', 'plan.md', 'progress.md', 'TODO.md', 'CONVENTIONS.md', 'ARCHITECTURE.md', 'PLANNING.md'],
+        dirs: [],
+      }));
+    } catch { /* skip */ }
+  }
+
+  // Deduplicate by path — editor-specific entries take priority over general
+  const seen = new Map();
+  for (const a of artifacts) {
+    const existing = seen.get(a.path);
+    if (!existing || (existing.editor === '_general' && a.editor !== '_general')) {
+      seen.set(a.path, a);
+    }
+  }
+  return Array.from(seen.values());
+}
+
+/**
+ * Get all MCP servers from all editors.
+ * Also scans project folders for project-level MCP configs (.mcp.json, .cursor/mcp.json, etc.)
+ */
+function getAllMCPServers(projectFolders = []) {
+  const { parseMcpConfigFile } = require('./base');
+  const path = require('path');
+  const fs = require('fs');
+  const servers = [];
+
+  // 1. Collect global MCP servers from each editor
+  for (const editor of editors) {
+    if (typeof editor.getMCPServers !== 'function') continue;
+    try {
+      servers.push(...editor.getMCPServers());
+    } catch { /* skip broken adapters */ }
+  }
+
+  // 2. Scan project folders for project-level MCP configs
+  const projectConfigs = [
+    { file: '.mcp.json', editor: 'claude-code', label: 'Claude Code' },
+    { file: '.cursor/mcp.json', editor: 'cursor', label: 'Cursor' },
+    { file: '.vscode/mcp.json', editor: 'vscode', label: 'VS Code' },
+    { file: '.gemini/settings.json', editor: 'gemini-cli', label: 'Gemini CLI' },
+    { file: '.kiro/settings/mcp.json', editor: 'kiro', label: 'Kiro' },
+  ];
+
+  const seenProjects = new Set();
+  for (const folder of projectFolders) {
+    if (!folder || seenProjects.has(folder)) continue;
+    seenProjects.add(folder);
+    for (const pc of projectConfigs) {
+      const configPath = path.join(folder, pc.file);
+      if (!fs.existsSync(configPath)) continue;
+      const found = parseMcpConfigFile(configPath, { editor: pc.editor, label: pc.label, scope: 'project' });
+      for (const s of found) {
+        s.projectFolder = folder;
+      }
+      servers.push(...found);
+    }
+  }
+
+  // 3. Deduplicate by name+editor (keep first occurrence, prefer global over project)
+  const seen = new Map();
+  for (const s of servers) {
+    const key = `${s.name}::${s.editor}::${s.scope}`;
+    if (!seen.has(key)) seen.set(key, s);
+  }
+  return Array.from(seen.values());
+}
+
+module.exports = { getAllChats, getAdapterErrors, getMessages, editors, editorLabels, resetCaches, getAllUsage, getAllArtifacts, getAllMCPServers };