@inetafrica/open-claudia 2.4.2 → 2.6.0

package/bin/entity.js

@@ -0,0 +1,77 @@
+// CLI: inspect and manage entity notes (people/places/projects memory).
+//   open-claudia entity list
+//   open-claudia entity show <slug-or-name>
+//   open-claudia entity match "<text>"            — debug the router
+//   open-claudia entity note <name> "<text>" [--type person|place|project|org|system]
+//   open-claudia entity remove <slug-or-name>
+//   open-claudia entity reindex
+
+const fs = require("fs");
+const path = require("path");
+const entities = require("../core/entities");
+
+function run(args) {
+  const cmd = (args[0] || "list").toLowerCase();
+  const rest = args.slice(1);
+
+  switch (cmd) {
+    case "list": {
+      const all = entities.listEntities();
+      if (all.length === 0) return console.log(`No entities yet (${entities.ENTITIES_DIR}).`);
+      for (const e of all) {
+        const seen = e.last_seen ? ` last-seen ${e.last_seen.slice(0, 10)}` : "";
+        const aka = e.aliases.length ? ` aka ${e.aliases.join(", ")}` : "";
+        console.log(`${e.slug} (${e.type})${aka}${seen}\n    ${e.description}`);
+      }
+      break;
+    }
+
+    case "show": {
+      const e = entities.findEntity(rest.join(" "));
+      if (!e) { console.error(`No entity: ${rest.join(" ")}`); process.exitCode = 1; return; }
+      console.log(fs.readFileSync(path.join(entities.ENTITIES_DIR, e.slug + ".md"), "utf-8"));
+      break;
+    }
+
+    case "match": {
+      const text = rest.join(" ");
+      if (!text) { console.error('Usage: entity match "<text>"'); process.exitCode = 1; return; }
+      const hits = entities.matchEntities(text, { limit: 5 });
+      if (hits.length === 0) return console.log("No matching entities.");
+      for (const h of hits) console.log(`${h.score.toFixed(2)}  ${h.slug} — ${h.name}`);
+      break;
+    }
+
+    case "note": {
+      const typeIdx = rest.indexOf("--type");
+      let type = null;
+      if (typeIdx !== -1) {
+        type = rest[typeIdx + 1] || null;
+        rest.splice(typeIdx, 2);
+      }
+      const [name, ...noteParts] = rest;
+      const note = noteParts.join(" ");
+      if (!name || !note) { console.error('Usage: entity note <name> "<text>" [--type <type>]'); process.exitCode = 1; return; }
+      const { entity, created } = entities.upsertEntity({ name, type, log: note });
+      console.log(`${created ? "Created" : "Updated"} entity ${entity.slug} (${entity.type}).`);
+      break;
+    }
+
+    case "remove": {
+      const removed = entities.removeEntity(rest.join(" "));
+      if (!removed) { console.error(`No entity: ${rest.join(" ")}`); process.exitCode = 1; return; }
+      console.log(`Removed entity ${removed.slug}.`);
+      break;
+    }
+
+    case "reindex": {
+      console.log(entities.reindex() ? "Reindexed." : "Index unavailable (node:sqlite missing?).");
+      break;
+    }
+
+    default:
+      console.log("Usage: open-claudia entity [list|show <slug>|match \"<text>\"|note <name> \"<text>\"|remove <slug>|reindex]");
+  }
+}
+
+module.exports = { run };

package/bin/pack.js

@@ -0,0 +1,100 @@
+// CLI: inspect and manage context packs (living skills+memory docs).
+//   open-claudia pack list
+//   open-claudia pack show <dir>
+//   open-claudia pack match "<text>"        — debug the router
+//   open-claudia pack migrate               — fold ~/.claude/skills into packs
+//   open-claudia pack remove <dir>
+//   open-claudia pack reindex
+
+const fs = require("fs");
+const path = require("path");
+const packs = require("../core/packs");
+
+function run(args) {
+  const cmd = (args[0] || "list").toLowerCase();
+  const rest = args.slice(1);
+
+  switch (cmd) {
+    case "list": {
+      const all = packs.listPacks();
+      if (all.length === 0) return console.log(`No packs yet (${packs.PACKS_DIR}).`);
+      for (const p of all) {
+        const used = p.last_used ? ` last-used ${p.last_used.slice(0, 10)}` : "";
+        console.log(`${p.dir} — ${p.name}${p.tags.length ? ` [${p.tags.join(", ")}]` : ""}${used}\n    ${p.description}`);
+      }
+      break;
+    }
+
+    case "show": {
+      const p = packs.findPack(rest[0]);
+      if (!p) { console.error(`No pack: ${rest[0]}`); process.exitCode = 1; return; }
+      console.log(fs.readFileSync(path.join(packs.PACKS_DIR, p.dir, "PACK.md"), "utf-8"));
+      break;
+    }
+
+    case "match": {
+      const text = rest.join(" ");
+      if (!text) { console.error('Usage: pack match "<text>"'); process.exitCode = 1; return; }
+      const hits = packs.matchPacks(text, { limit: 5 });
+      if (hits.length === 0) return console.log("No matching packs.");
+      for (const h of hits) console.log(`${h.score.toFixed(2)}  ${h.dir} — ${h.name}`);
+      break;
+    }
+
+    case "remove": {
+      const removed = packs.removePack(rest[0]);
+      if (!removed) { console.error(`No pack: ${rest[0]}`); process.exitCode = 1; return; }
+      console.log(`Removed pack ${removed.dir}.`);
+      break;
+    }
+
+    case "reindex": {
+      console.log(packs.reindex() ? "Reindexed." : "Index unavailable (node:sqlite missing?).");
+      break;
+    }
+
+    case "migrate": {
+      const skills = require("../core/skills");
+      const backupDir = path.join(require("../config-dir"), "backup", "skills-pre-packs");
+      const all = skills.listSkills();
+      if (all.length === 0) return console.log("No skills to migrate.");
+      fs.mkdirSync(backupDir, { recursive: true });
+      let migrated = 0, skipped = 0;
+      for (const s of all) {
+        const dir = packs.slugify(s.dir);
+        if (packs.readPack(dir)) {
+          console.log(`skip ${s.dir} (pack exists)`);
+          skipped++;
+          continue;
+        }
+        const content = fs.readFileSync(s.file, "utf-8");
+        const body = content.replace(/^---\n[\s\S]*?\n---\n?/, "").trim();
+        packs.createPack({
+          dir,
+          name: s.name,
+          description: s.description,
+          tags: [],
+          procedure: body,
+          journal: "Migrated from ~/.claude/skills.",
+        });
+        // Fold: move the original skill out of ~/.claude/skills so the
+        // pack is the single source of truth. Backup kept, never deleted.
+        const skillDir = path.join(skills.SKILLS_DIR, s.dir);
+        const dest = path.join(backupDir, s.dir);
+        fs.rmSync(dest, { recursive: true, force: true });
+        fs.cpSync(skillDir, dest, { recursive: true });
+        fs.rmSync(skillDir, { recursive: true, force: true });
+        console.log(`migrated ${s.dir} -> pack ${dir}`);
+        migrated++;
+      }
+      packs.reindex();
+      console.log(`Done: ${migrated} migrated, ${skipped} skipped. Originals backed up at ${backupDir}.`);
+      break;
+    }
+
+    default:
+      console.log("Usage: open-claudia pack [list|show <dir>|match \"<text>\"|migrate|remove <dir>|reindex]");
+  }
+}
+
+module.exports = { run };

package/bot.js

@@ -161,6 +161,8 @@ setInterval(checkForUpdates, 5 * 60 * 1000);
   } catch (e) {}
 
   initScheduler(adapters);
+  try { require("./core/dream").initDream(adapters); }
+  catch (e) { console.error("dream init failed:", e.message); }
 
   try {
     const lb = await loopback.start(registry);

package/core/dream.js

@@ -0,0 +1,332 @@
+// Dream: scheduled memory consolidation (Phase 3). While the per-turn
+// reviewer takes quick notes, dream is the slow pass that runs in the
+// quiet hours: it merges packs that drifted into the same topic, builds
+// parent/sub pack trees with umbrella summaries, tightens descriptions
+// and tags (the FTS router matches on those, so tighter = less noise),
+// deduplicates entities, cross-links entity notes to packs, and gently
+// evolves the persona based on how recent work actually went. The model
+// only RETURNS a JSON decision — all writes are applied here, every
+// merged-away pack/entity is backed up first, and the result is
+// reported in chat (no silent learning).
+
+const fs = require("fs");
+const path = require("path");
+const cron = require("node-cron");
+
+const CONFIG_DIR = require("../config-dir");
+const packs = require("./packs");
+const entities = require("./entities");
+const persona = require("./persona");
+const { spawnSubagent } = require("./subagent");
+
+const DREAM_MODEL = process.env.DREAM_MODEL || "sonnet";
+const DREAM_CRON = process.env.DREAM_CRON || "0 4 * * *";
+const MAX_PACK_CHARS = 2500;
+const MAX_ENTITY_CHARS = 900;
+const LIMITS = { merges: 3, umbrellas: 2, parents: 8, retag: 8, entity_merges: 3, entity_notes: 4 };
+
+let _dreaming = false;
+
+function enabled() {
+  return (process.env.DREAM || "on").toLowerCase() !== "off";
+}
+
+function clip(s, n) {
+  const t = String(s || "");
+  return t.length > n ? t.slice(0, n) + "\n…[truncated]" : t;
+}
+
+function buildDreamPrompt() {
+  const allPacks = packs.listPacks();
+  const allEntities = entities.listEntities();
+
+  const packDump = allPacks.map((p) => clip([
+    `=== pack: ${p.dir}${p.parent ? ` (parent: ${p.parent})` : ""}`,
+    `name: ${p.name}`,
+    `description: ${p.description}`,
+    `tags: ${p.tags.join(", ")}`,
+    `last_used: ${p.last_used || "never"}`,
+    `Stance: ${p.sections.Stance}`,
+    `Procedure: ${p.sections.Procedure}`,
+    `State: ${p.sections.State}`,
+    `Journal:\n${p.sections.Journal}`,
+  ].join("\n"), MAX_PACK_CHARS)).join("\n\n") || "(none)";
+
+  const entityDump = allEntities.map((e) => clip([
+    `=== entity: ${e.slug} (${e.type}${e.aliases.length ? `, aka ${e.aliases.join(", ")}` : ""})`,
+    `description: ${e.description}`,
+    `Notes: ${e.sections.Notes}`,
+    `Log:\n${e.sections.Log}`,
+  ].join("\n"), MAX_ENTITY_CHARS)).join("\n\n") || "(none)";
+
+  return `You are the dream pass of a personal AI assistant called Open Claudia — the overnight consolidation of her long-term memory. Below is her entire memory: context packs (living topic documents) and entity notes (people/places/projects/orgs/systems), plus her current persona.
+
+Today: ${new Date().toISOString().slice(0, 10)}
+
+CONTEXT PACKS:
+
+${packDump}
+
+ENTITIES:
+
+${entityDump}
+
+CURRENT PERSONA:
+
+${persona.loadPersona()}
+
+Your job — decide what consolidation, if any, is warranted:
+
+1. merges: packs that are clearly the SAME topic under different names get merged into one. Supply the merged Stance/Procedure/State (synthesised, not concatenated; null leaves the target's section alone) and a one-sentence journal note. Be conservative: when in doubt, do not merge.
+2. umbrellas: when 3+ packs are siblings under one theme, create an umbrella pack whose State is a 3-6 line map of the family ("for X see pack Y"), and list its children. The umbrella is a router, not a duplicate.
+3. parents: assign an existing pack as parent of another (sub-topic relationship) without creating anything.
+4. retag: tighten descriptions and tags. The router FTS-matches incoming messages against name/description/tags, so generic words there cause false matches. Descriptions should be one specific line; tags specific nouns.
+5. entity_merges: the same real-world entity recorded twice gets merged (the better slug wins).
+6. entity_notes: rewrite an entity's Notes to be current and cross-linked — mention related packs as [[pack-dir]] and related entities by name.
+7. persona: evolve the persona GENTLY — keep its structure and length (under 2200 chars), adjust only what recent work justifies (a new habit, a sharpened quirk). Most dreams should return null here.
+8. report: a short chat message to the owner, written AS Open Claudia in first person — warm, a little playful, a few emojis, mobile-friendly (2-6 short lines). Say what you tidied and why it helps. If you changed nothing, say the memory is in good shape, charmingly.
+
+Hard rules:
+- Never invent packs/entities not listed above; reference them by exact dir/slug.
+- Never store secrets, tokens, passwords, or credentials anywhere.
+- Limits: ≤${LIMITS.merges} merges, ≤${LIMITS.umbrellas} umbrellas, ≤${LIMITS.parents} parents, ≤${LIMITS.retag} retags, ≤${LIMITS.entity_merges} entity merges, ≤${LIMITS.entity_notes} entity note rewrites.
+- An empty decision is a perfectly good decision.
+
+Reply with ONLY a JSON object, no prose, no code fences:
+{"merges": [{"into": "<dir>", "from": ["<dir>"], "stance": null, "procedure": null, "state": null, "journal": "<one sentence>"}],
+ "umbrellas": [{"dir": "<new-kebab-slug>", "name": "<title>", "description": "<one specific line>", "tags": ["..."], "state": "<3-6 line family map>", "children": ["<dir>"]}],
+ "parents": [{"pack": "<dir>", "parent": "<dir>"}],
+ "retag": [{"pack": "<dir>", "description": "<one specific line>", "tags": ["..."]}],
+ "entity_merges": [{"into": "<slug>", "from": ["<slug>"], "notes": "<merged Notes or null>"}],
+ "entity_notes": [{"entity": "<slug>", "notes": "<rewritten Notes>"}],
+ "persona": null,
+ "report": "<chat message>"}`;
+}
+
+function parseDream(text) {
+  const raw = String(text || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "");
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end <= start) return null;
+  try {
+    const obj = JSON.parse(raw.slice(start, end + 1));
+    const arr = (k) => (Array.isArray(obj[k]) ? obj[k].slice(0, LIMITS[k] || 8) : []);
+    return {
+      merges: arr("merges"),
+      umbrellas: arr("umbrellas"),
+      parents: arr("parents"),
+      retag: arr("retag"),
+      entity_merges: arr("entity_merges"),
+      entity_notes: arr("entity_notes"),
+      persona: typeof obj.persona === "string" ? obj.persona : null,
+      report: typeof obj.report === "string" ? obj.report.trim() : "",
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+function makeBackupRoot() {
+  const stamp = new Date().toISOString().slice(0, 16).replace(/[:T]/g, "-");
+  return path.join(CONFIG_DIR, "backup", `dream-${stamp}`);
+}
+
+function backupPack(dir, root) {
+  fs.cpSync(path.join(packs.PACKS_DIR, dir), path.join(root, "packs", dir), { recursive: true });
+}
+
+function backupEntity(slug, root) {
+  const dest = path.join(root, "entities");
+  fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
+  fs.copyFileSync(path.join(entities.ENTITIES_DIR, slug + ".md"), path.join(dest, slug + ".md"));
+}
+
+function wouldCycle(packDir, parentDir) {
+  let cur = parentDir;
+  for (let i = 0; i < 10 && cur; i++) {
+    if (cur === packDir) return true;
+    cur = packs.readPack(cur)?.parent || null;
+  }
+  return false;
+}
+
+// Applies a parsed dream decision. Returns one human line per applied
+// change; invalid items are skipped, never thrown.
+function applyDream(decision, backupRoot) {
+  const lines = [];
+  const gone = new Set(); // dirs/slugs removed this run
+
+  for (const m of decision.merges) {
+    try {
+      const into = m?.into && packs.readPack(m.into);
+      const from = [].concat(m?.from || []).filter((d) => d && d !== m.into && !gone.has(d) && packs.readPack(d));
+      if (!into || from.length === 0) continue;
+      packs.updatePack(m.into, {
+        stance: typeof m.stance === "string" ? m.stance : "",
+        procedure: typeof m.procedure === "string" ? m.procedure : "",
+        state: typeof m.state === "string" ? m.state : "",
+        journal: m.journal || `absorbed ${from.join(", ")}`,
+      });
+      for (const d of from) {
+        backupPack(d, backupRoot);
+        packs.removePack(d);
+        gone.add(d);
+      }
+      lines.push(`📦 Merged ${from.join(" + ")} into ${m.into}`);
+    } catch (e) { console.warn(`[dream] merge failed: ${e.message}`); }
+  }
+
+  for (const u of decision.umbrellas) {
+    try {
+      const dir = packs.slugify(u?.dir || u?.name);
+      if (!dir || gone.has(dir)) continue;
+      const children = [].concat(u?.children || []).filter((d) => d && d !== dir && !gone.has(d) && packs.readPack(d));
+      if (children.length < 2) continue;
+      if (!packs.readPack(dir)) {
+        packs.createPack({
+          dir,
+          name: u.name || dir,
+          description: u.description || "",
+          tags: Array.isArray(u.tags) ? u.tags.slice(0, 6) : [],
+          state: u.state || "",
+          journal: `umbrella created over ${children.join(", ")}`,
+        });
+      }
+      for (const c of children) {
+        const child = packs.readPack(c);
+        if (!child || wouldCycle(c, dir)) continue;
+        child.parent = dir;
+        child.updated = new Date().toISOString();
+        packs.writePack(child);
+      }
+      lines.push(`🌂 Umbrella pack ${dir} now covers ${children.join(", ")}`);
+    } catch (e) { console.warn(`[dream] umbrella failed: ${e.message}`); }
+  }
+
+  for (const p of decision.parents) {
+    try {
+      const child = p?.pack && !gone.has(p.pack) && packs.readPack(p.pack);
+      if (!child || !p.parent || gone.has(p.parent) || !packs.readPack(p.parent)) continue;
+      if (p.pack === p.parent || wouldCycle(p.pack, p.parent)) continue;
+      if (child.parent === p.parent) continue;
+      child.parent = p.parent;
+      child.updated = new Date().toISOString();
+      packs.writePack(child);
+      lines.push(`🌳 Filed ${p.pack} under ${p.parent}`);
+    } catch (e) { console.warn(`[dream] parent failed: ${e.message}`); }
+  }
+
+  for (const r of decision.retag) {
+    try {
+      if (!r?.pack || gone.has(r.pack) || !packs.readPack(r.pack)) continue;
+      const desc = typeof r.description === "string" ? r.description.trim() : "";
+      const tags = Array.isArray(r.tags) ? r.tags.map((t) => String(t).trim()).filter(Boolean).slice(0, 6) : [];
+      if (!desc && tags.length === 0) continue;
+      packs.updatePack(r.pack, { description: desc, tags });
+      lines.push(`🏷️ Sharpened ${r.pack}'s description/tags`);
+    } catch (e) { console.warn(`[dream] retag failed: ${e.message}`); }
+  }
+
+  for (const em of decision.entity_merges) {
+    try {
+      const into = em?.into && entities.readEntity(em.into);
+      const from = [].concat(em?.from || []).filter((s) => s && s !== em.into && !gone.has(s) && entities.readEntity(s));
+      if (!into || from.length === 0) continue;
+      for (const slug of from) {
+        const f = entities.readEntity(slug);
+        backupEntity(slug, backupRoot);
+        entities.upsertEntity({
+          name: into.name,
+          aliases: [f.name, ...f.aliases],
+          log: `merged duplicate entity ${slug} into this one`,
+        });
+        entities.removeEntity(slug);
+        gone.add(slug);
+      }
+      if (typeof em.notes === "string" && em.notes.trim()) {
+        entities.upsertEntity({ name: into.name, notes: em.notes });
+      }
+      lines.push(`👥 Merged duplicate ${from.join(", ")} into ${em.into}`);
+    } catch (e) { console.warn(`[dream] entity merge failed: ${e.message}`); }
+  }
+
+  for (const en of decision.entity_notes) {
+    try {
+      const ent = en?.entity && !gone.has(en.entity) && entities.readEntity(en.entity);
+      if (!ent || typeof en.notes !== "string" || !en.notes.trim()) continue;
+      entities.upsertEntity({ name: ent.name, notes: en.notes });
+      lines.push(`🔗 Refreshed notes on ${ent.name}`);
+    } catch (e) { console.warn(`[dream] entity notes failed: ${e.message}`); }
+  }
+
+  if (decision.persona) {
+    try {
+      if (persona.personaExists()) {
+        fs.mkdirSync(backupRoot, { recursive: true, mode: 0o700 });
+        fs.copyFileSync(persona.PERSONA_FILE, path.join(backupRoot, "persona.md"));
+      }
+      persona.savePersona(decision.persona);
+      lines.push(`💫 Persona evolved a little`);
+    } catch (e) { console.warn(`[dream] persona update rejected: ${e.message}`); }
+  }
+
+  return lines;
+}
+
+async function runDream({ trigger = "manual" } = {}) {
+  if (!enabled()) return { skipped: "dream is disabled (DREAM=off)" };
+  if (_dreaming) return { skipped: "a dream is already in progress" };
+  const packCount = packs.listPacks().length;
+  const entityCount = entities.listEntities().length;
+  if (packCount === 0 && entityCount === 0) return { skipped: "no memory to consolidate yet" };
+
+  _dreaming = true;
+  try {
+    const { text } = await spawnSubagent(buildDreamPrompt(), {
+      model: DREAM_MODEL,
+      timeoutMs: 8 * 60 * 1000,
+      systemPrompt: "You are a background memory consolidation process. Reply with ONLY the requested JSON object. No prose, no markdown, no tool use.",
+    });
+    const decision = parseDream(text);
+    if (!decision) return { skipped: "dream model returned unparseable output" };
+
+    const backupRoot = makeBackupRoot();
+    const applied = applyDream(decision, backupRoot);
+    const report = decision.report || (applied.length > 0 ? "Tidied up my memory overnight." : "");
+
+    const message = applied.length > 0
+      ? `💤 ${report}\n\n${applied.join("\n")}\n\n🗄 Anything merged away is backed up under ${backupRoot}`
+      : (report ? `💤 ${report}` : "");
+
+    return { applied, report, message, trigger };
+  } finally {
+    _dreaming = false;
+  }
+}
+
+// In-bot scheduler: one quiet-hours cron, reporting to the owner's
+// Telegram chat. Silent (console only) when the dream changed nothing —
+// a nightly "all tidy" ping would be noise.
+function initDream(adapters) {
+  if (!enabled()) return;
+  if (!cron.validate(DREAM_CRON)) {
+    console.error(`dream: invalid DREAM_CRON "${DREAM_CRON}" — dream disabled`);
+    return;
+  }
+  cron.schedule(DREAM_CRON, async () => {
+    try {
+      const res = await runDream({ trigger: "cron" });
+      if (res.skipped) { console.log(`dream: skipped — ${res.skipped}`); return; }
+      console.log(`dream: applied ${res.applied.length} change(s)`);
+      if (res.applied.length === 0) return;
+      const { CHAT_ID } = require("./config");
+      const tg = (adapters || []).find((a) => a.type === "telegram");
+      if (tg && CHAT_ID) await tg.send(CHAT_ID, res.message);
+    } catch (e) {
+      console.error("dream: run failed:", e.message);
+    }
+  });
+  console.log(`dream: scheduled (${DREAM_CRON}, model ${DREAM_MODEL})`);
+}
+
+module.exports = { runDream, initDream, buildDreamPrompt, parseDream, applyDream, enabled, DREAM_CRON, DREAM_MODEL };