@massu/core 0.1.0 → 0.1.2

package/src/server.ts

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * Massu MCP Server
+ *
+ * An MCP server that provides project-specific intelligence on top of
+ * vanilla CodeGraph. Communicates via JSON-RPC 2.0 over stdio.
+ *
+ * Tool names are configurable via massu.config.yaml toolPrefix.
+ */
+
+import { getCodeGraphDb, getDataDb } from './db.ts';
+import { getConfig } from './config.ts';
+import { getToolDefinitions, handleToolCall } from './tools.ts';
+import { getMemoryDb, pruneOldConversationTurns, pruneOldObservations } from './memory-db.ts';
+
+interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  id?: number | string;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: '2.0';
+  id: number | string | null;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+// Server state
+let codegraphDb: ReturnType<typeof getCodeGraphDb> | null = null;
+let dataDb: ReturnType<typeof getDataDb> | null = null;
+
+function getDb() {
+  if (!codegraphDb) codegraphDb = getCodeGraphDb();
+  if (!dataDb) dataDb = getDataDb();
+  return { codegraphDb, dataDb: dataDb };
+}
+
+function handleRequest(request: JsonRpcRequest): JsonRpcResponse {
+  const { method, params, id } = request;
+
+  switch (method) {
+    case 'initialize': {
+      return {
+        jsonrpc: '2.0',
+        id: id ?? null,
+        result: {
+          protocolVersion: '2024-11-05',
+          capabilities: {
+            tools: {},
+          },
+          serverInfo: {
+            name: 'massu',
+            version: '1.0.0',
+          },
+        },
+      };
+    }
+
+    case 'notifications/initialized': {
+      // Client acknowledges initialization - no response needed for notifications
+      return { jsonrpc: '2.0', id: id ?? null, result: {} };
+    }
+
+    case 'tools/list': {
+      const tools = getToolDefinitions();
+      return {
+        jsonrpc: '2.0',
+        id: id ?? null,
+        result: { tools },
+      };
+    }
+
+    case 'tools/call': {
+      const toolName = (params as { name: string })?.name;
+      const toolArgs = (params as { arguments?: Record<string, unknown> })?.arguments ?? {};
+
+      const { codegraphDb: cgDb, dataDb: lDb } = getDb();
+      const result = handleToolCall(toolName, toolArgs, lDb, cgDb);
+
+      return {
+        jsonrpc: '2.0',
+        id: id ?? null,
+        result,
+      };
+    }
+
+    case 'ping': {
+      return { jsonrpc: '2.0', id: id ?? null, result: {} };
+    }
+
+    default: {
+      return {
+        jsonrpc: '2.0',
+        id: id ?? null,
+        error: { code: -32601, message: `Method not found: ${method}` },
+      };
+    }
+  }
+}
+
+// === Startup: prune stale memory data (non-blocking) ===
+
+function pruneMemoryOnStartup(): void {
+  try {
+    const memDb = getMemoryDb();
+    try {
+      const turns = pruneOldConversationTurns(memDb, 7);
+      const obsDeleted = pruneOldObservations(memDb, 90);
+
+      const totalPruned = turns.turnsDeleted + turns.detailsDeleted + obsDeleted;
+      if (totalPruned > 0) {
+        process.stderr.write(
+          `massu: Pruned memory DB on startup — ` +
+          `${turns.turnsDeleted} conversation turns, ` +
+          `${turns.detailsDeleted} tool call details (>7d), ` +
+          `${obsDeleted} observations (>90d)\n`
+        );
+      }
+    } finally {
+      memDb.close();
+    }
+  } catch (error) {
+    process.stderr.write(
+      `massu: Memory pruning failed (non-fatal): ${error instanceof Error ? error.message : String(error)}\n`
+    );
+  }
+}
+
+pruneMemoryOnStartup();
+
+// === stdio JSON-RPC transport ===
+
+let buffer = '';
+
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk: string) => {
+  buffer += chunk;
+
+  // Process complete messages (newline-delimited JSON-RPC)
+  let newlineIndex: number;
+  while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+    const line = buffer.slice(0, newlineIndex).trim();
+    buffer = buffer.slice(newlineIndex + 1);
+
+    if (!line) continue;
+
+    try {
+      const request = JSON.parse(line) as JsonRpcRequest;
+      const response = handleRequest(request);
+
+      // Don't send responses for notifications (no id)
+      if (request.id !== undefined) {
+        const responseStr = JSON.stringify(response);
+        process.stdout.write(responseStr + '\n');
+      }
+    } catch (error) {
+      const errorResponse: JsonRpcResponse = {
+        jsonrpc: '2.0',
+        id: null,
+        error: {
+          code: -32700,
+          message: `Parse error: ${error instanceof Error ? error.message : String(error)}`,
+        },
+      };
+      process.stdout.write(JSON.stringify(errorResponse) + '\n');
+    }
+  }
+});
+
+process.stdin.on('end', () => {
+  // Clean up database connections
+  if (codegraphDb) codegraphDb.close();
+  if (dataDb) dataDb.close();
+  process.exit(0);
+});
+
+// Handle errors gracefully
+process.on('uncaughtException', (error) => {
+  process.stderr.write(`massu: Uncaught exception: ${error.message}\n`);
+});
+
+process.on('unhandledRejection', (reason) => {
+  process.stderr.write(`massu: Unhandled rejection: ${reason}\n`);
+});

package/src/session-archiver.ts

@@ -0,0 +1,112 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'fs';
+import { resolve, dirname } from 'path';
+import type Database from 'better-sqlite3';
+import { generateCurrentMd } from './session-state-generator.ts';
+import { getProjectRoot } from './config.ts';
+
+// ============================================================
+// P5-002: Session Archiver
+// ============================================================
+
+const PROJECT_ROOT = getProjectRoot();
+
+/**
+ * Archive the current CURRENT.md and generate a new one from memory DB.
+ */
+export function archiveAndRegenerate(db: Database.Database, sessionId: string): {
+  archived: boolean;
+  archivePath?: string;
+  newContent: string;
+} {
+  const currentMdPath = resolve(PROJECT_ROOT, '.claude/session-state/CURRENT.md');
+  const archiveDir = resolve(PROJECT_ROOT, '.claude/session-state/archive');
+  let archived = false;
+  let archivePath: string | undefined;
+
+  // 1. Archive existing CURRENT.md if it exists and has content
+  if (existsSync(currentMdPath)) {
+    const existingContent = readFileSync(currentMdPath, 'utf-8');
+    if (existingContent.trim().length > 10) {
+      // Extract date and task description for filename
+      const { date, slug } = extractArchiveInfo(existingContent);
+      archivePath = resolve(archiveDir, `${date}-${slug}.md`);
+
+      // Ensure archive directory exists
+      if (!existsSync(archiveDir)) {
+        mkdirSync(archiveDir, { recursive: true });
+      }
+
+      // Move to archive (rename is atomic on same filesystem)
+      try {
+        renameSync(currentMdPath, archivePath);
+        archived = true;
+      } catch (_e) {
+        // If rename fails (cross-device), copy+delete
+        writeFileSync(archivePath, existingContent);
+        archived = true;
+      }
+    }
+  }
+
+  // 2. Generate new CURRENT.md from memory DB
+  const newContent = generateCurrentMd(db, sessionId);
+
+  // 3. Write new CURRENT.md
+  const dir = dirname(currentMdPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(currentMdPath, newContent, 'utf-8');
+
+  return { archived, archivePath, newContent };
+}
+
+/**
+ * Extract date and slug from existing CURRENT.md content for archive naming.
+ */
+function extractArchiveInfo(content: string): { date: string; slug: string } {
+  // Try to extract date from "# Session State - January 30, 2026"
+  const dateMatch = content.match(/# Session State - (\w+ \d+, \d+)/);
+  let date = new Date().toISOString().split('T')[0]; // fallback
+
+  if (dateMatch) {
+    const parsed = new Date(dateMatch[1]);
+    if (!isNaN(parsed.getTime())) {
+      date = parsed.toISOString().split('T')[0];
+    }
+  }
+
+  // Also try ISO date format "**Last Updated**: 2026-01-30"
+  const isoMatch = content.match(/(\d{4}-\d{2}-\d{2})/);
+  if (isoMatch) {
+    date = isoMatch[1];
+  }
+
+  // Extract task description for slug
+  let slug = 'session';
+  const taskMatch = content.match(/\*\*Task\*\*:\s*(.+)/);
+  if (taskMatch) {
+    slug = taskMatch[1]
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-|-$/g, '')
+      .slice(0, 50);
+  }
+
+  // Extract status for slug if no task
+  if (slug === 'session') {
+    const statusMatch = content.match(/\*\*Status\*\*:\s*\w+\s*-\s*(.+)/);
+    if (statusMatch) {
+      slug = statusMatch[1]
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 50);
+    }
+  }
+
+  return { date, slug };
+}

package/src/session-state-generator.ts

@@ -0,0 +1,174 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+import type Database from 'better-sqlite3';
+
+// ============================================================
+// P5-001: CURRENT.md Generator
+// ============================================================
+
+/**
+ * Generate CURRENT.md content from memory database.
+ * Replaces manual session state maintenance.
+ */
+export function generateCurrentMd(db: Database.Database, sessionId: string): string {
+  const session = db.prepare('SELECT * FROM sessions WHERE session_id = ?').get(sessionId) as Record<string, unknown> | undefined;
+  if (!session) return '# Session State\n\nNo active session found.\n';
+
+  const observations = db.prepare(
+    'SELECT * FROM observations WHERE session_id = ? ORDER BY created_at_epoch ASC'
+  ).all(sessionId) as Array<Record<string, unknown>>;
+
+  const summary = db.prepare(
+    'SELECT * FROM session_summaries WHERE session_id = ? ORDER BY created_at_epoch DESC LIMIT 1'
+  ).get(sessionId) as Record<string, unknown> | undefined;
+
+  const prompts = db.prepare(
+    'SELECT prompt_text FROM user_prompts WHERE session_id = ? ORDER BY prompt_number ASC LIMIT 1'
+  ).all(sessionId) as Array<{ prompt_text: string }>;
+
+  const date = new Date().toISOString().split('T')[0];
+  const firstPrompt = prompts[0]?.prompt_text ?? 'Unknown task';
+  const taskSummary = firstPrompt.slice(0, 100).replace(/\n/g, ' ');
+
+  const lines: string[] = [];
+  lines.push(`# Session State - ${formatDate(date)}`);
+  lines.push('');
+  lines.push(`**Last Updated**: ${new Date().toISOString().replace('T', ' ').slice(0, 19)} (auto-generated from massu-memory)`);
+  lines.push(`**Status**: ${session.status === 'active' ? 'IN PROGRESS' : (session.status as string).toUpperCase()} - ${taskSummary}`);
+  lines.push(`**Task**: ${taskSummary}`);
+  lines.push(`**Session ID**: ${sessionId}`);
+  lines.push(`**Branch**: ${session.git_branch ?? 'unknown'}`);
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  // Completed work
+  const completedObs = observations.filter(o =>
+    ['feature', 'bugfix', 'refactor', 'file_change'].includes(o.type as string)
+  );
+  if (completedObs.length > 0 || summary) {
+    lines.push('## COMPLETED WORK');
+    lines.push('');
+
+    if (summary?.completed) {
+      lines.push(summary.completed as string);
+      lines.push('');
+    }
+
+    // Files created
+    const filesCreated = observations
+      .filter(o => o.type === 'file_change' && (o.title as string).startsWith('Created'))
+      .map(o => {
+        const files = safeParseJson(o.files_involved as string, []) as string[];
+        return files[0] ?? (o.title as string).replace('Created/wrote: ', '');
+      });
+
+    if (filesCreated.length > 0) {
+      lines.push('### Files Created');
+      lines.push('');
+      lines.push('| File | Purpose |');
+      lines.push('|------|---------|');
+      for (const f of filesCreated) {
+        lines.push(`| \`${f}\` | |`);
+      }
+      lines.push('');
+    }
+
+    // Files modified
+    const filesModified = observations
+      .filter(o => o.type === 'file_change' && (o.title as string).startsWith('Edited'))
+      .map(o => {
+        const files = safeParseJson(o.files_involved as string, []) as string[];
+        return files[0] ?? (o.title as string).replace('Edited: ', '');
+      });
+
+    if (filesModified.length > 0) {
+      lines.push('### Files Modified');
+      lines.push('');
+      lines.push('| File | Change |');
+      lines.push('|------|--------|');
+      for (const f of [...new Set(filesModified)]) {
+        lines.push(`| \`${f}\` | |`);
+      }
+      lines.push('');
+    }
+  }
+
+  // Key decisions
+  const decisions = observations.filter(o => o.type === 'decision');
+  if (decisions.length > 0) {
+    lines.push('### Key Decisions');
+    lines.push('');
+    for (const d of decisions) {
+      lines.push(`- ${d.title}`);
+    }
+    lines.push('');
+  }
+
+  // Failed attempts
+  const failures = observations.filter(o => o.type === 'failed_attempt');
+  if (failures.length > 0) {
+    lines.push('## FAILED ATTEMPTS (DO NOT RETRY)');
+    lines.push('');
+    for (const f of failures) {
+      lines.push(`- ${f.title}`);
+      if (f.detail) lines.push(`  ${(f.detail as string).slice(0, 200)}`);
+    }
+    lines.push('');
+  }
+
+  // Verification evidence
+  const vrChecks = observations.filter(o => o.type === 'vr_check');
+  if (vrChecks.length > 0) {
+    lines.push('## VERIFICATION EVIDENCE');
+    lines.push('');
+    for (const v of vrChecks) {
+      lines.push(`- ${v.title}`);
+    }
+    lines.push('');
+  }
+
+  // Pending / next steps
+  if (summary?.next_steps) {
+    lines.push('## PENDING');
+    lines.push('');
+    lines.push(summary.next_steps as string);
+    lines.push('');
+  }
+
+  // Plan document
+  if (session.plan_file) {
+    lines.push('## PLAN DOCUMENT');
+    lines.push('');
+    lines.push(`\`${session.plan_file}\``);
+
+    // Show plan progress if available
+    if (summary?.plan_progress) {
+      const progress = safeParseJson(summary.plan_progress as string, {}) as Record<string, string>;
+      const total = Object.keys(progress).length;
+      const complete = Object.values(progress).filter(v => v === 'complete').length;
+      if (total > 0) {
+        lines.push(`- Progress: ${complete}/${total} items complete`);
+      }
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+function formatDate(dateStr: string): string {
+  const months = ['January', 'February', 'March', 'April', 'May', 'June',
+    'July', 'August', 'September', 'October', 'November', 'December'];
+  const [year, month, day] = dateStr.split('-').map(Number);
+  return `${months[month - 1]} ${day}, ${year}`;
+}
+
+function safeParseJson(json: string, fallback: unknown): unknown {
+  try {
+    return JSON.parse(json);
+  } catch (_e) {
+    return fallback;
+  }
+}