convoptics 0.1.0

package/src/cursor/scanner.js

@@ -0,0 +1,167 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import Database from 'better-sqlite3';
+
+export function defaultCursorRoot() {
+  const home = os.homedir();
+  if (process.platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'Cursor', 'User');
+  }
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    return path.join(appData, 'Cursor', 'User');
+  }
+  return path.join(home, '.config', 'Cursor', 'User');
+}
+
+function fileUriToPath(uri) {
+  if (typeof uri !== 'string') return null;
+  if (!uri.startsWith('file://')) return uri;
+  try {
+    const url = new URL(uri);
+    let pathname = decodeURIComponent(url.pathname);
+    if (process.platform === 'win32' && /^\/[A-Za-z]:/.test(pathname)) {
+      pathname = pathname.slice(1);
+    }
+    return pathname;
+  } catch {
+    return uri;
+  }
+}
+
+function isoFromMs(ms) {
+  if (typeof ms !== 'number' || !Number.isFinite(ms) || ms <= 0) return null;
+  try {
+    return new Date(ms).toISOString();
+  } catch {
+    return null;
+  }
+}
+
+function parseJsonValue(value) {
+  if (value === null || value === undefined) return null;
+  const text = Buffer.isBuffer(value) ? value.toString('utf8') : String(value);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+async function buildRegistry(workspaceStorageDir) {
+  const registry = new Map();
+  let entries;
+  try {
+    entries = await fs.readdir(workspaceStorageDir, { withFileTypes: true });
+  } catch {
+    return registry;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const wsPath = path.join(workspaceStorageDir, entry.name);
+    const wsJsonPath = path.join(wsPath, 'workspace.json');
+    const wsDbPath = path.join(wsPath, 'state.vscdb');
+
+    let folder = null;
+    try {
+      const raw = await fs.readFile(wsJsonPath, 'utf8');
+      const wsJson = JSON.parse(raw);
+      folder = fileUriToPath(wsJson.folder);
+    } catch {
+      // workspace.json missing or unreadable — leave folder null
+    }
+
+    let db;
+    try {
+      db = new Database(wsDbPath, { readonly: true, fileMustExist: true });
+    } catch {
+      continue;
+    }
+
+    try {
+      const row = db
+        .prepare('SELECT value FROM ItemTable WHERE key = ?')
+        .get('composer.composerData');
+      const data = parseJsonValue(row?.value);
+      if (!data || !Array.isArray(data.allComposers)) continue;
+      for (const c of data.allComposers) {
+        if (!c || !c.composerId) continue;
+        registry.set(c.composerId, {
+          cwd: folder,
+          branch: c.createdOnBranch ?? null,
+          name: c.name ?? null,
+          subtitle: c.subtitle ?? null,
+          isArchived: !!c.isArchived,
+        });
+      }
+    } finally {
+      db.close();
+    }
+  }
+
+  return registry;
+}
+
+export async function* scanSessions(root) {
+  const globalDbPath = path.join(root, 'globalStorage', 'state.vscdb');
+  const wsDir = path.join(root, 'workspaceStorage');
+
+  try {
+    await fs.access(globalDbPath);
+  } catch {
+    return;
+  }
+
+  const registry = await buildRegistry(wsDir);
+
+  const gdb = new Database(globalDbPath, { readonly: true, fileMustExist: true });
+  try {
+    const composerStmt = gdb.prepare(
+      "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'",
+    );
+    const countStmt = gdb.prepare(
+      'SELECT COUNT(*) AS n FROM cursorDiskKV WHERE key LIKE ?',
+    );
+
+    for (const row of composerStmt.iterate()) {
+      const composerId = row.key.slice('composerData:'.length);
+      if (!composerId) continue;
+      const header = parseJsonValue(row.value);
+      if (!header) continue;
+
+      const meta = registry.get(composerId) ?? {};
+      const { n: bubbleCount } = countStmt.get(`bubbleId:${composerId}:%`);
+
+      const conversationOrder = Array.isArray(header.conversation)
+        ? header.conversation.map((c) => c?.bubbleId).filter(Boolean)
+        : [];
+
+      yield {
+        path: globalDbPath,
+        sessionId: composerId,
+        projectFolder: meta.cwd ? path.basename(meta.cwd) : null,
+        cwd: meta.cwd ?? null,
+        gitBranch: meta.branch ?? null,
+        version: null,
+        startedAt: isoFromMs(header.createdAt),
+        endedAt: isoFromMs(header.lastUpdatedAt),
+        summary: meta.name ?? header.name ?? null,
+        messageCount: bubbleCount ?? 0,
+        malformedCount: 0,
+        tokens: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
+        tokensByModel: {},
+        _cursor: {
+          dbPath: globalDbPath,
+          composerId,
+          isArchived: !!meta.isArchived,
+          subtitle: meta.subtitle ?? null,
+          conversationOrder,
+        },
+      };
+    }
+  } finally {
+    gdb.close();
+  }
+}

package/src/matcher.js

@@ -0,0 +1,63 @@
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+  const tokens = escaped.split('**').map((part) => part.replace(/\*/g, '[^/]*'));
+  return new RegExp(`^${tokens.join('.*')}$`, 'i');
+}
+
+function matchesGlob(value, pattern) {
+  if (pattern === value) {
+    return true;
+  }
+  const regex = globToRegExp(pattern);
+  return regex.test(value);
+}
+
+function isoDatePart(value) {
+  if (!value || typeof value !== 'string') return null;
+  const date = value.slice(0, 10);
+  return date.match(/^\d{4}-\d{2}-\d{2}$/) ? date : null;
+}
+
+export function match(filter, session) {
+  if (filter.branch) {
+    if (!session.gitBranch) {
+      return false;
+    }
+    const branchMatch = filter.branch.some((pattern) => matchesGlob(session.gitBranch, pattern));
+    if (!branchMatch) return false;
+  }
+
+  if (filter.cwd) {
+    if (!session.cwd) return false;
+    const cwdLower = session.cwd.toLowerCase();
+    const anyCwd = filter.cwd.some((token) => cwdLower.includes(token.toLowerCase()));
+    if (!anyCwd) return false;
+  }
+
+  if (filter.project) {
+    const anyProject = filter.project.some((token) => token === session.projectFolder);
+    if (!anyProject) return false;
+  }
+
+  if (filter.session) {
+    const anySession = filter.session.some((token) => session.sessionId.startsWith(token));
+    if (!anySession) return false;
+  }
+
+  if (filter.version) {
+    const anyVersion = filter.version.some((token) => token === session.version);
+    if (!anyVersion) return false;
+  }
+
+  if (filter.date) {
+    const started = isoDatePart(session.startedAt);
+    if (!started) return false;
+    if (filter.date.eq && started !== filter.date.eq) return false;
+    if (filter.date.gte && started < filter.date.gte) return false;
+    if (filter.date.lte && started > filter.date.lte) return false;
+    if (filter.date.gt && started <= filter.date.gt) return false;
+    if (filter.date.lt && started >= filter.date.lt) return false;
+  }
+
+  return true;
+}

package/src/query.js

@@ -0,0 +1,108 @@
+const VALID_KEYS = new Set(['tool', 'branch', 'cwd', 'project', 'session', 'version', 'date', 'diffs']);
+const VALID_TOOLS = new Set(['claude-code', 'cursor']);
+const TOOL_UNSUPPORTED_KEYS = {
+  cursor: new Set(['version']),
+};
+const DATE_OPERATORS = new Set([':', '=', '>=', '<=', '>', '<']);
+const DIFFS_VALUES = new Set(['diffs', 'no-diffs']);
+
+export function parseQuery(argv) {
+  const spec = {
+    tool: null,
+    branch: [],
+    cwd: [],
+    project: [],
+    session: [],
+    version: [],
+    date: {},
+    diffs: 'diffs',
+  };
+
+  if (!Array.isArray(argv)) {
+    throw new Error('parseQuery expects an array of arguments');
+  }
+
+  for (const token of argv) {
+    if (!token || typeof token !== 'string') {
+      throw new Error(`Invalid query token: ${token}`);
+    }
+
+    const match = token.match(/^(\w+)(>=|<=|:|=|>|<)(.+)$/);
+    if (!match) {
+      throw new Error(`Invalid query token: ${token}`);
+    }
+
+    const [, key, op, rawValue] = match;
+    if (!VALID_KEYS.has(key)) {
+      throw new Error(`Unknown query key: ${key}`);
+    }
+
+    const value = rawValue.trim();
+    if (!value) {
+      throw new Error(`Empty value for query token: ${token}`);
+    }
+
+    if (key === 'date') {
+      if (!DATE_OPERATORS.has(op)) {
+        throw new Error(`Invalid date operator in token: ${token}`);
+      }
+      const normalized = op === ':' ? 'eq' : op === '=' ? 'eq' : op === '>=' ? 'gte' : op === '<=' ? 'lte' : op === '>' ? 'gt' : 'lt';
+      spec.date[normalized] = value;
+      continue;
+    }
+
+    if (op !== ':' && op !== '=') {
+      throw new Error(`Operator ${op} not supported for ${key} in token: ${token}`);
+    }
+
+    switch (key) {
+      case 'tool':
+        spec.tool = value;
+        break;
+      case 'diffs':
+        if (!DIFFS_VALUES.has(value)) {
+          throw new Error(`Invalid value for diffs (expected "diffs" or "no-diffs"): ${value}`);
+        }
+        spec.diffs = value;
+        break;
+      case 'branch':
+      case 'cwd':
+      case 'project':
+      case 'session':
+      case 'version':
+        spec[key].push(value);
+        break;
+      default:
+        throw new Error(`Unsupported query key: ${key}`);
+    }
+  }
+
+  if (!spec.tool) {
+    throw new Error('Missing required filter: tool');
+  }
+  if (!VALID_TOOLS.has(spec.tool)) {
+    throw new Error(`Unknown tool: ${spec.tool} (expected one of ${[...VALID_TOOLS].join(', ')})`);
+  }
+
+  const unsupported = TOOL_UNSUPPORTED_KEYS[spec.tool];
+  if (unsupported) {
+    for (const key of unsupported) {
+      if (spec[key] && spec[key].length > 0) {
+        throw new Error(`Filter "${key}:" is not supported for tool:${spec.tool}`);
+      }
+    }
+  }
+
+  // Normalize empty arrays to undefined for easier matcher handling.
+  for (const key of ['branch', 'cwd', 'project', 'session', 'version']) {
+    if (spec[key].length === 0) {
+      delete spec[key];
+    }
+  }
+
+  if (Object.keys(spec.date).length === 0) {
+    delete spec.date;
+  }
+
+  return spec;
+}