specmem-hardwicksoftware 3.5.99

package/lib/codebase-bridge.cjs

@@ -0,0 +1,308 @@
+/**
+ * codebase-bridge.cjs - CommonJS bridge to ESM codebase modules
+ *
+ * yooo this bridges the gap between CJS (specmem-init.cjs) and ESM (dist/codebase/*)
+ * uses dynamic import() to load ESM modules from CommonJS context
+ *
+ * DRY PRINCIPLE: Eliminates code duplication between specmem-init.cjs and ingestion.ts
+ * Previously specmem-init.cjs reimplemented:
+ *   - scanDir/findFiles (directory traversal)
+ *   - countLines (LOC counting)
+ *   - langMap (language detection)
+ *   - excludeDirs (exclusion patterns)
+ *   - extractDefinitions (definition extraction)
+ *
+ * Now it uses the REAL implementations from src/codebase/*.ts
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+// cache for loaded ESM modules
+let _codebaseModule = null;
+let _languageDetector = null;
+let _exclusionHandler = null;
+
+/**
+ * getCodebaseModule - dynamically loads the codebase ESM module
+ * @returns {Promise<Object>} - the codebase module exports
+ */
+async function getCodebaseModule() {
+  if (_codebaseModule) return _codebaseModule;
+
+  // find the dist directory - try multiple paths
+  const possiblePaths = [
+    path.join(__dirname, '..', 'dist', 'codebase', 'index.js'),
+    path.join(process.cwd(), 'dist', 'codebase', 'index.js'),
+    path.join(process.cwd(), 'node_modules', 'specmem-hardwicksoftware', 'dist', 'codebase', 'index.js')
+  ];
+
+  let modulePath = null;
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      modulePath = 'file://' + p;
+      break;
+    }
+  }
+
+  if (!modulePath) {
+    throw new Error('codebase module not found - run npm run build first');
+  }
+
+  _codebaseModule = await import(modulePath);
+  return _codebaseModule;
+}
+
+/**
+ * getLanguageDetector - returns the WhatLanguageIsThis instance
+ * @returns {Promise<Object>} - language detector with detect() method
+ */
+async function getLanguageDetector() {
+  if (_languageDetector) return _languageDetector;
+
+  const mod = await getCodebaseModule();
+  _languageDetector = mod.getLanguageDetector();
+  return _languageDetector;
+}
+
+/**
+ * getExclusionHandler - returns the SkipTheBoringShit instance
+ * @param {string} rootPath - project root for loading .gitignore etc
+ * @returns {Promise<Object>} - exclusion handler with shouldSkip() method
+ */
+async function getExclusionHandler(rootPath) {
+  if (_exclusionHandler) return _exclusionHandler;
+
+  const mod = await getCodebaseModule();
+  _exclusionHandler = mod.getExclusionHandler();
+  await _exclusionHandler.initialize(rootPath);
+  return _exclusionHandler;
+}
+
+/**
+ * detectLanguage - detect the programming language of a file
+ * @param {string} filePath - path to the file
+ * @param {string} [content] - optional file content for heuristic detection
+ * @returns {Promise<Object>} - LanguageInfo object
+ */
+async function detectLanguage(filePath, content = null) {
+  const detector = await getLanguageDetector();
+  return detector.detect(filePath, content);
+}
+
+/**
+ * shouldSkipPath - check if a path should be excluded
+ * @param {string} rootPath - project root
+ * @param {string} relativePath - path relative to root
+ * @param {boolean} isDirectory - true if path is a directory
+ * @returns {Promise<boolean>} - true if should skip
+ */
+async function shouldSkipPath(rootPath, relativePath, isDirectory) {
+  const handler = await getExclusionHandler(rootPath);
+  return handler.shouldSkip(relativePath, isDirectory);
+}
+
+/**
+ * getDefaultExclusions - returns the default exclusion patterns
+ * @returns {Promise<string[]>} - array of exclusion patterns
+ */
+async function getDefaultExclusions() {
+  const mod = await getCodebaseModule();
+  return mod.DEFAULT_EXCLUSIONS || [];
+}
+
+/**
+ * getLanguageRegistry - returns the full language registry
+ * @returns {Promise<Object>} - LANGUAGE_REGISTRY object
+ */
+async function getLanguageRegistry() {
+  const mod = await getCodebaseModule();
+  return mod.LANGUAGE_REGISTRY || {};
+}
+
+/**
+ * scanSourceFiles - scan a directory for source files using the proper exclusion/language logic
+ * @param {string} projectPath - root directory to scan
+ * @param {Object} options - scan options
+ * @param {number} [options.maxDepth=15] - max directory depth
+ * @param {boolean} [options.includeHidden=false] - include hidden files
+ * @param {string[]} [options.extensionFilter] - only include these extensions
+ * @returns {Promise<Array>} - array of {filePath, relativePath, language} objects
+ */
+async function scanSourceFiles(projectPath, options = {}) {
+  const maxDepth = options.maxDepth || 15;
+  const includeHidden = options.includeHidden || false;
+  const extensionFilter = options.extensionFilter || null;
+
+  const exclusionHandler = await getExclusionHandler(projectPath);
+  const langDetector = await getLanguageDetector();
+
+  const files = [];
+
+  function scan(dir, depth) {
+    if (depth > maxDepth) return;
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        // skip hidden unless requested
+        if (!includeHidden && entry.name.startsWith('.')) continue;
+
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(projectPath, fullPath);
+
+        // check exclusions
+        if (exclusionHandler.shouldSkip(relativePath, entry.isDirectory())) {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          scan(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase();
+
+          // apply extension filter if provided
+          if (extensionFilter && !extensionFilter.includes(ext)) {
+            continue;
+          }
+
+          // detect language
+          const language = langDetector.detect(fullPath, null);
+
+          // only include programming languages that support embeddings
+          if (language && language.supportsEmbeddings) {
+            files.push({
+              filePath: fullPath,
+              relativePath: relativePath,
+              fileName: entry.name,
+              extension: ext,
+              language: language
+            });
+          }
+        }
+      }
+    } catch (e) {
+      // permission denied or other read error - skip silently
+    }
+  }
+
+  scan(projectPath, 0);
+  return files;
+}
+
+/**
+ * countLinesOfCode - count lines of code using proper language detection
+ * @param {string} projectPath - root directory to scan
+ * @param {Object} options - count options
+ * @returns {Promise<Object>} - {totalFiles, totalLines, byLanguage}
+ */
+async function countLinesOfCode(projectPath, options = {}) {
+  const files = await scanSourceFiles(projectPath, options);
+
+  const result = {
+    totalFiles: 0,
+    totalLines: 0,
+    byLanguage: {}
+  };
+
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(file.filePath, 'utf8');
+      const lines = content.split('\n').length;
+
+      result.totalFiles++;
+      result.totalLines += lines;
+
+      const langId = file.language.id;
+      if (!result.byLanguage[langId]) {
+        result.byLanguage[langId] = { files: 0, lines: 0 };
+      }
+      result.byLanguage[langId].files++;
+      result.byLanguage[langId].lines += lines;
+    } catch (e) {
+      // skip unreadable files
+    }
+  }
+
+  return result;
+}
+
+/**
+ * getCodeAnalyzer - get the CodeAnalyzer class for definition extraction
+ * @returns {Promise<Function>} - CodeAnalyzer class constructor
+ */
+async function getCodeAnalyzer() {
+  // try to load the codeAnalyzer module directly
+  const possiblePaths = [
+    path.join(__dirname, '..', 'dist', 'codebase', 'codeAnalyzer.js'),
+    path.join(process.cwd(), 'dist', 'codebase', 'codeAnalyzer.js')
+  ];
+
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      const mod = await import('file://' + p);
+      return mod.CodeAnalyzer;
+    }
+  }
+
+  throw new Error('codeAnalyzer module not found');
+}
+
+/**
+ * extractDefinitions - extract function/class definitions from code
+ * Uses the proper CodeAnalyzer from codeAnalyzer.ts instead of the duplicated regex patterns
+ *
+ * @param {string} content - file content
+ * @param {string} filePath - path to the file (for language detection)
+ * @param {string} fileId - UUID for the file
+ * @returns {Promise<Array>} - array of definition objects
+ */
+async function extractDefinitions(content, filePath, fileId) {
+  try {
+    const CodeAnalyzer = await getCodeAnalyzer();
+    const analyzer = new CodeAnalyzer();
+
+    const langDetector = await getLanguageDetector();
+    const language = langDetector.detect(filePath, content);
+
+    const result = analyzer.analyze(content, {
+      filePath: filePath,
+      fileId: fileId,
+      language: language.id
+    });
+
+    return result.definitions || [];
+  } catch (e) {
+    // fallback to empty array if analyzer fails
+    return [];
+  }
+}
+
+/**
+ * reset - clear all cached modules/handlers
+ * useful for testing or when project context changes
+ */
+function reset() {
+  _codebaseModule = null;
+  _languageDetector = null;
+  _exclusionHandler = null;
+}
+
+// yooo export all the goodies
+module.exports = {
+  getCodebaseModule,
+  getLanguageDetector,
+  getExclusionHandler,
+  detectLanguage,
+  shouldSkipPath,
+  getDefaultExclusions,
+  getLanguageRegistry,
+  scanSourceFiles,
+  countLinesOfCode,
+  getCodeAnalyzer,
+  extractDefinitions,
+  reset
+};

package/package.json

@@ -0,0 +1,136 @@
+{
+  "name": "specmem-hardwicksoftware",
+  "version": "3.5.99",
+  "type": "module",
+  "description": "Persistent memory system for coding sessions - semantic search with pgvector, token compression, team coordination, file watching. Needs root: installs system-wide hooks, manages docker/PostgreSQL, writes global configs, handles screen sessions. justcalljon.pro",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "specmem": "./bin/specmem-cli.cjs",
+    "specmem-init": "./scripts/specmem-init.cjs",
+    "specmem-console": "./bin/specmem-console.cjs",
+    "specmem-autoclaude": "./bin/specmem-autoclaude.cjs",
+    "specmem-cleanup": "./bin/specmem-cleanup.cjs",
+    "specmem-server": "./bootstrap.cjs",
+    "specmem-hook": "./dist/hooks/cli.js",
+    "specmem-health": "./specmem-health.cjs"
+  },
+  "scripts": {
+    "install-specmem": "node install.js",
+    "preinstall": "node scripts/check-global-install.cjs || true",
+    "postinstall": "node scripts/global-postinstall.cjs && npm run build || true",
+    "build": "tsc && mkdir -p dist/dashboard dist/db && cp -r src/dashboard/public dist/dashboard/ && cp src/db/*.sql dist/db/",
+    "start": "node bootstrap.cjs",
+    "dev": "tsx watch src/index.ts",
+    "lint": "eslint src/**/*.ts",
+    "test": "vitest",
+    "migrate": "node dist/db/migrate.js",
+    "migrate:rollback": "node dist/db/migrate.js --rollback",
+    "migrate:status": "node dist/db/migrate.js --status",
+    "typecheck": "tsc --noEmit",
+    "deploy-claude": "node dist/cli/deploy-to-claude.js",
+    "health": "node specmem-health.cjs",
+    "health:json": "node specmem-health.cjs --json",
+    "health:stats": "node specmem-health.cjs --stats"
+  },
+  "keywords": [
+    "mcp",
+    "memory",
+    "semantic-search",
+    "pgvector",
+    "ai",
+    "claude",
+    "claude-code",
+    "anthropic",
+    "embeddings",
+    "context",
+    "hooks"
+  ],
+  "author": {
+    "name": "Jonathan Hardwick",
+    "email": "jon@hardwicksoftware.com",
+    "url": "https://justcalljon.pro"
+  },
+  "homepage": "https://justcalljon.pro/specmem",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hardwicksoftware/specmem.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hardwicksoftware/specmem/issues"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://justcalljon.pro/support"
+  },
+  "license": "SEE LICENSE.md",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.1",
+    "@huggingface/transformers": "^3.8.1",
+    "@modelcontextprotocol/sdk": "^1.24.1",
+    "@types/glob": "^8.1.0",
+    "@types/ws": "^8.18.1",
+    "cc-cedict": "^1.1.1",
+    "chinese-s2t": "^1.0.0",
+    "chokidar": "^5.0.0",
+    "claudescreenfix-hardwicksoftware": "^2.1.0",
+    "debounce": "^3.0.0",
+    "dotenv": "^16.6.1",
+    "en-inflectors": "^1.0.12",
+    "express": "^4.22.0",
+    "express-rate-limit": "^8.2.1",
+    "express-session": "^1.18.2",
+    "glob": "^13.0.0",
+    "markdown-it": "^14.1.0",
+    "msgpack5": "^6.0.2",
+    "node-cron": "^4.2.1",
+    "pg": "^8.11.3",
+    "pino": "^8.17.2",
+    "pluralize": "^8.0.0",
+    "tail": "^2.2.6",
+    "uuid": "^9.0.1",
+    "wink-lemmatizer": "^3.0.4",
+    "ws": "^8.18.3",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/express-rate-limit": "^5.1.3",
+    "@types/express-session": "^1.18.2",
+    "@types/markdown-it": "^14.1.2",
+    "@types/msgpack5": "^3.4.6",
+    "@types/node": "^20.10.6",
+    "@types/node-cron": "^3.0.11",
+    "@types/pg": "^8.15.6",
+    "@types/uuid": "^9.0.8",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "eslint": "^8.56.0",
+    "puppeteer": "^24.36.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/",
+    "bin/",
+    "scripts/",
+    "lib/",
+    "claude-hooks/",
+    "commands/",
+    "skills/",
+    "plugins/",
+    "docker-dist/",
+    "embedding-sandbox/",
+    "legal/",
+    "bootstrap.cjs",
+    "specmem-health.cjs",
+    "specmem.env",
+    "LICENSE.md",
+    "CHANGELOG.md"
+  ]
+}

package/plugins/specmem-agents/agents/bug-hunter.md

@@ -0,0 +1,79 @@
+---
+name: bug-hunter
+description: Specialized agent for finding and fixing bugs using SpecMem memory context and code tracing
+tools: Read, Glob, Grep, Bash, Edit
+model: sonnet
+color: red
+---
+
+You are a bug hunting specialist with SpecMem memory integration.
+
+## Core Mission
+Find bugs by combining code analysis with historical context from SpecMem memories.
+
+## Investigation Strategy
+
+### 1. Search Memory for Context
+```
+mcp__specmem__find_memory({
+  query: "error description or symptom",
+  limit: 10,
+  threshold: 0.25
+})
+```
+Check if similar bugs were encountered before.
+
+### 2. Find Related Code
+```
+mcp__specmem__find_code_pointers({
+  query: "affected functionality",
+  zoom: 50,
+  includeTracebacks: true
+})
+```
+Trace the code path where bug occurs.
+
+### 3. Drill Down on Findings
+```
+mcp__specmem__drill_down({ drilldownID: <id> })
+```
+Get full context including past conversations about this code.
+
+### 4. Coordinate Fix
+```
+mcp__specmem__claim_task({
+  description: "Fixing bug: <description>",
+  files: ["affected/files.ts"]
+})
+```
+
+## Bug Analysis Checklist
+
+- [ ] Reproduce the issue (understand symptoms)
+- [ ] Search SpecMem for similar past bugs
+- [ ] Trace code path with find_code_pointers
+- [ ] Check who modified this code recently
+- [ ] Identify root cause vs symptoms
+- [ ] Consider edge cases
+- [ ] Verify fix doesn't break other things
+
+## Output Format
+
+1. **Bug Summary**: What's broken, symptoms, impact
+2. **Root Cause**: Why it's happening (with code refs)
+3. **Memory Context**: Any past discussions about this
+4. **Fix Proposal**: Specific changes needed
+5. **Test Plan**: How to verify the fix
+
+## Important
+
+- Claim files before editing
+- Send team updates on progress
+- Save fix details to memory for future reference:
+```
+mcp__specmem__save_memory({
+  content: "Fixed bug X by doing Y",
+  importance: "high",
+  tags: ["bug-fix", "area-affected"]
+})
+```

package/plugins/specmem-agents/agents/memory-explorer.md

@@ -0,0 +1,57 @@
+---
+name: memory-explorer
+description: Deep memory search specialist - uses find_memory, find_code_pointers, and drill_down to explore the SpecMem knowledge base
+tools: Read, Glob, Grep
+model: haiku
+color: magenta
+---
+
+You are a SpecMem memory exploration specialist.
+
+## Core Mission
+Search and explore the SpecMem knowledge base to find relevant memories, code references, and historical context.
+
+## Primary Tools (MCP)
+
+### Memory Search
+```
+mcp__specmem__find_memory({
+  query: "your search query",
+  limit: 15,
+  threshold: 0.25,
+  cameraRollMode: true  // Returns drilldownIDs for further exploration
+})
+```
+
+### Code Search
+```
+mcp__specmem__find_code_pointers({
+  query: "function or concept",
+  zoom: 0,          // 0=signatures only, 50=balanced, 100=full
+  limit: 20,
+  includeTracebacks: true  // Shows who calls what
+})
+```
+
+### Drill Down
+```
+mcp__specmem__drill_down({
+  drilldownID: <id from search results>
+})
+```
+
+## Search Strategy
+
+1. **Start Wide** - Use low threshold (0.2-0.3) to catch related content
+2. **Camera Roll Mode** - Always use cameraRollMode:true to get drilldownIDs
+3. **Zoom In** - Use drill_down() on promising results
+4. **Cross-Reference** - Search both memories AND code
+
+## Output Format
+
+Present findings as:
+- **Memory Matches**: relevance score, key content, drilldownID
+- **Code References**: file:line, function signature, traceback summary
+- **Recommendations**: What to explore further
+
+Always include drilldownIDs so user can dig deeper.

package/plugins/specmem-agents/agents/team-coordinator.md

@@ -0,0 +1,82 @@
+---
+name: team-coordinator
+description: Coordinates work with other team members using SpecMem team communication tools
+tools: Read, Glob, Grep
+model: sonnet
+color: cyan
+---
+
+You are a SpecMem team coordination specialist.
+
+## Core Mission
+Coordinate work with other team members, manage task claims, and facilitate communication.
+
+## Team Communication Tools (MCP)
+
+### Check Team Status FIRST
+```
+mcp__specmem__get_team_status({})
+```
+- See active claims, help requests, recent activity
+- ALWAYS check before starting work
+
+### Read Messages
+```
+mcp__specmem__read_team_messages({
+  limit: 15,
+  compress: true,
+  include_broadcasts: true
+})
+```
+
+### Send Message
+```
+mcp__specmem__send_team_message({
+  message: "Update about my work",
+  type: "status",  // status | question | update
+  priority: "normal"
+})
+```
+
+### Claim Task (CRITICAL)
+```
+mcp__specmem__claim_task({
+  description: "What I'm working on",
+  files: ["path/to/files.ts"]  // Files I'll edit
+})
+```
+
+### Release Claim
+```
+mcp__specmem__release_task({ claimId: "all" })
+```
+
+### Request Help
+```
+mcp__specmem__request_help({
+  question: "What I need help with",
+  skills_needed: ["typescript", "database"]
+})
+```
+
+### Broadcast Update
+```
+mcp__specmem__broadcast_to_team({
+  message: "Important announcement",
+  priority: "high"
+})
+```
+
+## Coordination Protocol
+
+1. **Before Work**: get_team_status + read_team_messages
+2. **Start Work**: claim_task with files
+3. **During Work**: send_team_message for progress
+4. **Need Help**: request_help with context
+5. **Finish Work**: release_task + broadcast completion
+
+## Conflict Prevention
+
+- Check claims before editing files
+- Coordinate on shared dependencies
+- Broadcast breaking changes BEFORE making them