@shahmilsaari/memory-core 1.0.22 → 1.0.26

package/dist/chunk-M7NKSXFS.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+
+// src/db.ts
+import pg from "pg";
+import { createHash } from "crypto";
+
+// src/config.ts
+import { config } from "dotenv";
+import { join } from "path";
+var localEnv = join(process.cwd(), ".memory-core.env");
+config({ path: localEnv });
+var Config = {
+  get databaseUrl() {
+    return process.env.DATABASE_URL ?? "";
+  },
+  get ollamaUrl() {
+    return process.env.OLLAMA_URL ?? "http://localhost:11434";
+  },
+  get ollamaModel() {
+    return process.env.OLLAMA_MODEL ?? "nomic-embed-text";
+  },
+  get chatModel() {
+    return process.env.CHAT_MODEL ?? process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
+  },
+  get chatProvider() {
+    return process.env.CHAT_PROVIDER ?? "ollama";
+  },
+  get chatApiKey() {
+    return process.env.CHAT_API_KEY ?? "";
+  }
+};
+
+// src/db.ts
+var { Pool } = pg;
+var pool = null;
+var migrationsRun = false;
+function readPositiveIntEnv(name, fallback) {
+  const raw = Number(process.env[name]);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : fallback;
+}
+function hashMemoryContent(content) {
+  return createHash("md5").update(content.trim()).digest("hex");
+}
+function getPool() {
+  if (!pool) {
+    if (!Config.databaseUrl) {
+      throw new Error("DATABASE_URL is not set. Add it to your .env or .memory-core.env file.");
+    }
+    const timeoutMs = readPositiveIntEnv("DATABASE_TIMEOUT_MS", 5e3);
+    pool = new Pool({
+      connectionString: Config.databaseUrl,
+      connectionTimeoutMillis: timeoutMs,
+      query_timeout: timeoutMs,
+      statement_timeout: timeoutMs
+    });
+  }
+  return pool;
+}
+async function runMigrations() {
+  if (migrationsRun) return;
+  const client = await getPool().connect();
+  try {
+    await client.query("BEGIN");
+    await client.query(`ALTER TABLE memories ALTER COLUMN scope SET DEFAULT 'project'`);
+    await client.query(`ALTER TABLE memories ADD COLUMN IF NOT EXISTS reason TEXT`);
+    await client.query(`ALTER TABLE memories ADD COLUMN IF NOT EXISTS content_hash TEXT`);
+    await client.query(`ALTER TABLE memories ADD COLUMN IF NOT EXISTS context JSONB NOT NULL DEFAULT '{}'::jsonb`);
+    await client.query(
+      `UPDATE memories
+       SET content_hash = md5(trim(content))
+       WHERE content_hash IS NULL`
+    );
+    await client.query(`CREATE INDEX IF NOT EXISTS memories_content_hash_idx ON memories (content_hash)`);
+    await client.query("COMMIT");
+    migrationsRun = true;
+  } catch (err) {
+    await client.query("ROLLBACK");
+    throw err;
+  } finally {
+    client.release();
+  }
+}
+async function saveMemory(memory) {
+  await runMigrations();
+  const { type, scope, architecture, projectName, title, content, reason, context, tags, embedding } = memory;
+  const contentHash = hashMemoryContent(content);
+  await getPool().query(
+    `INSERT INTO memories (type, scope, architecture, project_name, title, content, reason, context, tags, embedding, content_hash)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9, $10, $11)`,
+    [
+      type,
+      scope,
+      architecture ?? null,
+      projectName ?? null,
+      title ?? null,
+      content,
+      reason ?? null,
+      JSON.stringify(context ?? {}),
+      tags ?? [],
+      `[${embedding.join(",")}]`,
+      contentHash
+    ]
+  );
+}
+async function upsertMemory(memory) {
+  await runMigrations();
+  const contentHash = hashMemoryContent(memory.content);
+  const existing = await getPool().query(
+    `SELECT id FROM memories
+     WHERE content_hash = $1
+       AND COALESCE(architecture, '') = COALESCE($2, '')
+       AND scope = $3
+       AND type = $4
+     LIMIT 1`,
+    [contentHash, memory.architecture ?? null, memory.scope, memory.type]
+  );
+  if (existing.rowCount) return "skipped";
+  await saveMemory(memory);
+  return "inserted";
+}
+async function listMemories(filters = {}) {
+  await runMigrations();
+  const where = [];
+  const params = [];
+  if (filters.type) {
+    params.push(filters.type);
+    where.push(`type = $${params.length}`);
+  }
+  if (filters.scope) {
+    params.push(filters.scope);
+    where.push(`scope = $${params.length}`);
+  }
+  if (filters.architecture) {
+    if (Array.isArray(filters.architecture)) {
+      params.push(filters.architecture);
+      where.push(filters.includeGlobal ? `(architecture IS NULL OR architecture = ANY($${params.length}))` : `architecture = ANY($${params.length})`);
+    } else {
+      params.push(filters.architecture);
+      where.push(filters.includeGlobal ? `(architecture IS NULL OR architecture = $${params.length})` : `architecture = $${params.length}`);
+    }
+  }
+  if (filters.projectName) {
+    params.push(filters.projectName);
+    where.push(filters.includeGlobal ? `(project_name IS NULL OR project_name = $${params.length})` : `project_name = $${params.length}`);
+  }
+  if (filters.tags?.length) {
+    params.push(filters.tags);
+    where.push(`tags && $${params.length}::text[]`);
+  }
+  const limit = filters.limit ?? 200;
+  params.push(limit);
+  const result = await getPool().query(
+    `SELECT id, type, scope, architecture, project_name, title, content, reason, context, tags, content_hash
+     FROM memories
+     ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
+     ORDER BY id ASC
+     LIMIT $${params.length}`,
+    params
+  );
+  return result.rows;
+}
+async function getMemory(id) {
+  await runMigrations();
+  const result = await getPool().query(
+    `SELECT id, type, scope, architecture, project_name, title, content, reason, context, tags, content_hash
+     FROM memories
+     WHERE id = $1`,
+    [id]
+  );
+  return result.rows[0] ?? null;
+}
+async function deleteMemory(id) {
+  await runMigrations();
+  const result = await getPool().query(`DELETE FROM memories WHERE id = $1`, [id]);
+  return (result.rowCount ?? 0) > 0;
+}
+async function deleteMemories(filters) {
+  await runMigrations();
+  const where = [];
+  const params = [];
+  if (filters.type) {
+    params.push(filters.type);
+    where.push(`type = $${params.length}`);
+  }
+  if (filters.scope) {
+    params.push(filters.scope);
+    where.push(`scope = $${params.length}`);
+  }
+  if (filters.architecture) {
+    if (Array.isArray(filters.architecture)) {
+      params.push(filters.architecture);
+      where.push(`architecture = ANY($${params.length})`);
+    } else {
+      params.push(filters.architecture);
+      where.push(`architecture = $${params.length}`);
+    }
+  }
+  if (filters.tag) {
+    params.push(filters.tag);
+    where.push(`$${params.length} = ANY(tags)`);
+  }
+  if (where.length === 0) {
+    throw new Error("Refusing to bulk-delete without filters");
+  }
+  const result = await getPool().query(
+    `DELETE FROM memories WHERE ${where.join(" AND ")}`,
+    params
+  );
+  return result.rowCount ?? 0;
+}
+async function updateMemory(id, patch) {
+  await runMigrations();
+  const current = await getMemory(id);
+  if (!current) return null;
+  const content = patch.content ?? current.content;
+  const contentHash = hashMemoryContent(content);
+  const embedding = patch.embedding ? `[${patch.embedding.join(",")}]` : null;
+  const result = await getPool().query(
+    `UPDATE memories
+     SET type = $2,
+         scope = $3,
+         title = $4,
+         content = $5,
+         reason = $6,
+         context = $7::jsonb,
+         tags = $8,
+         content_hash = $9,
+         embedding = COALESCE($10::vector, embedding)
+     WHERE id = $1
+     RETURNING id, type, scope, architecture, project_name, title, content, reason, context, tags, content_hash`,
+    [
+      id,
+      patch.type ?? current.type,
+      patch.scope ?? current.scope,
+      patch.title ?? current.title ?? null,
+      content,
+      patch.reason ?? current.reason ?? null,
+      JSON.stringify(patch.context ?? current.context ?? {}),
+      patch.tags ?? current.tags ?? [],
+      contentHash,
+      embedding
+    ]
+  );
+  return result.rows[0] ?? null;
+}
+async function searchMemories(embedding, architectures, limit = 10) {
+  await runMigrations();
+  const vector = `[${embedding.join(",")}]`;
+  const params = [vector];
+  let whereClause = "";
+  const selectedArchitectures = architectures ? (Array.isArray(architectures) ? architectures : [architectures]).filter(Boolean) : [];
+  if (selectedArchitectures.length > 0) {
+    whereClause = `WHERE (
+      architecture = ANY($2)
+      OR architecture IS NULL
+      OR architecture = 'global'
+    )`;
+    params.push(selectedArchitectures);
+  }
+  const client = await getPool().connect();
+  try {
+    await client.query("BEGIN");
+    await client.query("SET LOCAL ivfflat.probes = 10");
+    const result = await client.query(
+      `SELECT id, type, scope, architecture, project_name, title, content, reason, context, tags,
+              1 - (embedding <=> $1) AS similarity
+       FROM memories
+       ${whereClause}
+       ORDER BY embedding <=> $1
+       LIMIT $${params.length + 1}`,
+      [...params, limit]
+    );
+    await client.query("COMMIT");
+    return result.rows;
+  } finally {
+    client.release();
+  }
+}
+async function closePool() {
+  if (pool) {
+    await pool.end();
+    pool = null;
+    migrationsRun = false;
+  }
+}
+
+export {
+  Config,
+  hashMemoryContent,
+  getPool,
+  runMigrations,
+  saveMemory,
+  upsertMemory,
+  listMemories,
+  getMemory,
+  deleteMemory,
+  deleteMemories,
+  updateMemory,
+  searchMemories,
+  closePool
+};

package/dist/chunk-PQBWHAZN.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+// src/chat.ts
+function getChatConfig() {
+  const provider = process.env.CHAT_PROVIDER ?? "ollama";
+  const model = process.env.CHAT_MODEL ?? process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
+  return {
+    provider,
+    model,
+    ollamaUrl: process.env.OLLAMA_URL ?? "http://localhost:11434",
+    apiKey: process.env.CHAT_API_KEY ?? "",
+    baseUrl: process.env.CHAT_BASE_URL ?? ""
+  };
+}
+function getDefaultTimeoutMs() {
+  const raw = Number(process.env.CHAT_TIMEOUT_MS ?? 6e4);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 6e4;
+}
+function timeoutSignal(timeoutMs) {
+  return AbortSignal.timeout(timeoutMs ?? getDefaultTimeoutMs());
+}
+function normalizeChatError(err, timeoutMs) {
+  const ms = timeoutMs ?? getDefaultTimeoutMs();
+  if (err instanceof Error && err.name === "AbortError") {
+    return new Error(`TIMEOUT:${ms}`);
+  }
+  if (err instanceof Error) {
+    return err;
+  }
+  return new Error(String(err));
+}
+async function callOllama(cfg, messages, options = {}) {
+  const res = await fetch(`${cfg.ollamaUrl}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    signal: timeoutSignal(options.timeoutMs),
+    body: JSON.stringify({ model: cfg.model, messages, stream: false, format: "json" })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    if (body.includes("not found") || body.includes("model")) {
+      throw new Error(`MODEL_NOT_FOUND:${cfg.model}`);
+    }
+    throw new Error(body);
+  }
+  const data = await res.json();
+  const inputTokens = data.prompt_eval_count ?? 0;
+  const outputTokens = data.eval_count ?? 0;
+  return {
+    content: data.message.content.trim(),
+    usage: inputTokens || outputTokens ? { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens } : void 0
+  };
+}
+async function callOpenAICompat(cfg, messages, options = {}) {
+  const base = (cfg.baseUrl ?? "").replace(/\/$/, "") || "https://api.openai.com/v1";
+  const res = await fetch(`${base}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${cfg.apiKey}`
+    },
+    signal: timeoutSignal(options.timeoutMs),
+    body: JSON.stringify({
+      model: cfg.model,
+      messages,
+      response_format: { type: "json_object" }
+    })
+  });
+  if (!res.ok) throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  const u = data.usage;
+  return {
+    content: data.choices[0].message.content.trim(),
+    usage: u ? { inputTokens: u.prompt_tokens, outputTokens: u.completion_tokens, totalTokens: u.total_tokens } : void 0
+  };
+}
+async function callAnthropic(cfg, messages, options = {}) {
+  const system = messages.find((m) => m.role === "system")?.content ?? "";
+  const userMessages = messages.filter((m) => m.role !== "system");
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": cfg.apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    signal: timeoutSignal(options.timeoutMs),
+    body: JSON.stringify({
+      model: cfg.model,
+      max_tokens: 4096,
+      system,
+      messages: userMessages
+    })
+  });
+  if (!res.ok) throw new Error(`Anthropic API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  const u = data.usage;
+  return {
+    content: data.content[0].text.trim(),
+    usage: u ? { inputTokens: u.input_tokens, outputTokens: u.output_tokens, totalTokens: u.input_tokens + u.output_tokens } : void 0
+  };
+}
+async function callMiniMax(cfg, messages, options = {}) {
+  const res = await fetch("https://api.minimax.io/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${cfg.apiKey}`
+    },
+    signal: timeoutSignal(options.timeoutMs),
+    body: JSON.stringify({
+      model: cfg.model,
+      messages,
+      response_format: { type: "json_object" }
+    })
+  });
+  if (!res.ok) throw new Error(`MiniMax API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  const u = data.usage;
+  return {
+    content: data.choices[0].message.content.trim(),
+    usage: u ? { inputTokens: u.prompt_tokens, outputTokens: u.completion_tokens, totalTokens: u.total_tokens } : void 0
+  };
+}
+async function callChatModel(messages, options = {}) {
+  const cfg = getChatConfig();
+  try {
+    switch (cfg.provider) {
+      case "openai":
+      case "openai-compatible":
+        return await callOpenAICompat(cfg, messages, options);
+      case "anthropic":
+        return await callAnthropic(cfg, messages, options);
+      case "minimax":
+        return await callMiniMax(cfg, messages, options);
+      default:
+        return await callOllama(cfg, messages, options);
+    }
+  } catch (err) {
+    throw normalizeChatError(err, options.timeoutMs);
+  }
+}
+function getChatProviderLabel() {
+  const cfg = getChatConfig();
+  if (cfg.provider === "ollama") return `ollama (${cfg.model})`;
+  if (cfg.provider === "openai-compatible") {
+    const host = cfg.baseUrl ? new URL(cfg.baseUrl).hostname : "custom";
+    return `openai-compat/${host} (${cfg.model})`;
+  }
+  return `${cfg.provider} (${cfg.model})`;
+}
+
+export {
+  callChatModel,
+  getChatProviderLabel
+};

package/dist/chunk-W6WEAV3S.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+// src/automation/approval-queue.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var QUEUE_FILE = "approval-queue.json";
+var ApprovalQueue = class {
+  constructor(configDir) {
+    this.configDir = configDir;
+    this.queuePath = join(configDir, QUEUE_FILE);
+  }
+  configDir;
+  queuePath;
+  load() {
+    if (!existsSync(this.queuePath)) return [];
+    return JSON.parse(readFileSync(this.queuePath, "utf-8"));
+  }
+  save(items) {
+    writeFileSync(this.queuePath, JSON.stringify(items, null, 2));
+  }
+  add(rule, source, confidence) {
+    const items = this.load();
+    const item = {
+      id: rule.id,
+      rule,
+      source,
+      confidence,
+      status: "pending",
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    items.push(item);
+    this.save(items);
+    return item;
+  }
+  approve(id) {
+    const items = this.load();
+    const item = items.find((i) => i.id === id);
+    if (!item) return false;
+    item.status = "approved";
+    this.save(items);
+    return true;
+  }
+  reject(id) {
+    const items = this.load();
+    const item = items.find((i) => i.id === id);
+    if (!item) return false;
+    item.status = "rejected";
+    this.save(items);
+    return true;
+  }
+  pending() {
+    return this.load().filter((i) => i.status === "pending");
+  }
+  persistApproved(rulesPath) {
+    const items = this.load();
+    const approved = items.filter((i) => i.status === "approved");
+    if (approved.length === 0) return 0;
+    const existing = existsSync(rulesPath) ? JSON.parse(readFileSync(rulesPath, "utf-8")).rules : [];
+    const merged = [...existing, ...approved.map((i) => i.rule)];
+    writeFileSync(rulesPath, JSON.stringify({ rules: merged }, null, 2));
+    const remaining = items.filter((i) => i.status !== "approved");
+    this.save(remaining);
+    return approved.length;
+  }
+};
+
+export {
+  ApprovalQueue
+};

package/dist/chunk-ZZBQEXEO.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+
+// src/infrastructure/ast/import-analysis.ts
+import { builtinModules } from "module";
+import { existsSync, readFileSync } from "fs";
+import { dirname, extname, isAbsolute, join, normalize, resolve } from "path";
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var NODE_BUILTINS = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((entry) => `node:${entry}`)]);
+function countNewlines(value) {
+  let count = 0;
+  for (const char of value) {
+    if (char === "\n") count += 1;
+  }
+  return count;
+}
+function parseImports(source) {
+  const imports = [];
+  const patterns = [
+    { kind: "import", regex: /(^|\n)\s*import\s+(?:type\s+)?(?:[^'"\n]+?\s+from\s+)?['"]([^'"\n]+)['"]/g },
+    { kind: "export-from", regex: /(^|\n)\s*export\s+(?:type\s+)?(?:[^'"\n]+?\s+from\s+)['"]([^'"\n]+)['"]/g },
+    { kind: "require", regex: /(^|\n)[^\n]*?\brequire\(\s*['"]([^'"\n]+)['"]\s*\)/g },
+    { kind: "dynamic-import", regex: /(^|\n)[^\n]*?\bimport\(\s*['"]([^'"\n]+)['"]\s*\)/g }
+  ];
+  for (const { kind, regex } of patterns) {
+    for (const match of source.matchAll(regex)) {
+      const prefix = source.slice(0, match.index ?? 0);
+      imports.push({
+        kind,
+        specifier: match[2],
+        line: countNewlines(prefix) + 1
+      });
+    }
+  }
+  return imports;
+}
+function tryResolveFilePath(candidate) {
+  if (existsSync(candidate)) return normalize(candidate);
+  if (!extname(candidate)) {
+    for (const ext of SOURCE_EXTENSIONS) {
+      const withExt = `${candidate}${ext}`;
+      if (existsSync(withExt)) return normalize(withExt);
+    }
+    for (const ext of SOURCE_EXTENSIONS) {
+      const indexFile = join(candidate, `index${ext}`);
+      if (existsSync(indexFile)) return normalize(indexFile);
+    }
+  }
+  return void 0;
+}
+function looksLikeExternal(specifier) {
+  return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("@/");
+}
+function resolveImportPath(fromFile, specifier, cwd = process.cwd()) {
+  if (specifier.startsWith(".")) {
+    return tryResolveFilePath(resolve(dirname(fromFile), specifier));
+  }
+  if (specifier.startsWith("/")) {
+    return tryResolveFilePath(resolve(cwd, `.${specifier}`));
+  }
+  if (specifier.startsWith("@/")) {
+    return tryResolveFilePath(resolve(cwd, "src", specifier.slice(2)));
+  }
+  if (isAbsolute(specifier)) {
+    return tryResolveFilePath(specifier);
+  }
+  return void 0;
+}
+function collectResolvedImports(filePath, cwd = process.cwd()) {
+  if (!existsSync(filePath)) return [];
+  const source = readFileSync(filePath, "utf-8");
+  const imports = parseImports(source);
+  return imports.map((entry) => {
+    if (looksLikeExternal(entry.specifier) || NODE_BUILTINS.has(entry.specifier)) {
+      return { ...entry, isExternal: true };
+    }
+    return {
+      ...entry,
+      isExternal: false,
+      resolvedPath: resolveImportPath(filePath, entry.specifier, cwd)
+    };
+  });
+}
+function asPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function moduleNameFromPath(absPath, cwd = process.cwd()) {
+  const rel = asPosix(normalize(absPath)).replace(asPosix(normalize(cwd)) + "/", "");
+  const match = rel.match(/^src\/modules\/([^/]+)\//);
+  return match?.[1];
+}
+function buildModuleDependencyEdges(files, cwd = process.cwd()) {
+  const edges = [];
+  for (const file of files) {
+    const absoluteFile = resolve(cwd, file);
+    const fromModule = moduleNameFromPath(absoluteFile, cwd);
+    if (!fromModule) continue;
+    const imports = collectResolvedImports(absoluteFile, cwd);
+    for (const imp of imports) {
+      if (!imp.resolvedPath) continue;
+      const toModule = moduleNameFromPath(imp.resolvedPath, cwd);
+      if (!toModule || toModule === fromModule) continue;
+      edges.push({
+        fromModule,
+        toModule,
+        file,
+        line: imp.line
+      });
+    }
+  }
+  return edges;
+}
+function parseChangedFilesFromDiff(diff) {
+  const files = /* @__PURE__ */ new Set();
+  for (const line of diff.split("\n")) {
+    if (!line.startsWith("+++ b/")) continue;
+    const file = line.slice("+++ b/".length).trim();
+    if (!file || file === "/dev/null") continue;
+    files.add(file);
+  }
+  return [...files];
+}
+function detectModuleCycles(edges) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const next = graph.get(edge.fromModule) ?? /* @__PURE__ */ new Set();
+    next.add(edge.toModule);
+    graph.set(edge.fromModule, next);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const cycles = /* @__PURE__ */ new Set();
+  const visit = (node, path) => {
+    visited.add(node);
+    stack.add(node);
+    const next = graph.get(node) ?? /* @__PURE__ */ new Set();
+    for (const target of next) {
+      if (!visited.has(target)) {
+        visit(target, [...path, target]);
+        continue;
+      }
+      if (stack.has(target)) {
+        const start = path.indexOf(target);
+        const cycle = start >= 0 ? path.slice(start).concat(target) : [node, target, node];
+        cycles.add(cycle.join("->"));
+      }
+    }
+    stack.delete(node);
+  };
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      visit(node, [node]);
+    }
+  }
+  return [...cycles].map((value) => value.split("->"));
+}
+function isExternalFrameworkSpecifier(specifier) {
+  const frameworkPrefixes = [
+    "express",
+    "fastify",
+    "@nestjs/",
+    "react",
+    "vue",
+    "svelte",
+    "@angular/",
+    "next/",
+    "nuxt",
+    "typeorm",
+    "@prisma/",
+    "mongoose",
+    "sequelize",
+    "axios"
+  ];
+  return frameworkPrefixes.some((prefix) => specifier === prefix || specifier.startsWith(`${prefix}/`));
+}
+
+export {
+  parseImports,
+  collectResolvedImports,
+  buildModuleDependencyEdges,
+  parseChangedFilesFromDiff,
+  detectModuleCycles,
+  isExternalFrameworkSpecifier
+};