@massu/core 0.1.1 → 0.4.0

package/dist/hooks/session-start.js

@@ -3,12 +3,13 @@ import{createRequire as __cr}from"module";const require=__cr(import.meta.url);
 
 // src/memory-db.ts
 import Database from "better-sqlite3";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname2, basename } from "path";
 import { existsSync as existsSync2, mkdirSync } from "fs";
 
 // src/config.ts
 import { resolve, dirname } from "path";
 import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
 import { parse as parseYaml } from "yaml";
 import { z } from "zod";
 var DomainConfigSchema = z.object({
@@ -140,6 +141,49 @@ var CloudConfigSchema = z.object({
     audit: z.boolean().default(true)
   }).default({ memory: true, analytics: true, audit: true })
 }).optional();
+var ConventionsConfigSchema = z.object({
+  claudeDirName: z.string().default(".claude").refine(
+    (s) => !s.includes("..") && !s.startsWith("/"),
+    { message: 'claudeDirName must not contain ".." or start with "/"' }
+  ),
+  sessionStatePath: z.string().default(".claude/session-state/CURRENT.md").refine(
+    (s) => !s.includes("..") && !s.startsWith("/"),
+    { message: 'sessionStatePath must not contain ".." or start with "/"' }
+  ),
+  sessionArchivePath: z.string().default(".claude/session-state/archive").refine(
+    (s) => !s.includes("..") && !s.startsWith("/"),
+    { message: 'sessionArchivePath must not contain ".." or start with "/"' }
+  ),
+  knowledgeCategories: z.array(z.string()).default([
+    "patterns",
+    "commands",
+    "incidents",
+    "reference",
+    "protocols",
+    "checklists",
+    "playbooks",
+    "critical",
+    "scripts",
+    "status",
+    "templates",
+    "loop-state",
+    "session-state",
+    "agents"
+  ]),
+  knowledgeSourceFiles: z.array(z.string()).default(["CLAUDE.md", "MEMORY.md", "corrections.md"]),
+  excludePatterns: z.array(z.string()).default(["/ARCHIVE/", "/SESSION-HISTORY/"])
+}).optional();
+var PythonDomainConfigSchema = z.object({
+  name: z.string(),
+  packages: z.array(z.string()),
+  allowed_imports_from: z.array(z.string()).default([])
+});
+var PythonConfigSchema = z.object({
+  root: z.string(),
+  alembic_dir: z.string().optional(),
+  domains: z.array(PythonDomainConfigSchema).default([]),
+  exclude_dirs: z.array(z.string()).default(["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"])
+}).optional();
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
@@ -174,7 +218,9 @@ var RawConfigSchema = z.object({
   security: SecurityConfigSchema,
   team: TeamConfigSchema,
   regression: RegressionConfigSchema,
-  cloud: CloudConfigSchema
+  cloud: CloudConfigSchema,
+  conventions: ConventionsConfigSchema,
+  python: PythonConfigSchema
 }).passthrough();
 var _config = null;
 var _projectRoot = null;
@@ -238,13 +284,24 @@ function getConfig() {
     security: parsed.security,
     team: parsed.team,
     regression: parsed.regression,
-    cloud: parsed.cloud
+    cloud: parsed.cloud,
+    conventions: parsed.conventions,
+    python: parsed.python
   };
+  if (!_config.cloud?.apiKey && process.env.MASSU_API_KEY) {
+    _config.cloud = {
+      enabled: true,
+      sync: { memory: true, analytics: true, audit: true },
+      ..._config.cloud,
+      apiKey: process.env.MASSU_API_KEY
+    };
+  }
   return _config;
 }
 function getResolvedPaths() {
   const config = getConfig();
   const root = getProjectRoot();
+  const claudeDirName = config.conventions?.claudeDirName ?? ".claude";
   return {
     codegraphDbPath: resolve(root, ".codegraph/codegraph.db"),
     dataDbPath: resolve(root, ".massu/data.db"),
@@ -260,22 +317,49 @@ function getResolvedPaths() {
     ),
     extensions: [".ts", ".tsx", ".js", ".jsx"],
     indexFiles: ["index.ts", "index.tsx", "index.js", "index.jsx"],
-    patternsDir: resolve(root, ".claude/patterns"),
-    claudeMdPath: resolve(root, ".claude/CLAUDE.md"),
+    patternsDir: resolve(root, claudeDirName, "patterns"),
+    claudeMdPath: resolve(root, claudeDirName, "CLAUDE.md"),
     docsMapPath: resolve(root, ".massu/docs-map.json"),
     helpSitePath: resolve(root, "../" + config.project.name + "-help"),
-    memoryDbPath: resolve(root, ".massu/memory.db")
+    memoryDbPath: resolve(root, ".massu/memory.db"),
+    knowledgeDbPath: resolve(root, ".massu/knowledge.db"),
+    plansDir: resolve(root, "docs/plans"),
+    docsDir: resolve(root, "docs"),
+    claudeDir: resolve(root, claudeDirName),
+    memoryDir: resolve(homedir(), claudeDirName, "projects", root.replace(/\//g, "-"), "memory"),
+    sessionStatePath: resolve(root, config.conventions?.sessionStatePath ?? `${claudeDirName}/session-state/CURRENT.md`),
+    sessionArchivePath: resolve(root, config.conventions?.sessionArchivePath ?? `${claudeDirName}/session-state/archive`),
+    mcpJsonPath: resolve(root, ".mcp.json"),
+    settingsLocalPath: resolve(root, claudeDirName, "settings.local.json")
   };
 }
 
-// src/memory-schema.ts
+// src/memory-db.ts
+function sanitizeFts5Query(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return '""';
+  const tokens = trimmed.replace(/"/g, "").split(/\s+/).filter(Boolean);
+  return tokens.map((t) => `"${t}"`).join(" ");
+}
+function getMemoryDb() {
+  const dbPath = getResolvedPaths().memoryDbPath;
+  const dir = dirname2(dbPath);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  initMemorySchema(db);
+  return db;
+}
 function initMemorySchema(db) {
   db.exec(`
     -- Sessions table (linked to Claude Code session IDs)
     CREATE TABLE IF NOT EXISTS sessions (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT UNIQUE NOT NULL,
-      project TEXT NOT NULL DEFAULT 'unknown',
+      project TEXT NOT NULL DEFAULT 'my-project',
       git_branch TEXT,
       started_at TEXT NOT NULL,
       started_at_epoch INTEGER NOT NULL,
@@ -330,9 +414,7 @@ function initMemorySchema(db) {
         content_rowid='id'
       );
     `);
-  } catch (e) {
-    process.stderr.write(`FTS5 setup warning: ${e instanceof Error ? e.message : String(e)}
-`);
+  } catch (_e) {
   }
   db.exec(`
     CREATE TRIGGER IF NOT EXISTS observations_ai AFTER INSERT ON observations BEGIN
@@ -392,9 +474,7 @@ function initMemorySchema(db) {
         content_rowid='id'
       );
     `);
-  } catch (e) {
-    process.stderr.write(`FTS5 setup warning: ${e instanceof Error ? e.message : String(e)}
-`);
+  } catch (_e) {
   }
   db.exec(`
     CREATE TRIGGER IF NOT EXISTS prompts_ai AFTER INSERT ON user_prompts BEGIN
@@ -464,9 +544,7 @@ function initMemorySchema(db) {
         content_rowid=id
       );
     `);
-  } catch (e) {
-    process.stderr.write(`FTS5 setup warning: ${e instanceof Error ? e.message : String(e)}
-`);
+  } catch (_e) {
   }
   db.exec(`
     CREATE TRIGGER IF NOT EXISTS ct_fts_insert AFTER INSERT ON conversation_turns BEGIN
@@ -490,7 +568,7 @@ function initMemorySchema(db) {
     CREATE TABLE IF NOT EXISTS session_quality_scores (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT NOT NULL UNIQUE,
-      project TEXT NOT NULL DEFAULT 'unknown',
+      project TEXT NOT NULL DEFAULT 'my-project',
       score INTEGER NOT NULL DEFAULT 100,
       security_score INTEGER NOT NULL DEFAULT 100,
       architecture_score INTEGER NOT NULL DEFAULT 100,
@@ -513,7 +591,7 @@ function initMemorySchema(db) {
     CREATE TABLE IF NOT EXISTS session_costs (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT NOT NULL UNIQUE,
-      project TEXT NOT NULL DEFAULT 'unknown',
+      project TEXT NOT NULL DEFAULT 'my-project',
       input_tokens INTEGER NOT NULL DEFAULT 0,
       output_tokens INTEGER NOT NULL DEFAULT 0,
       cache_read_tokens INTEGER NOT NULL DEFAULT 0,
@@ -740,10 +818,16 @@ function initMemorySchema(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_pending_sync_created ON pending_sync(created_at ASC);
   `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS license_cache (
+      api_key_hash TEXT PRIMARY KEY,
+      tier TEXT NOT NULL,
+      valid_until TEXT NOT NULL,
+      last_validated TEXT NOT NULL,
+      features TEXT DEFAULT '[]'
+    );
+  `);
 }
-
-// src/memory-queries.ts
-import { basename } from "path";
 function autoDetectTaskId(planFile) {
   if (!planFile) return null;
   const base = basename(planFile);
@@ -786,7 +870,7 @@ function getFailedAttempts(db, query, limit = 20) {
       JOIN observations o ON observations_fts.rowid = o.id
       WHERE observations_fts MATCH ? AND o.type = 'failed_attempt'
       ORDER BY o.recurrence_count DESC, rank LIMIT ?
-    `).all(query, limit);
+    `).all(sanitizeFts5Query(query), limit);
   }
   return db.prepare(`
     SELECT id, title, detail, session_id, recurrence_count, created_at
@@ -821,25 +905,9 @@ function linkSessionToTask(db, sessionId, taskId) {
   db.prepare("UPDATE sessions SET task_id = ? WHERE session_id = ?").run(taskId, sessionId);
 }
 
-// src/memory-db.ts
-var initializedPaths = /* @__PURE__ */ new Set();
-function getMemoryDb() {
-  const dbPath = getResolvedPaths().memoryDbPath;
-  const dir = dirname2(dbPath);
-  if (!existsSync2(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  const db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
-  db.pragma("foreign_keys = ON");
-  if (!initializedPaths.has(dbPath)) {
-    initMemorySchema(db);
-    initializedPaths.add(dbPath);
-  }
-  return db;
-}
-
 // src/hooks/session-start.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { join } from "path";
 async function main() {
   try {
     const input = await readStdin();
@@ -866,7 +934,7 @@ Session memory, code intelligence, and governance are now active.
 `
         );
       }
-      const context = buildContext(db, session_id, source ?? "startup", tokenBudget, session?.task_id ?? null);
+      const context = await buildContext(db, session_id, source ?? "startup", tokenBudget, session?.task_id ?? null);
       if (context.trim()) {
         process.stdout.write(context);
       }
@@ -891,7 +959,7 @@ function getTokenBudget(source) {
       return 2e3;
   }
 }
-function buildContext(db, sessionId, source, tokenBudget, taskId) {
+async function buildContext(db, sessionId, source, tokenBudget, taskId) {
   const sections = [];
   const failures = getFailedAttempts(db, void 0, 10);
   if (failures.length > 0) {
@@ -948,6 +1016,47 @@ function buildContext(db, sessionId, source, tokenBudget, taskId) {
       sections.push({ text: progressText, importance: 8 });
     }
   }
+  const preventionRules = loadCorrectionsPreventionRules();
+  if (preventionRules.length > 0) {
+    let rulesText = "### Active Prevention Rules (from corrections.md)\n";
+    for (const rule of preventionRules) {
+      rulesText += `- ${rule}
+`;
+    }
+    sections.push({ text: rulesText, importance: 9 });
+  }
+  try {
+    const knowledgeDbPath = getResolvedPaths().knowledgeDbPath;
+    if (existsSync3(knowledgeDbPath)) {
+      const Database2 = (await import("better-sqlite3")).default;
+      const kdb = new Database2(knowledgeDbPath, { readonly: true });
+      try {
+        const stats = kdb.prepare(
+          "SELECT COUNT(*) as doc_count, MAX(indexed_at) as last_indexed FROM knowledge_documents"
+        ).get();
+        if (stats.doc_count > 0 && stats.last_indexed) {
+          const ageMs = Date.now() - new Date(stats.last_indexed).getTime();
+          const ageHours = Math.round(ageMs / 36e5);
+          if (ageHours > 24) {
+            sections.push({
+              text: `### Knowledge Index Status
+Index has ${stats.doc_count} documents, last indexed ${ageHours}h ago. Consider re-indexing.
+`,
+              importance: 3
+            });
+          }
+        } else if (stats.doc_count === 0) {
+          sections.push({
+            text: "### Knowledge Index Status\nKnowledge index is empty. Run knowledge indexing to populate it.\n",
+            importance: 2
+          });
+        }
+      } finally {
+        kdb.close();
+      }
+    }
+  } catch (_knowledgeErr) {
+  }
   const recentObs = getRecentObservations(db, 20);
   if (recentObs.length > 0) {
     let obsText = "### Recent Observations\n";
@@ -960,7 +1069,7 @@ function buildContext(db, sessionId, source, tokenBudget, taskId) {
   }
   sections.sort((a, b) => b.importance - a.importance);
   let usedTokens = 0;
-  const headerTokens = estimateTokens("=== CS MEMORY: Previous Session Context ===\n\n=== END CS MEMORY ===\n");
+  const headerTokens = estimateTokens("=== Massu Memory: Previous Session Context ===\n\n=== END Massu Memory ===\n");
   usedTokens += headerTokens;
   const includedSections = [];
   for (const section of sections) {
@@ -971,10 +1080,10 @@ function buildContext(db, sessionId, source, tokenBudget, taskId) {
     }
   }
   if (includedSections.length === 0) return "";
-  return `=== CS MEMORY: Previous Session Context ===
+  return `=== Massu Memory: Previous Session Context ===
 
 ${includedSections.join("\n")}
-=== END CS MEMORY ===
+=== END Massu Memory ===
 `;
 }
 function estimateTokens(text) {
@@ -994,14 +1103,14 @@ async function getGitBranch() {
   }
 }
 function readStdin() {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve2(data));
-    setTimeout(() => resolve2(data), 3e3);
+    process.stdin.on("end", () => resolve3(data));
+    setTimeout(() => resolve3(data), 3e3);
   });
 }
 function safeParseJson(json) {
@@ -1011,4 +1120,32 @@ function safeParseJson(json) {
     return null;
   }
 }
+function loadCorrectionsPreventionRules() {
+  try {
+    const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const cwd = process.cwd();
+    const config = getConfig();
+    const claudeDirName = config.conventions?.claudeDirName ?? ".claude";
+    const projectDirName = cwd.replace(/\//g, "-").replace(/^-/, "");
+    const correctionsPath = join(homeDir, claudeDirName, "projects", projectDirName, "memory", "corrections.md");
+    if (!existsSync3(correctionsPath)) return [];
+    const content = readFileSync2(correctionsPath, "utf-8");
+    const lines = content.split("\n");
+    const rules = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("|") || !trimmed.endsWith("|")) continue;
+      const cells = trimmed.split("|").map((c) => c.trim()).filter((c) => c.length > 0);
+      if (cells.length < 4) continue;
+      if (cells[0] === "Date" || cells[0].startsWith("-")) continue;
+      const preventionRule = cells[3];
+      if (preventionRule && !preventionRule.startsWith("-") && !preventionRule.startsWith("<!--")) {
+        rules.push(preventionRule);
+      }
+    }
+    return rules;
+  } catch (_e) {
+    return [];
+  }
+}
 main();