@yugabytedb/meko-mcp 1.0.3

package/lib/migrate/adapters/claude-code.mjs

@@ -0,0 +1,165 @@
+/**
+ * adapters/claude-code.mjs — Enumerate + parse Claude Code sessions.
+ *
+ * Parser lives in ../claude-parser.mjs (vendored, streaming). We do NOT
+ * import from `skills/hooks-handlers/lib/capture.js` — that file is
+ * published in a different package, is CommonJS with side effects, and
+ * using `import.meta.dirname` to reach it broke under `npm install`.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { agentIdForClaude, slugifyCwd } from "../id.mjs";
+import { parseSessionStream, peekSessionMetadata } from "../claude-parser.mjs";
+
+function homeDir() {
+  return process.env.HOME || os.homedir();
+}
+
+/**
+ * The projects root that Claude Code writes session files under.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.home]
+ * @returns {string}
+ */
+export function projectsRoot(opts = {}) {
+  return path.join(opts.home ?? homeDir(), ".claude", "projects");
+}
+
+/**
+ * User-scope CLAUDE.md location.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.home]
+ * @returns {string}
+ */
+export function userClaudeMdPath(opts = {}) {
+  return path.join(opts.home ?? homeDir(), ".claude", "CLAUDE.md");
+}
+
+/**
+ * @typedef {Object} SessionRef
+ * @property {string} sessionUuid
+ * @property {string} path
+ * @property {string} slug
+ * @property {string} cwd             Derived from the first session in the slug dir.
+ * @property {string} agentId
+ * @property {number} size
+ * @property {number} mtimeMs
+ * @property {boolean} likelyInProgress
+ */
+
+/**
+ * Enumerate session files under `~/.claude/projects/`.
+ *
+ * For `scope === "project"`, filter by matching the session's embedded
+ * `cwd` field against `projectCwd`. The slug→cwd mapping is lossy for
+ * paths containing `.` or `-`, so we only use the slug as a candidate
+ * shortlist; the authoritative match is on file content.
+ *
+ * @param {object} opts
+ * @param {"user"|"project"} opts.scope
+ * @param {string} [opts.projectCwd]
+ * @param {string} [opts.home]
+ * @returns {Promise<SessionRef[]>}
+ */
+export async function listSessions(opts) {
+  const root = projectsRoot(opts);
+  if (!fs.existsSync(root)) return [];
+
+  const slugs = fs.readdirSync(root, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+
+  const wantedCwd = opts.scope === "project" ? opts.projectCwd : null;
+  const wantedSlug = wantedCwd ? slugifyCwd(wantedCwd) : null;
+
+  const out = [];
+  for (const slug of slugs) {
+    if (wantedSlug && slug !== wantedSlug) continue;
+    const dir = path.join(root, slug);
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    // Resolve the project cwd from the first readable session — authoritative.
+    const slugCwd = await cwdForSlugDir(dir, slug);
+    if (wantedCwd && slugCwd && slugCwd !== wantedCwd) continue;
+
+    for (const e of entries) {
+      if (!e.isFile() || !e.name.endsWith(".jsonl")) continue;
+      const full = path.join(dir, e.name);
+      let stat;
+      try { stat = fs.statSync(full); } catch { continue; }
+      const sessionUuid = e.name.replace(/\.jsonl$/, "");
+      out.push({
+        sessionUuid,
+        path: full,
+        slug,
+        cwd: slugCwd,
+        agentId: agentIdForClaude(slugCwd),
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        likelyInProgress: stat.mtimeMs > Date.now() - 60_000,
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * Resolve the absolute project cwd for a slug directory by peeking at
+ * the first parseable line of any session file in it. Falls back to a
+ * naive `-` → `/` replacement if no session file has a cwd.
+ *
+ * Cached per call (each session dir is read at most once).
+ *
+ * @param {string} dir
+ * @param {string} slug
+ * @returns {Promise<string>}
+ */
+export async function cwdForSlugDir(dir, slug) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir).filter((n) => n.endsWith(".jsonl"));
+  } catch {
+    return fallbackCwd(slug);
+  }
+  for (const name of entries) {
+    try {
+      const meta = await peekSessionMetadata(path.join(dir, name));
+      if (meta.cwd) return meta.cwd;
+    } catch {
+      continue;
+    }
+  }
+  return fallbackCwd(slug);
+}
+
+function fallbackCwd(slug) {
+  if (!slug || !slug.startsWith("-")) return slug;
+  return slug.replace(/-/g, "/");
+}
+
+/**
+ * Parse a session file via the streaming parser.
+ *
+ * @param {string} sessionPath
+ * @returns {Promise<{
+ *   sessionUuid: string,
+ *   firstUserText: string,
+ *   cwd: string,
+ *   gitBranch: string|null,
+ *   startedAt: string|null,
+ *   messageCount: number,
+ *   exchanges: Array<{user_uuid: string, input: string, output: string, reasoning: string, timestamp: string}>,
+ *   partial: boolean,
+ * }>}
+ */
+export function parseSession(sessionPath) {
+  return parseSessionStream(sessionPath);
+}

package/lib/migrate/adapters/cursor.mjs

@@ -0,0 +1,221 @@
+/**
+ * adapters/cursor.mjs — Enumerate + parse Cursor agent transcripts.
+ *
+ * Cursor writes sessions under:
+ *   ~/.cursor/projects/<projectName>/agent-transcripts/<sessionUuid>/...jsonl
+ *
+ * The transcript format differs from Claude Code's: each line is a
+ * `{role, message: {content: [blocks]}}` object. Blocks may be
+ * `{type:"text", text:"..."}` or `{type:"tool_use", name, input}` or
+ * `{type:"tool_result", content:...}`.
+ *
+ * Schema drift is common with Cursor; unknown block types are dropped
+ * with a warning and do not fail ingestion.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { agentIdForCursor } from "../id.mjs";
+
+function homeDir() {
+  return process.env.HOME || require("node:os").homedir();
+}
+
+export function projectsRoot(opts = {}) {
+  return path.join(opts.home ?? homeDir(), ".cursor", "projects");
+}
+
+/**
+ * @typedef {Object} CursorSessionRef
+ * @property {string} sessionUuid
+ * @property {string} path            Directory containing transcript shards.
+ * @property {string} projectName
+ * @property {string} agentId         `cursor:<projectName>`.
+ * @property {number} mtimeMs
+ * @property {boolean} likelyInProgress
+ */
+
+/**
+ * @param {object} opts
+ * @param {"user"|"project"} opts.scope
+ * @param {string} [opts.projectCwd]
+ * @param {string} [opts.home]
+ * @returns {CursorSessionRef[]}
+ */
+export function listSessions(opts) {
+  const root = projectsRoot(opts);
+  if (!fs.existsSync(root)) return [];
+
+  // Cursor's project folder name is NOT path-encoded the same way as
+  // Claude Code. For `--scope project`, we can only match heuristically
+  // on the basename of the cwd. That's acceptable for v1.
+  const wantedName = opts.scope === "project"
+    ? path.basename(opts.projectCwd || "")
+    : null;
+
+  const projects = fs.readdirSync(root, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+
+  const out = [];
+  for (const projectName of projects) {
+    if (wantedName && projectName !== wantedName) continue;
+    const transcriptsDir = path.join(root, projectName, "agent-transcripts");
+    let sessionDirs;
+    try {
+      sessionDirs = fs.readdirSync(transcriptsDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const sd of sessionDirs) {
+      if (!sd.isDirectory()) continue;
+      const sessionDir = path.join(transcriptsDir, sd.name);
+      let stat;
+      try {
+        stat = fs.statSync(sessionDir);
+      } catch {
+        continue;
+      }
+      out.push({
+        sessionUuid: sd.name,
+        path: sessionDir,
+        projectName,
+        agentId: agentIdForCursor(projectName),
+        mtimeMs: stat.mtimeMs,
+        likelyInProgress: stat.mtimeMs > Date.now() - 60_000,
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * Parse a session directory: pair user/assistant turns.
+ *
+ * @param {string} sessionPath
+ * @returns {{
+ *   sessionUuid: string,
+ *   firstUserText: string,
+ *   startedAt: string|null,
+ *   exchanges: Array<{user_uuid: string, input: string, output: string, reasoning: string, timestamp: string}>,
+ *   partial: boolean,
+ * }}
+ */
+export function parseSession(sessionPath) {
+  const entries = collectEntries(sessionPath);
+
+  let firstUserText = "";
+  let startedAt = null;
+  for (const e of entries) {
+    if (!startedAt && e.timestamp) startedAt = e.timestamp;
+    if (!firstUserText && e.role === "user") {
+      const txt = extractTextBlocks(e.content);
+      if (txt) firstUserText = txt.slice(0, 240);
+    }
+  }
+
+  // Pair user→assistant turns.
+  const exchanges = [];
+  let pendingUser = null;
+  let turnIdx = 0;
+  for (const e of entries) {
+    if (e.role === "user") {
+      if (pendingUser) {
+        // User-after-user: flush with empty output.
+        exchanges.push(makePair(pendingUser, null, turnIdx++));
+      }
+      pendingUser = e;
+    } else if (e.role === "assistant") {
+      if (!pendingUser) continue; // assistant with no preceding user — skip
+      exchanges.push(makePair(pendingUser, e, turnIdx++));
+      pendingUser = null;
+    }
+  }
+  if (pendingUser) {
+    exchanges.push(makePair(pendingUser, null, turnIdx++));
+  }
+
+  return {
+    sessionUuid: path.basename(sessionPath),
+    firstUserText,
+    startedAt,
+    exchanges: exchanges.filter((ex) => ex.input || ex.output),
+    partial: false, // Cursor directories don't give us a partial-line signal
+  };
+}
+
+function collectEntries(dir) {
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).sort();
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const f of files) {
+    let raw;
+    try {
+      raw = fs.readFileSync(path.join(dir, f), "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const obj = JSON.parse(trimmed);
+        const role = obj.role || obj.message?.role;
+        if (role !== "user" && role !== "assistant") continue;
+        entries.push({
+          role,
+          uuid: obj.uuid || obj.id || null,
+          timestamp: obj.timestamp || obj.createdAt || null,
+          content: obj.message?.content ?? obj.content ?? null,
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+  return entries;
+}
+
+function makePair(userEntry, assistantEntry, idx) {
+  const input = extractTextBlocks(userEntry.content);
+  const output = assistantEntry ? extractTextBlocks(assistantEntry.content) : "";
+  const reasoning = assistantEntry ? extractToolCallsText(assistantEntry.content) : "";
+  return {
+    user_uuid: userEntry.uuid || `cursor-${idx}`,
+    input,
+    output,
+    reasoning,
+    timestamp: assistantEntry?.timestamp || userEntry.timestamp || "",
+  };
+}
+
+function extractTextBlocks(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const b of content) {
+    if (!b) continue;
+    if (typeof b === "string") { parts.push(b); continue; }
+    if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+  }
+  return parts.join("\n");
+}
+
+function extractToolCallsText(content) {
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const b of content) {
+    if (!b) continue;
+    if (b.type === "tool_use") {
+      const input = b.input ? JSON.stringify(b.input).slice(0, 500) : "";
+      parts.push(`TOOL CALL: ${b.name || "unknown"}(${input})`);
+    } else if (b.type === "tool_result" && typeof b.content === "string") {
+      parts.push(`TOOL RESULT:\n${b.content.slice(0, 3000)}`);
+    }
+  }
+  return parts.join("\n---\n");
+}

package/lib/migrate/adapters/memory-md.mjs

@@ -0,0 +1,230 @@
+/**
+ * adapters/memory-md.mjs — Enumerate and parse CLAUDE.md + per-file memory/*.md.
+ *
+ * Two shapes:
+ *   1. CLAUDE.md (user- or project-scope) — split on `^# ` level-1 headings;
+ *      each section becomes one memory (metadata includes `heading`).
+ *   2. ~/.claude/projects/<slug>/memory/*.md — each file is one memory; the
+ *      body (minus YAML frontmatter) is the text, frontmatter becomes metadata.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import {
+  CLAUDE_CODE_USER_AGENT_ID,
+  agentIdForClaude,
+  memoryHash,
+  slugifyCwd,
+} from "../id.mjs";
+import { cwdForSlugDir } from "./claude-code.mjs";
+
+function homeDir() {
+  return process.env.HOME || os.homedir();
+}
+
+/**
+ * @typedef {Object} MemoryItem
+ * @property {string} agentId
+ * @property {string} text
+ * @property {string} hash
+ * @property {{source: string, scope: "user"|"project", sourcePath: string, heading?: string, name?: string, description?: string, type?: string}} metadata
+ * @property {string} name      Display/dedup name.
+ */
+
+/**
+ * Enumerate memory items per scope.
+ *
+ * Derives project cwd by peeking at an actual session file in each slug
+ * directory (authoritative) rather than reverse-slugging, which is lossy
+ * for paths containing `-` or `.`.
+ *
+ * @param {object} opts
+ * @param {"user"|"project"} opts.scope
+ * @param {string} [opts.projectCwd]
+ * @param {string} [opts.home]
+ * @returns {Promise<MemoryItem[]>}
+ */
+export async function enumerateMemoryItems(opts) {
+  const home = opts.home ?? homeDir();
+  const items = [];
+
+  if (opts.scope === "user") {
+    const userMd = path.join(home, ".claude", "CLAUDE.md");
+    items.push(...readClaudeMd(userMd, CLAUDE_CODE_USER_AGENT_ID, "user"));
+
+    const projectsRoot = path.join(home, ".claude", "projects");
+    if (fs.existsSync(projectsRoot)) {
+      for (const slug of fs.readdirSync(projectsRoot)) {
+        const dir = path.join(projectsRoot, slug);
+        let stat;
+        try { stat = fs.statSync(dir); } catch { continue; }
+        if (!stat.isDirectory()) continue;
+        const cwd = await cwdForSlugDir(dir, slug);
+        if (!cwd) continue;
+        const agentId = agentIdForClaude(cwd);
+        const projMd = path.join(cwd, ".claude", "CLAUDE.md");
+        items.push(...readClaudeMd(projMd, agentId, "project"));
+        const memDir = path.join(dir, "memory");
+        items.push(...readMemoryDir(memDir, agentId, "project"));
+      }
+    }
+  } else {
+    const cwd = opts.projectCwd;
+    if (!cwd) return [];
+    const agentId = agentIdForClaude(cwd);
+    const projMd = path.join(cwd, ".claude", "CLAUDE.md");
+    items.push(...readClaudeMd(projMd, agentId, "project"));
+    const slug = slugifyCwd(cwd);
+    const memDir = path.join(home, ".claude", "projects", slug, "memory");
+    items.push(...readMemoryDir(memDir, agentId, "project"));
+  }
+
+  return items;
+}
+
+/**
+ * Parse a CLAUDE.md file into one item per top-level `# ` heading. If the
+ * file has no top-level headings, the whole body is one item.
+ *
+ * @param {string} filePath
+ * @param {string} agentId
+ * @param {"user"|"project"} scope
+ * @returns {MemoryItem[]}
+ */
+export function readClaudeMd(filePath, agentId, scope) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return [];
+  }
+  if (!raw.trim()) return [];
+
+  const sections = splitTopLevelSections(raw);
+  return sections.map((section) => {
+    const heading = section.heading;
+    const text = section.body.trim();
+    const name = heading || path.basename(filePath);
+    return {
+      agentId,
+      text,
+      hash: memoryHash(text, name),
+      name,
+      metadata: {
+        source: path.basename(filePath),
+        scope,
+        sourcePath: filePath,
+        ...(heading ? { heading } : {}),
+      },
+    };
+  });
+}
+
+/**
+ * Split on `^# ` (level-1) headings. Returns [{heading, body}...].
+ * Content before the first heading becomes a section with empty heading
+ * (dropped only if the body is also empty).
+ *
+ * @param {string} md
+ * @returns {{heading: string, body: string}[]}
+ */
+export function splitTopLevelSections(md) {
+  const lines = md.split("\n");
+  const sections = [];
+  let currentHeading = "";
+  let currentLines = [];
+  for (const line of lines) {
+    const m = /^#\s+(.*)$/.exec(line);
+    if (m) {
+      if (currentHeading || currentLines.some((l) => l.trim())) {
+        sections.push({ heading: currentHeading, body: currentLines.join("\n") });
+      }
+      currentHeading = m[1].trim();
+      currentLines = [];
+    } else {
+      currentLines.push(line);
+    }
+  }
+  if (currentHeading || currentLines.some((l) => l.trim())) {
+    sections.push({ heading: currentHeading, body: currentLines.join("\n") });
+  }
+  // If the file has zero headings, treat the whole thing as one anonymous section.
+  if (sections.length === 0) return [];
+  return sections.filter((s) => s.body.trim().length > 0);
+}
+
+/**
+ * Read `~/.claude/projects/<slug>/memory/*.md`. One item per file.
+ *
+ * @param {string} memDir
+ * @param {string} agentId
+ * @param {"user"|"project"} scope
+ * @returns {MemoryItem[]}
+ */
+export function readMemoryDir(memDir, agentId, scope) {
+  let entries;
+  try {
+    entries = fs.readdirSync(memDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    if (entry === "MEMORY.md") continue; // index-only
+    const full = path.join(memDir, entry);
+    let raw;
+    try {
+      raw = fs.readFileSync(full, "utf8");
+    } catch {
+      continue;
+    }
+    const { frontmatter, body } = parseFrontmatter(raw);
+    const text = body.trim();
+    if (!text) continue;
+    const name = frontmatter.name || entry.replace(/\.md$/, "");
+    out.push({
+      agentId,
+      text,
+      hash: memoryHash(text, name),
+      name,
+      metadata: {
+        source: `memory/${entry}`,
+        scope,
+        sourcePath: full,
+        ...(frontmatter.name ? { name: frontmatter.name } : {}),
+        ...(frontmatter.description ? { description: frontmatter.description } : {}),
+        ...(frontmatter.type ? { type: frontmatter.type } : {}),
+      },
+    });
+  }
+  return out;
+}
+
+/**
+ * Minimal YAML frontmatter parser. Supports `key: value` on a single line
+ * (bare or quoted). Returns `{frontmatter: {...}, body: string}`.
+ *
+ * @param {string} raw
+ * @returns {{frontmatter: object, body: string}}
+ */
+export function parseFrontmatter(raw) {
+  const m = /^---\s*\n([\s\S]*?)\n---\s*\n?/.exec(raw);
+  if (!m) return { frontmatter: {}, body: raw };
+  const fmText = m[1];
+  const body = raw.slice(m[0].length);
+  const frontmatter = {};
+  for (const line of fmText.split("\n")) {
+    const kv = /^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+    if (!kv) continue;
+    let val = kv[2].trim();
+    // strip surrounding quotes
+    if ((val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    frontmatter[kv[1]] = val;
+  }
+  return { frontmatter, body };
+}