@hasna/mementos 0.10.2 → 0.10.4

package/dist/cli/index.js

@@ -6920,6 +6920,13 @@ function listAgents(db) {
   const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
   return rows.map(parseAgentRow);
 }
+function touchAgent(idOrName, db) {
+  const d = db || getDatabase();
+  const agent = getAgent(idOrName, d);
+  if (!agent)
+    return;
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), agent.id]);
+}
 function updateAgent(id, updates, db) {
   const d = db || getDatabase();
   const agent = getAgent(id, d);
@@ -6960,6 +6967,40 @@ function updateAgent(id, updates, db) {
   return getAgent(agent.id, d);
 }
 
+// src/lib/focus.ts
+init_hooks();
+var sessionFocus = new Map;
+function setFocus(agentId, projectId) {
+  const previous = getFocusCached(agentId);
+  sessionFocus.set(agentId, projectId);
+  updateAgent(agentId, { active_project_id: projectId });
+  if (projectId && projectId !== previous) {
+    hookRegistry.runHooks("OnSessionStart", {
+      agentId,
+      projectId,
+      timestamp: Date.now()
+    });
+  } else if (!projectId && previous) {
+    hookRegistry.runHooks("OnSessionEnd", {
+      agentId,
+      projectId: previous,
+      timestamp: Date.now()
+    });
+  }
+}
+function getFocusCached(agentId) {
+  return sessionFocus.get(agentId) ?? null;
+}
+function getFocus(agentId) {
+  if (sessionFocus.has(agentId)) {
+    return sessionFocus.get(agentId) ?? null;
+  }
+  const agent = getAgent(agentId);
+  const projectId = agent?.active_project_id ?? null;
+  sessionFocus.set(agentId, projectId);
+  return projectId;
+}
+
 // src/db/projects.ts
 init_database();
 function parseProjectRow(row) {
@@ -10832,4 +10873,52 @@ session_end = "bun ${script}"`));
     console.log("Usage: mementos session setup-hook --claude | --codex");
   }
 });
+program2.command("heartbeat [agent-id]").description("Update last_seen_at to signal this agent is active").action((agentId) => {
+  const globalOpts = program2.opts();
+  const id = agentId || globalOpts.agent;
+  if (!id) {
+    process.stderr.write(`Agent ID required. Use --agent or pass as argument.
+`);
+    process.exit(1);
+  }
+  const agent = getAgent(id);
+  if (!agent) {
+    process.stderr.write(`Agent not found: ${id}
+`);
+    process.exit(1);
+  }
+  touchAgent(agent.id);
+  if (globalOpts.json)
+    console.log(JSON.stringify({ agent_id: agent.id, name: agent.name, last_seen_at: new Date().toISOString() }));
+  else
+    console.log(chalk.green(`\u2665 ${agent.name} (${agent.id}) \u2014 heartbeat sent`));
+});
+program2.command("set-focus [project]").description("Focus this agent on a project (or clear focus if no project given)").option("--agent <id>", "Agent ID").action((project, opts) => {
+  const globalOpts = program2.opts();
+  const agentId = opts?.agent || globalOpts.agent;
+  if (!agentId) {
+    process.stderr.write(`Agent ID required. Use --agent.
+`);
+    process.exit(1);
+  }
+  setFocus(agentId, project ?? null);
+  if (project)
+    console.log(chalk.green(`Focused: ${agentId} \u2192 project ${project}`));
+  else
+    console.log(chalk.dim(`Focus cleared for ${agentId}`));
+});
+program2.command("get-focus").description("Show the current project focus for an agent").option("--agent <id>", "Agent ID").action((opts) => {
+  const globalOpts = program2.opts();
+  const agentId = opts?.agent || globalOpts.agent;
+  if (!agentId) {
+    process.stderr.write(`Agent ID required. Use --agent.
+`);
+    process.exit(1);
+  }
+  const focus = getFocus(agentId);
+  if (focus)
+    console.log(chalk.cyan(`Focus: ${focus}`));
+  else
+    console.log(chalk.dim("No focus set."));
+});
 program2.parse(process.argv);

package/dist/lib/file-deps.d.ts

@@ -0,0 +1,27 @@
+/**
+ * File dependency graph builder for open-mementos.
+ * Scans a codebase, creates 'file' entities for each source file, and
+ * creates 'depends_on' relations between files based on import/require statements.
+ *
+ * Supports: TypeScript, JavaScript, Python, Go (basic), Rust (basic).
+ */
+import type { Database } from "bun:sqlite";
+export interface FileDepsOptions {
+    root_dir: string;
+    project_id?: string;
+    extensions?: string[];
+    exclude_patterns?: string[];
+    incremental?: boolean;
+}
+export interface FileDepsResult {
+    files_scanned: number;
+    entities_created: number;
+    entities_updated: number;
+    relations_created: number;
+    errors: string[];
+}
+/**
+ * Scan a codebase, create file entities and import-based depends_on relations.
+ */
+export declare function buildFileDependencyGraph(opts: FileDepsOptions, db?: Database): Promise<FileDepsResult>;
+//# sourceMappingURL=file-deps.d.ts.map

package/dist/lib/file-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-deps.d.ts","sourceRoot":"","sources":["../../src/lib/file-deps.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAK3C,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAgFD;;GAEG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,eAAe,EACrB,EAAE,CAAC,EAAE,QAAQ,GACZ,OAAO,CAAC,cAAc,CAAC,CAwFzB"}

package/dist/mcp/index.js

@@ -7651,6 +7651,163 @@ var FORMAT_UNITS = [
 
 // src/mcp/index.ts
 init_hooks();
+
+// src/lib/file-deps.ts
+init_database();
+init_entities();
+init_relations();
+import { readdirSync, readFileSync, statSync, existsSync as existsSync3 } from "fs";
+import { join as join3, resolve as resolve3, relative, dirname as dirname3, extname, basename as basename2 } from "path";
+var DEFAULT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".rs"];
+var DEFAULT_EXCLUDES = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "target", "vendor"];
+function parseImports(_filePath, content) {
+  const imports = [];
+  const tsImports = [
+    /import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/g,
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+  ];
+  for (const re of tsImports) {
+    let m2;
+    re.lastIndex = 0;
+    while ((m2 = re.exec(content)) !== null) {
+      const imp = m2[1];
+      if (imp.startsWith("."))
+        imports.push(imp);
+    }
+  }
+  const pyImports = /^(?:from\s+(\.+[\w.]*)|import\s+([\w.]+))/gm;
+  let m;
+  while ((m = pyImports.exec(content)) !== null) {
+    const imp = m[1] || m[2];
+    if (imp && imp.startsWith("."))
+      imports.push(imp);
+  }
+  return [...new Set(imports)];
+}
+function resolveImport(fromFile, importPath, allFiles) {
+  const dir = dirname3(fromFile);
+  const base = resolve3(dir, importPath);
+  if (allFiles.has(base))
+    return base;
+  for (const ext of [".ts", ".tsx", ".js", ".jsx", ".mjs"]) {
+    const withExt = base + ext;
+    if (allFiles.has(withExt))
+      return withExt;
+    const index = join3(base, `index${ext}`);
+    if (allFiles.has(index))
+      return index;
+  }
+  return null;
+}
+function collectFiles(dir, extensions, excludes) {
+  const files = [];
+  function walk(current) {
+    let entries;
+    try {
+      entries = readdirSync(current);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (excludes.some((e) => entry === e || current.includes(`/${e}/`)))
+        continue;
+      const full = join3(current, entry);
+      let stat;
+      try {
+        stat = statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        walk(full);
+      } else if (extensions.includes(extname(entry))) {
+        files.push(full);
+      }
+    }
+  }
+  walk(resolve3(dir));
+  return files;
+}
+async function buildFileDependencyGraph(opts, db) {
+  const d = db || getDatabase();
+  const result = { files_scanned: 0, entities_created: 0, entities_updated: 0, relations_created: 0, errors: [] };
+  const extensions = opts.extensions ?? DEFAULT_EXTENSIONS;
+  const excludes = opts.exclude_patterns ?? DEFAULT_EXCLUDES;
+  const rootDir = resolve3(opts.root_dir);
+  if (!existsSync3(rootDir)) {
+    result.errors.push(`Directory not found: ${rootDir}`);
+    return result;
+  }
+  const files = collectFiles(rootDir, extensions, excludes);
+  const fileSet = new Set(files);
+  result.files_scanned = files.length;
+  const entityMap = new Map;
+  const existingEntities = listEntities({ type: "file", project_id: opts.project_id, limit: 1e4 }, d);
+  for (const e of existingEntities) {
+    if (e.metadata?.["file_path"]) {
+      entityMap.set(e.metadata["file_path"], e.id);
+    }
+  }
+  for (const filePath of files) {
+    const relPath = relative(rootDir, filePath);
+    const name = basename2(filePath);
+    if (entityMap.has(filePath)) {
+      result.entities_updated++;
+      continue;
+    }
+    try {
+      const entity = createEntity({
+        type: "file",
+        name,
+        description: relPath,
+        project_id: opts.project_id,
+        metadata: { file_path: filePath, rel_path: relPath, ext: extname(filePath), root_dir: rootDir }
+      }, d);
+      entityMap.set(filePath, entity.id);
+      result.entities_created++;
+    } catch (e) {
+      result.errors.push(`Entity creation failed for ${relPath}: ${String(e)}`);
+    }
+  }
+  for (const filePath of files) {
+    const fromId = entityMap.get(filePath);
+    if (!fromId)
+      continue;
+    let content;
+    try {
+      content = readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const imports = parseImports(filePath, content);
+    for (const imp of imports) {
+      const resolvedPath = resolveImport(filePath, imp, fileSet);
+      if (!resolvedPath)
+        continue;
+      const toId = entityMap.get(resolvedPath);
+      if (!toId || toId === fromId)
+        continue;
+      try {
+        const existing = listRelations({ entity_id: fromId, relation_type: "depends_on", direction: "outgoing" }, d);
+        if (existing.some((r) => r.target_entity_id === toId))
+          continue;
+        createRelation({
+          source_entity_id: fromId,
+          target_entity_id: toId,
+          relation_type: "depends_on",
+          metadata: { import_path: imp, project_id: opts.project_id }
+        }, d);
+        result.relations_created++;
+      } catch (e) {
+        result.errors.push(`Relation failed ${relative(rootDir, filePath)} \u2192 ${relative(rootDir, resolvedPath)}: ${String(e)}`);
+      }
+    }
+  }
+  return result;
+}
+
+// src/mcp/index.ts
 init_built_in_hooks();
 init_webhook_hooks();
 
@@ -10323,6 +10480,26 @@ server.tool("graph_stats", "Get entity and relation counts by type.", {}, async
     return { content: [{ type: "text", text: formatError(e) }], isError: true };
   }
 });
+server.tool("build_file_dep_graph", "Scan a codebase directory and build a file dependency graph: creates 'file' entities and 'depends_on' relations based on import/require statements. Use graph_query to find blast radius of a file change.", {
+  root_dir: exports_external.string().describe("Root directory to scan"),
+  project_id: exports_external.string().optional().describe("Project to associate file entities with"),
+  extensions: exports_external.array(exports_external.string()).optional().describe("File extensions to scan (default: .ts .tsx .js .jsx .py .go .rs)"),
+  exclude_patterns: exports_external.array(exports_external.string()).optional().describe("Directory/file patterns to skip (default: node_modules, dist, .git, etc.)"),
+  incremental: exports_external.boolean().optional().describe("Skip files that already have entities (default: true)")
+}, async (args) => {
+  try {
+    const result = await buildFileDependencyGraph({
+      root_dir: args.root_dir,
+      project_id: args.project_id ? resolvePartialId(getDatabase(), "projects", args.project_id) ?? args.project_id : undefined,
+      extensions: args.extensions,
+      exclude_patterns: args.exclude_patterns,
+      incremental: args.incremental ?? true
+    });
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
 var FULL_SCHEMAS = {
   memory_save: {
     description: "Save/upsert a memory. Creates new or merges with existing key.",
@@ -10988,6 +11165,17 @@ server.tool("set_focus", "Set focus for an agent on a project. Memory ops will a
     return { content: [{ type: "text", text: formatError(e) }], isError: true };
   }
 });
+server.tool("heartbeat", "Update agent last_seen_at to signal active session. Call periodically during long tasks to prevent being marked stale.", { agent_id: exports_external.string().describe("Agent ID or name") }, async (args) => {
+  try {
+    const agent = getAgent(args.agent_id);
+    if (!agent)
+      return { content: [{ type: "text", text: `Agent not found: ${args.agent_id}` }], isError: true };
+    touchAgent(agent.id);
+    return { content: [{ type: "text", text: `\u2665 ${agent.name} (${agent.id}) \u2014 last_seen_at updated` }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
 server.tool("get_focus", "Get the current focus project for an agent.", { agent_id: exports_external.string() }, async (args) => {
   try {
     const projectId = getFocus(args.agent_id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/mementos",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Universal memory system for AI agents - CLI + MCP server + library API",
   "type": "module",
   "main": "dist/index.js",