@bcmyguest/openmem 0.0.0-stage → 0.8.0

package/cli/coding-agent/bank-from-cwd.mjs

@@ -0,0 +1,140 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseDocument } from "yaml";
+
+const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+
+function validGitEntry(root) {
+  const entry = path.join(root, ".git");
+  try {
+    const stat = fs.statSync(entry);
+    if (stat.isDirectory()) return fs.existsSync(path.join(entry, "HEAD")) && fs.existsSync(path.join(entry, "config"));
+    if (!stat.isFile()) return false;
+    const match = /^gitdir:\s*(.+)\s*$/m.exec(fs.readFileSync(entry, "utf8"));
+    if (!match) return false;
+    const gitDir = path.resolve(root, match[1]);
+    return fs.statSync(gitDir).isDirectory()
+      && (fs.existsSync(path.join(gitDir, "HEAD")) || fs.existsSync(path.join(gitDir, "commondir")));
+  } catch { return false; }
+}
+
+function projectRoot(cwd) {
+  try {
+    if (!fs.statSync(cwd).isDirectory()) return cwd;
+  } catch { return cwd; }
+  let candidate = cwd;
+  while (true) {
+    if (validGitEntry(candidate)) return candidate;
+    const parent = path.dirname(candidate);
+    if (parent === candidate) return cwd;
+    candidate = parent;
+  }
+}
+
+function projectName(root) {
+  try {
+    const gitEntry = path.join(root, ".git");
+    const stat = fs.statSync(gitEntry);
+    let gitDir = gitEntry;
+    if (stat.isFile()) {
+      const match = /^gitdir:\s*(.+)\s*$/m.exec(fs.readFileSync(gitEntry, "utf8"));
+      if (match) gitDir = path.resolve(root, match[1]);
+    }
+    const commonFile = path.join(gitDir, "commondir");
+    const commonPath = fs.existsSync(commonFile)
+      ? path.resolve(gitDir, fs.readFileSync(commonFile, "utf8").trim())
+      : gitDir;
+    // Only linked worktrees use a shared project's name. Submodules retain their own repository name.
+    if (path.basename(path.dirname(gitDir)) === "worktrees" && path.basename(commonPath) === ".git") {
+      return path.basename(path.dirname(commonPath));
+    }
+  } catch { /* non-git workspace */ }
+  return path.basename(root);
+}
+
+function expandPrefix(prefix, home) {
+  if (typeof prefix !== "string" || !prefix.trim()) return null;
+  let expanded = prefix;
+  if (prefix === "~" || prefix.startsWith("~/")) {
+    expanded = prefix === "~" ? home : path.join(home, prefix.slice(2));
+  } else if (prefix.startsWith("~")) {
+    const slash = prefix.indexOf(path.sep);
+    const username = slash < 0 ? prefix.slice(1) : prefix.slice(1, slash);
+    if (!username) return null;
+    let userHome = null;
+    try {
+      userHome = fs.readFileSync("/etc/passwd", "utf8").split(/\r?\n/)
+        .map((line) => line.split(":"))
+        .find((fields) => fields[0] === username)?.[5] || null;
+    } catch { /* passwd is not available on every platform */ }
+    if (!userHome && username === os.userInfo().username) userHome = home;
+    if (!userHome) return null;
+    expanded = slash < 0 ? userHome : path.join(userHome, prefix.slice(slash + 1));
+  }
+  if (!path.isAbsolute(expanded)) return null;
+  return path.resolve(expanded);
+}
+
+function matchingBank(target, mappings, home) {
+  if (!mappings || typeof mappings !== "object" || Array.isArray(mappings)) return null;
+  return Object.entries(mappings)
+    .filter(([prefix, bank]) => typeof bank === "string" && bank.trim() && expandPrefix(prefix, home))
+    .map(([prefix, bank]) => [expandPrefix(prefix, home), bank.trim()])
+    .filter(([prefix]) => target === prefix || target.startsWith(`${prefix}${path.sep}`))
+    .sort(([a], [b]) => b.length - a.length)[0]?.[1] || null;
+}
+
+function readJson(file) {
+  try {
+    const value = JSON.parse(fs.readFileSync(file, "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch { return {}; }
+}
+
+function yamlBanks(file, home) {
+  const source = fs.readFileSync(file, "utf8");
+  const document = parseDocument(source, { uniqueKeys: true, version: "1.1" });
+  if (document.errors.length) throw new Error(`${file}: ${document.errors[0].message}`);
+  const data = document.toJS() ?? {};
+  if (typeof data !== "object" || Array.isArray(data)) throw new Error(`${file}: expected a YAML mapping`);
+  const banks = Object.hasOwn(data, "banks")
+    ? data.banks
+    : { "~/Documents/sample-project": "coding-agent::documents-sample-project" };
+  if (!banks || typeof banks !== "object" || Array.isArray(banks)) throw new Error(`${file}: banks must be a mapping`);
+  const result = {};
+  for (const [key, value] of Object.entries(banks)) {
+    if (typeof key !== "string" || !key.trim()) throw new Error(`${file}: banks key must be a non-empty string`);
+    if (typeof value !== "string" || !value.trim()) throw new Error(`${file}: banks[${key}] must be a non-empty bank id string`);
+    const prefix = expandPrefix(key, home);
+    if (!prefix) throw new Error(`${file}: banks key must be an absolute path: ${key}`);
+    result[prefix] = value;
+  }
+  return result;
+}
+
+function configuredBanks(home, env) {
+  const override = env.HINDSIGHT_INDEX_CONFIG;
+  const user = path.join(home, ".config", "hindsight", "index.yml");
+  const configFile = override ? (expandPrefix(override, home) || path.resolve(override))
+    : fs.existsSync(user) ? user : path.join(PKG_ROOT, "config", "index.yml");
+  return yamlBanks(configFile, home);
+}
+
+/** Map a workspace cwd to the indexer's project bank. */
+export function bankFromCwd(cwd, options = {}) {
+  const dir = path.resolve(String(cwd || process.cwd()));
+  const root = projectRoot(dir);
+  const home = options.home || process.env.HOME || os.homedir();
+  const env = options.env || process.env;
+  const indexBanks = options.banks || configuredBanks(home, env);
+  const personalConfig = readJson(path.join(home, ".config", "personal-memory", "coding-agent.json"));
+  const legacyConfig = readJson(path.join(home, ".hindsight", "coding-agent.json"));
+  const mappingTarget = root === dir ? dir : root;
+  for (const mapping of [indexBanks, options.mapPathToBank || personalConfig.mapPathToBank, legacyConfig.mapPathToBank]) {
+    const bank = matchingBank(mappingTarget, mapping, home);
+    if (bank) return bank;
+  }
+  return `coding-agent::${projectName(root) || "workspace"}`;
+}

package/cli/coding-agent/capabilities.mjs

@@ -0,0 +1,34 @@
+/** Session-memory hook parity vs Hindsight plugin (non-Hindsight uses MCP shim). */
+
+import { CODING_AGENTS, DEFAULT_AGENT_IDS } from "./agents.mjs";
+
+export const AGENT_IDS = Object.freeze(CODING_AGENTS.map((a) => a.id));
+export { DEFAULT_AGENT_IDS };
+
+/**
+ * @typedef {"retain" | "recall" | "reflect" | "consolidate" | "bank_scope" | "knowledge_pages" | "initiatives" | "ingest_status"} Feature
+ */
+
+/** @type {Record<string, Partial<Record<Feature, boolean>>>} */
+export const PROVIDER_CAPABILITIES = {
+  hindsight: {
+    retain: true,
+    recall: true,
+    reflect: true,
+    consolidate: true,
+    bank_scope: true,
+    knowledge_pages: true,
+    initiatives: true,
+    ingest_status: true,
+  },
+  mem0: { retain: true, recall: true, reflect: true, consolidate: false, bank_scope: true, ingest_status: true },
+  cognee: { retain: true, recall: true, reflect: true, consolidate: true, bank_scope: true },
+};
+
+/**
+ * @param {string} provider
+ * @param {Feature} feature
+ */
+export function providerSupports(provider, feature) {
+  return Boolean(PROVIDER_CAPABILITIES[provider]?.[feature]);
+}

package/cli/coding-agent/context-store.mjs

@@ -0,0 +1,81 @@
+/** Hook side of the context store contract (docs/context-store.md). */
+import fs from "node:fs";
+import path from "node:path";
+
+/** Marker in the installed smart-compact command body; survives command expansion. */
+export const SMART_COMPACT_MARKER = "openmem:smart-compact";
+/** Prompt that `/smart-compact` sends in every agent (Claude Code command file, OpenCode 2 command). */
+export const SMART_COMPACT_BODY = `<!-- ${SMART_COMPACT_MARKER} -->
+OpenMem will trim this session's earlier context on the next request. Reply with one short line acknowledging this; do not summarize the conversation. After the trim, use \`smart_compact_search\` with this session's id to look up anything earlier.`;
+/** Claude Code command file (`~/.claude/commands/smart-compact.md`): frontmatter plus SMART_COMPACT_BODY. */
+export const SMART_COMPACT_COMMAND = `---
+description: Trim this session's context on the next request (OpenMem)
+---
+${SMART_COMPACT_BODY}
+`;
+const SMART_COMPACT_PREFIX = /^\s*\/smart-compact(?:\s|$)/;
+const SMART_COMPACT_TAG = "<command-name>/smart-compact</command-name>";
+/** ASCII whitespace only, so the hooks and the proxy trim the same characters (session ids, OPENMEM_STATE_DIR). */
+const ASCII_TRIM_RE = /^[ \t\n\v\f\r]+|[ \t\n\v\f\r]+$/g;
+const SID_UNSAFE_RE = /[^A-Za-z0-9._-]/gu;
+
+/** `$OPENMEM_STATE_DIR/context` (value trimmed), default `~/.local/share/openmem/context`. */
+export function contextRoot(home, env = process.env) {
+  const state = String(env.OPENMEM_STATE_DIR || "").replace(ASCII_TRIM_RE, "") || path.join(home, ".local", "share", "openmem");
+  return path.join(state, "context");
+}
+
+/**
+ * Contract sanitizer (docs/context-store.md): trim surrounding ASCII whitespace, replace every character
+ * outside `[A-Za-z0-9._-]` with `_`, throw on an empty result.
+ */
+export function sanitizeSessionId(sessionId) {
+  const sid = String(sessionId ?? "").replace(ASCII_TRIM_RE, "").replace(SID_UNSAFE_RE, "_");
+  if (!sid) throw new Error("empty session id");
+  return sid;
+}
+
+function sessionsDir(home, env) {
+  const root = contextRoot(home, env);
+  const dir = path.join(root, "sessions");
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  fs.chmodSync(root, 0o700);
+  fs.chmodSync(dir, 0o700);
+  return dir;
+}
+
+function writePrivate(file, text) {
+  const temporary = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, text, { mode: 0o600 });
+  fs.renameSync(temporary, file);
+}
+
+/** Write `sessions/<sid>.json`. Returns the path, or null without a session id. */
+export function registerSession({ home, env, sessionId, agent, cwd, bank, now = new Date() }) {
+  if (!sessionId) return null;
+  const sid = sanitizeSessionId(sessionId);
+  const file = path.join(sessionsDir(home, env), `${sid}.json`);
+  const registration = {
+    session_id: sid,
+    agent,
+    cwd,
+    bank,
+    registered_at: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+  };
+  writePrivate(file, `${JSON.stringify(registration)}\n`);
+  return file;
+}
+
+/** Write the empty `sessions/<sid>.force` flag. Returns the path, or null without a session id. */
+export function writeForceFlag({ home, env, sessionId }) {
+  if (!sessionId) return null;
+  const file = path.join(sessionsDir(home, env), `${sanitizeSessionId(sessionId)}.force`);
+  writePrivate(file, "");
+  return file;
+}
+
+/** True for `/smart-compact …`, Claude Code's command tag, or the expanded command body. */
+export function isSmartCompactPrompt(prompt) {
+  const text = String(prompt || "");
+  return SMART_COMPACT_PREFIX.test(text) || text.includes(SMART_COMPACT_TAG) || text.includes(SMART_COMPACT_MARKER);
+}