@hir4ta/mneme 0.17.0

package/dist/lib/db.js

@@ -0,0 +1,340 @@
+// lib/db.ts
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var originalEmit = process.emit;
+process.emit = (event, ...args) => {
+  if (event === "warning" && typeof args[0] === "object" && args[0] !== null && "name" in args[0] && args[0].name === "ExperimentalWarning" && "message" in args[0] && typeof args[0].message === "string" && args[0].message.includes("SQLite")) {
+    return false;
+  }
+  return originalEmit.apply(process, [event, ...args]);
+};
+var { DatabaseSync } = await import("node:sqlite");
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function getCurrentUser() {
+  try {
+    return execSync("git config user.name", { encoding: "utf-8" }).trim();
+  } catch {
+    try {
+      return execSync("whoami", { encoding: "utf-8" }).trim();
+    } catch {
+      return "unknown";
+    }
+  }
+}
+function getLocalDbPath(projectPath) {
+  return join(projectPath, ".mneme", "local.db");
+}
+function configurePragmas(db) {
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA synchronous = NORMAL");
+}
+function initLocalDatabase(projectPath) {
+  const mnemeDir = join(projectPath, ".mneme");
+  if (!existsSync(mnemeDir)) {
+    mkdirSync(mnemeDir, { recursive: true });
+  }
+  const dbPath = getLocalDbPath(projectPath);
+  const db = new DatabaseSync(dbPath);
+  configurePragmas(db);
+  const schemaPath = join(__dirname, "schema.sql");
+  if (existsSync(schemaPath)) {
+    const schema = readFileSync(schemaPath, "utf-8");
+    db.exec(schema);
+  }
+  return db;
+}
+function openLocalDatabase(projectPath) {
+  const dbPath = getLocalDbPath(projectPath);
+  if (!existsSync(dbPath)) {
+    return null;
+  }
+  const db = new DatabaseSync(dbPath);
+  configurePragmas(db);
+  return db;
+}
+function getRepositoryInfo(projectPath) {
+  const result = {
+    repository: null,
+    repository_url: null,
+    repository_root: null
+  };
+  try {
+    execSync("git rev-parse --git-dir", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    result.repository_root = execSync("git rev-parse --show-toplevel", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    }).trim();
+    try {
+      result.repository_url = execSync("git remote get-url origin", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      }).trim();
+      const match = result.repository_url.match(/[:/]([^/]+\/[^/]+?)(\.git)?$/);
+      if (match) {
+        result.repository = match[1].replace(/\.git$/, "");
+      }
+    } catch {
+    }
+  } catch {
+  }
+  return result;
+}
+function insertInteractions(db, interactions) {
+  const insert = db.prepare(`
+    INSERT INTO interactions (session_id, project_path, repository, repository_url, repository_root, owner, role, content, thinking, tool_calls, timestamp, is_compact_summary)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  db.exec("BEGIN TRANSACTION");
+  try {
+    for (const item of interactions) {
+      insert.run(
+        item.session_id,
+        item.project_path,
+        item.repository || null,
+        item.repository_url || null,
+        item.repository_root || null,
+        item.owner,
+        item.role,
+        item.content,
+        item.thinking || null,
+        item.tool_calls || null,
+        item.timestamp,
+        item.is_compact_summary || 0
+      );
+    }
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+function getInteractions(db, sessionId) {
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE session_id = ?
+    ORDER BY timestamp ASC
+  `);
+  return stmt.all(sessionId);
+}
+function getInteractionsByOwner(db, sessionId, owner) {
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE session_id = ? AND owner = ?
+    ORDER BY timestamp ASC
+  `);
+  return stmt.all(sessionId, owner);
+}
+function getInteractionsBySessionIds(db, sessionIds) {
+  if (sessionIds.length === 0) {
+    return [];
+  }
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE session_id IN (${placeholders})
+    ORDER BY timestamp ASC, id ASC
+  `);
+  return stmt.all(...sessionIds);
+}
+function getInteractionsBySessionIdsAndOwner(db, sessionIds, owner) {
+  if (sessionIds.length === 0) {
+    return [];
+  }
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE session_id IN (${placeholders}) AND owner = ?
+    ORDER BY timestamp ASC, id ASC
+  `);
+  return stmt.all(...sessionIds, owner);
+}
+function hasInteractionsForSessionIds(db, sessionIds, owner) {
+  if (sessionIds.length === 0) {
+    return false;
+  }
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const stmt = db.prepare(`
+    SELECT COUNT(*) as count FROM interactions
+    WHERE session_id IN (${placeholders}) AND owner = ?
+  `);
+  const result = stmt.get(...sessionIds, owner);
+  return result.count > 0;
+}
+function hasInteractions(db, sessionId, owner) {
+  const stmt = db.prepare(`
+    SELECT COUNT(*) as count FROM interactions
+    WHERE session_id = ? AND owner = ?
+  `);
+  const result = stmt.get(sessionId, owner);
+  return result.count > 0;
+}
+function insertPreCompactBackup(db, backup) {
+  const stmt = db.prepare(`
+    INSERT INTO pre_compact_backups (session_id, project_path, owner, interactions)
+    VALUES (?, ?, ?, ?)
+  `);
+  stmt.run(
+    backup.session_id,
+    backup.project_path,
+    backup.owner,
+    backup.interactions
+  );
+}
+function getLatestBackup(db, sessionId) {
+  const stmt = db.prepare(`
+    SELECT * FROM pre_compact_backups
+    WHERE session_id = ?
+    ORDER BY created_at DESC
+    LIMIT 1
+  `);
+  return stmt.get(sessionId) || null;
+}
+function getAllBackups(db, sessionId) {
+  const stmt = db.prepare(`
+    SELECT * FROM pre_compact_backups
+    WHERE session_id = ?
+    ORDER BY created_at ASC
+  `);
+  return stmt.all(sessionId);
+}
+function searchInteractions(db, query, limit = 10) {
+  const stmt = db.prepare(`
+    SELECT i.session_id, i.content, i.thinking
+    FROM interactions_fts fts
+    JOIN interactions i ON fts.rowid = i.id
+    WHERE interactions_fts MATCH ?
+    LIMIT ?
+  `);
+  return stmt.all(query, limit);
+}
+function deleteInteractions(db, sessionId) {
+  const stmt = db.prepare("DELETE FROM interactions WHERE session_id = ?");
+  stmt.run(sessionId);
+}
+function deleteBackups(db, sessionId) {
+  const stmt = db.prepare(
+    "DELETE FROM pre_compact_backups WHERE session_id = ?"
+  );
+  stmt.run(sessionId);
+}
+function getDbStats(db) {
+  const interactionsCount = db.prepare("SELECT COUNT(*) as count FROM interactions").get();
+  const backupsCount = db.prepare("SELECT COUNT(*) as count FROM pre_compact_backups").get();
+  return {
+    interactions: interactionsCount.count,
+    backups: backupsCount.count
+  };
+}
+function getInteractionsByProject(db, projectPath) {
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE project_path = ?
+    ORDER BY timestamp ASC
+  `);
+  return stmt.all(projectPath);
+}
+function getInteractionsByRepository(db, repository) {
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE repository = ?
+    ORDER BY timestamp ASC
+  `);
+  return stmt.all(repository);
+}
+function getUniqueProjects(db) {
+  const stmt = db.prepare(`
+    SELECT DISTINCT project_path FROM interactions
+    ORDER BY project_path
+  `);
+  const rows = stmt.all();
+  return rows.map((r) => r.project_path);
+}
+function getUniqueRepositories(db) {
+  const stmt = db.prepare(`
+    SELECT DISTINCT repository FROM interactions
+    WHERE repository IS NOT NULL
+    ORDER BY repository
+  `);
+  const rows = stmt.all();
+  return rows.map((r) => r.repository);
+}
+function deleteInteractionsByProject(db, projectPath) {
+  const stmt = db.prepare("DELETE FROM interactions WHERE project_path = ?");
+  const result = stmt.run(projectPath);
+  return Number(result.changes);
+}
+function deleteInteractionsBefore(db, beforeDate) {
+  const stmt = db.prepare("DELETE FROM interactions WHERE timestamp < ?");
+  const result = stmt.run(beforeDate);
+  return Number(result.changes);
+}
+function deleteBackupsByProject(db, projectPath) {
+  const stmt = db.prepare(
+    "DELETE FROM pre_compact_backups WHERE project_path = ?"
+  );
+  const result = stmt.run(projectPath);
+  return Number(result.changes);
+}
+function countInteractions(db, filter) {
+  const conditions = [];
+  const params = [];
+  if (filter.sessionId) {
+    conditions.push("session_id = ?");
+    params.push(filter.sessionId);
+  }
+  if (filter.projectPath) {
+    conditions.push("project_path = ?");
+    params.push(filter.projectPath);
+  }
+  if (filter.repository) {
+    conditions.push("repository = ?");
+    params.push(filter.repository);
+  }
+  if (filter.before) {
+    conditions.push("timestamp < ?");
+    params.push(filter.before);
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const stmt = db.prepare(
+    `SELECT COUNT(*) as count FROM interactions ${whereClause}`
+  );
+  const result = stmt.get(...params);
+  return result.count;
+}
+export {
+  countInteractions,
+  deleteBackups,
+  deleteBackupsByProject,
+  deleteInteractions,
+  deleteInteractionsBefore,
+  deleteInteractionsByProject,
+  getAllBackups,
+  getCurrentUser,
+  getDbStats,
+  getInteractions,
+  getInteractionsByOwner,
+  getInteractionsByProject,
+  getInteractionsByRepository,
+  getInteractionsBySessionIds,
+  getInteractionsBySessionIdsAndOwner,
+  getLatestBackup,
+  getLocalDbPath,
+  getRepositoryInfo,
+  getUniqueProjects,
+  getUniqueRepositories,
+  hasInteractions,
+  hasInteractionsForSessionIds,
+  initLocalDatabase,
+  insertInteractions,
+  insertPreCompactBackup,
+  openLocalDatabase,
+  searchInteractions
+};

package/dist/lib/fuzzy-search.js

@@ -0,0 +1,214 @@
+// lib/fuzzy-search.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// lib/utils.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function safeReadJson(filePath, fallback) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return fallback;
+  }
+}
+function findJsonFiles(dir) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  const items = fs.readdirSync(dir, { withFileTypes: true });
+  for (const item of items) {
+    const fullPath = path.join(dir, item.name);
+    if (item.isDirectory()) {
+      results.push(...findJsonFiles(fullPath));
+    } else if (item.name.endsWith(".json")) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+// lib/fuzzy-search.ts
+function levenshtein(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= a.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= b.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        // deletion
+        matrix[i][j - 1] + 1,
+        // insertion
+        matrix[i - 1][j - 1] + cost
+        // substitution
+      );
+    }
+  }
+  return matrix[a.length][b.length];
+}
+function expandAliases(query, tags) {
+  const results = /* @__PURE__ */ new Set([query]);
+  const lowerQuery = query.toLowerCase();
+  for (const tag of tags) {
+    const allTerms = [tag.id, tag.label, ...tag.aliases].map(
+      (t) => t.toLowerCase()
+    );
+    if (allTerms.includes(lowerQuery)) {
+      results.add(tag.id);
+      results.add(tag.label);
+      for (const alias of tag.aliases) {
+        results.add(alias);
+      }
+    }
+  }
+  return Array.from(results);
+}
+function calculateSimilarity(text, query) {
+  const lowerText = text.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  if (lowerText === lowerQuery) return 10;
+  if (lowerText.includes(lowerQuery)) return 5;
+  if (lowerQuery.includes(lowerText)) return 3;
+  const distance = levenshtein(lowerText, lowerQuery);
+  if (distance <= 2) return 2;
+  if (distance <= 3) return 1;
+  return 0;
+}
+async function search(options) {
+  const {
+    query,
+    mnemeDir,
+    targets = ["sessions", "decisions"],
+    limit = 20,
+    timeout = 1e4
+  } = options;
+  const startTime = Date.now();
+  const results = [];
+  const tagsPath = path2.join(mnemeDir, "tags.json");
+  const tagsData = safeReadJson(tagsPath, { tags: [] });
+  const expandedQueries = expandAliases(query, tagsData.tags);
+  if (targets.includes("sessions")) {
+    const sessionsDir = path2.join(mnemeDir, "sessions");
+    if (fs2.existsSync(sessionsDir)) {
+      const files = findJsonFiles(sessionsDir);
+      for (const file of files) {
+        if (Date.now() - startTime > timeout) break;
+        const session = safeReadJson(file, {});
+        const score = scoreDocument(session, expandedQueries, [
+          "title",
+          "goal",
+          "tags"
+        ]);
+        if (score > 0) {
+          results.push({
+            type: "session",
+            id: session.id || path2.basename(file, ".json"),
+            score,
+            title: session.title || "Untitled",
+            highlights: []
+          });
+        }
+      }
+    }
+  }
+  if (targets.includes("decisions")) {
+    const decisionsDir = path2.join(mnemeDir, "decisions");
+    if (fs2.existsSync(decisionsDir)) {
+      const files = findJsonFiles(decisionsDir);
+      for (const file of files) {
+        if (Date.now() - startTime > timeout) break;
+        const decision = safeReadJson(file, {});
+        const score = scoreDocument(decision, expandedQueries, [
+          "title",
+          "decision",
+          "tags"
+        ]);
+        if (score > 0) {
+          results.push({
+            type: "decision",
+            id: decision.id || path2.basename(file, ".json"),
+            score,
+            title: decision.title || "Untitled",
+            highlights: []
+          });
+        }
+      }
+    }
+  }
+  if (targets.includes("patterns")) {
+    const patternsDir = path2.join(mnemeDir, "patterns");
+    if (fs2.existsSync(patternsDir)) {
+      const files = findJsonFiles(patternsDir);
+      for (const file of files) {
+        if (Date.now() - startTime > timeout) break;
+        const pattern = safeReadJson(file, {});
+        const patterns = pattern.patterns || [];
+        for (const p of patterns) {
+          const score = scoreDocument(p, expandedQueries, [
+            "description",
+            "errorPattern",
+            "tags"
+          ]);
+          if (score > 0) {
+            results.push({
+              type: "pattern",
+              id: `${path2.basename(file, ".json")}-${p.type || "unknown"}`,
+              score,
+              title: p.description || "Untitled pattern",
+              highlights: []
+            });
+          }
+        }
+      }
+    }
+  }
+  return results.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+function scoreDocument(doc, queries, fields) {
+  let totalScore = 0;
+  for (const field of fields) {
+    const value = doc[field];
+    if (typeof value === "string") {
+      for (const q of queries) {
+        totalScore += calculateSimilarity(value, q);
+      }
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === "string") {
+          for (const q of queries) {
+            totalScore += calculateSimilarity(item, q);
+          }
+        }
+      }
+    }
+  }
+  return totalScore;
+}
+var isMain = process.argv[1]?.endsWith("fuzzy-search.js") || process.argv[1]?.endsWith("fuzzy-search.ts");
+if (isMain && process.argv.length > 2) {
+  const args = process.argv.slice(2);
+  const queryIndex = args.indexOf("--query");
+  const query = queryIndex !== -1 ? args[queryIndex + 1] : "";
+  const mnemeDir = `${process.cwd()}/.mneme`;
+  if (!query) {
+    console.error(JSON.stringify({ success: false, error: "Missing --query" }));
+    process.exit(0);
+  }
+  search({ query, mnemeDir }).then((results) => {
+    console.log(JSON.stringify({ success: true, results }));
+  }).catch((error) => {
+    console.error(JSON.stringify({ success: false, error: String(error) }));
+  });
+}
+export {
+  calculateSimilarity,
+  expandAliases,
+  levenshtein,
+  search
+};

package/dist/lib/github.js

@@ -0,0 +1,121 @@
+// lib/github.ts
+function parsePRUrl(url) {
+  const patterns = [
+    // Standard PR URL: https://github.com/owner/repo/pull/123
+    /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/
+  ];
+  for (const pattern of patterns) {
+    const match = url.match(pattern);
+    if (match) {
+      const [, owner, repo, prNumber] = match;
+      return {
+        owner,
+        repo,
+        prNumber: Number.parseInt(prNumber, 10),
+        url: `https://github.com/${owner}/${repo}/pull/${prNumber}`
+      };
+    }
+  }
+  return null;
+}
+async function fetchPRDiff(prSource) {
+  const { owner, repo, prNumber } = prSource;
+  const { execSync } = await import("node:child_process");
+  try {
+    const diff = execSync(`gh pr diff ${prNumber} --repo ${owner}/${repo}`, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return diff;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to fetch PR diff: ${message}`);
+  }
+}
+async function fetchPRComments(prSource) {
+  const { owner, repo, prNumber } = prSource;
+  const { execSync } = await import("node:child_process");
+  try {
+    const reviewCommentsJson = execSync(
+      `gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`,
+      { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+    );
+    const reviewComments = JSON.parse(reviewCommentsJson);
+    return reviewComments.map(
+      (comment) => ({
+        id: comment.id,
+        body: comment.body,
+        path: comment.path,
+        line: comment.line ?? comment.original_line,
+        user: { login: comment.user.login },
+        createdAt: comment.created_at,
+        url: comment.html_url
+      })
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to fetch PR comments: ${message}`);
+  }
+}
+async function fetchPRIssueComments(prSource) {
+  const { owner, repo, prNumber } = prSource;
+  const { execSync } = await import("node:child_process");
+  try {
+    const issueCommentsJson = execSync(
+      `gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`,
+      { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+    );
+    const issueComments = JSON.parse(issueCommentsJson);
+    return issueComments.map(
+      (comment) => ({
+        id: comment.id,
+        body: comment.body,
+        path: "",
+        line: null,
+        user: { login: comment.user.login },
+        createdAt: comment.created_at,
+        url: comment.html_url
+      })
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to fetch PR issue comments: ${message}`);
+  }
+}
+async function fetchAllPRComments(prSource) {
+  const [reviewComments, issueComments] = await Promise.all([
+    fetchPRComments(prSource),
+    fetchPRIssueComments(prSource)
+  ]);
+  return [...reviewComments, ...issueComments];
+}
+async function fetchPRMetadata(prSource) {
+  const { owner, repo, prNumber } = prSource;
+  const { execSync } = await import("node:child_process");
+  try {
+    const prJson = execSync(
+      `gh pr view ${prNumber} --repo ${owner}/${repo} --json title,body,state,author,createdAt,mergedAt`,
+      { encoding: "utf-8" }
+    );
+    const pr = JSON.parse(prJson);
+    return {
+      title: pr.title,
+      body: pr.body || "",
+      state: pr.state,
+      author: pr.author.login,
+      createdAt: pr.createdAt,
+      mergedAt: pr.mergedAt
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to fetch PR metadata: ${message}`);
+  }
+}
+export {
+  fetchAllPRComments,
+  fetchPRComments,
+  fetchPRDiff,
+  fetchPRIssueComments,
+  fetchPRMetadata,
+  parsePRUrl
+};