cue-ai 0.9.0 → 0.9.2

package/src/lib/claude-mem-env.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  assignPorts,
+  claudeMemDataDir,
+  type PortRegistry,
+  portsForSlot,
+  resolveClaudeMemEnv,
+} from "./claude-mem-env";
+
+describe("portsForSlot", () => {
+  test("slot 0 → worker 30000 / server 30001", () => {
+    expect(portsForSlot(0)).toEqual({ worker: 30000, server: 30001 });
+  });
+
+  test("consecutive slots never overlap (worker even, server odd, +2 per slot)", () => {
+    expect(portsForSlot(5)).toEqual({ worker: 30010, server: 30011 });
+    // slot N's server (30000+2N+1) is always below slot N+1's worker (30000+2N+2)
+    expect(portsForSlot(5).server).toBeLessThan(portsForSlot(6).worker);
+  });
+
+  test("stays below the Linux ephemeral range for any realistic slot", () => {
+    expect(portsForSlot(999).server).toBeLessThan(32768);
+  });
+});
+
+describe("assignPorts", () => {
+  test("assigns the lowest free slot to a new profile and does not mutate input", () => {
+    const reg: PortRegistry = { version: 1, slots: {} };
+    const out = assignPorts(reg, "backend");
+    expect(out.assigned).toBe(true);
+    expect(out.ports).toEqual({ worker: 30000, server: 30001 });
+    expect(out.registry.slots).toEqual({ backend: 0 });
+    expect(reg.slots).toEqual({}); // input untouched
+  });
+
+  test("returns the same ports (and assigned=false) for an already-known profile", () => {
+    const reg: PortRegistry = { version: 1, slots: { backend: 3 } };
+    const out = assignPorts(reg, "backend");
+    expect(out.assigned).toBe(false);
+    expect(out.ports).toEqual(portsForSlot(3));
+    expect(out.registry).toBe(reg); // unchanged reference
+  });
+
+  test("fills the lowest gap rather than appending", () => {
+    const reg: PortRegistry = { version: 1, slots: { a: 0, c: 2 } };
+    const out = assignPorts(reg, "b");
+    expect(out.registry.slots.b).toBe(1);
+  });
+
+  test("distinct profiles get distinct, non-overlapping ports", () => {
+    let reg: PortRegistry = { version: 1, slots: {} };
+    const a = assignPorts(reg, "frontend");
+    reg = a.registry;
+    const b = assignPorts(reg, "secops");
+    const ports = [a.ports.worker, a.ports.server, b.ports.worker, b.ports.server];
+    expect(new Set(ports).size).toBe(4);
+  });
+});
+
+describe("claudeMemDataDir", () => {
+  test("nests the profile under <home>/.claude-mem/profiles", () => {
+    expect(claudeMemDataDir("backend", "/home/u")).toBe("/home/u/.claude-mem/profiles/backend");
+  });
+
+  test("keeps + and @ (real profile names) but sanitizes path separators", () => {
+    expect(claudeMemDataDir("gstack+skill-writer", "/home/u")).toBe(
+      "/home/u/.claude-mem/profiles/gstack+skill-writer",
+    );
+    expect(claudeMemDataDir("a/b", "/home/u")).toBe("/home/u/.claude-mem/profiles/a_b");
+  });
+});
+
+describe("resolveClaudeMemEnv", () => {
+  const inMemoryRegistry = () => {
+    let reg: PortRegistry = { version: 1, slots: {} };
+    return {
+      readRegistry: () => reg,
+      writeRegistry: (r: PortRegistry) => {
+        reg = r;
+      },
+      current: () => reg,
+    };
+  };
+
+  test("returns null when isolation is opted out", () => {
+    const out = resolveClaudeMemEnv("backend", {
+      home: "/home/u",
+      existingEnv: { CUE_CLAUDE_MEM_ISOLATE: "0" },
+    });
+    expect(out).toBeNull();
+  });
+
+  test("returns null when the user already manages CLAUDE_MEM_* by hand", () => {
+    const out = resolveClaudeMemEnv("backend", {
+      home: "/home/u",
+      existingEnv: { CLAUDE_MEM_DATA_DIR: "/custom" },
+    });
+    expect(out).toBeNull();
+  });
+
+  test("produces the SQLite-only overlay and persists a new slot", () => {
+    const io = inMemoryRegistry();
+    const out = resolveClaudeMemEnv("backend", {
+      home: "/home/u",
+      existingEnv: {},
+      readRegistry: io.readRegistry,
+      writeRegistry: io.writeRegistry,
+    });
+    expect(out).toEqual({
+      CLAUDE_MEM_DATA_DIR: "/home/u/.claude-mem/profiles/backend",
+      CLAUDE_MEM_CHROMA_ENABLED: "false",
+      CLAUDE_MEM_WORKER_PORT: "30000",
+      CLAUDE_MEM_SERVER_PORT: "30001",
+    });
+    expect(io.current().slots).toEqual({ backend: 0 });
+  });
+
+  test("is stable across calls for the same profile (no re-allocation)", () => {
+    const io = inMemoryRegistry();
+    const first = resolveClaudeMemEnv("backend", {
+      home: "/home/u",
+      existingEnv: {},
+      readRegistry: io.readRegistry,
+      writeRegistry: io.writeRegistry,
+    });
+    const second = resolveClaudeMemEnv("backend", {
+      home: "/home/u",
+      existingEnv: {},
+      readRegistry: io.readRegistry,
+      writeRegistry: io.writeRegistry,
+    });
+    expect(second).toEqual(first);
+  });
+
+  test("two profiles get different ports", () => {
+    const io = inMemoryRegistry();
+    const opts = {
+      home: "/home/u",
+      existingEnv: {},
+      readRegistry: io.readRegistry,
+      writeRegistry: io.writeRegistry,
+    };
+    const a = resolveClaudeMemEnv("frontend", opts);
+    const b = resolveClaudeMemEnv("secops", opts);
+    expect(a?.CLAUDE_MEM_WORKER_PORT).not.toBe(b?.CLAUDE_MEM_WORKER_PORT);
+  });
+});

package/src/lib/claude-mem-env.ts

@@ -0,0 +1,172 @@
+/**
+ * claude-mem-env — per-profile claude-mem environment overlay.
+ *
+ * claude-mem keys its ENTIRE store off CLAUDE_MEM_DATA_DIR (default ~/.claude-mem)
+ * and addresses its background worker over a single TCP port (default UID-derived).
+ * So out of the box every cue profile shares one memory pool AND one worker port —
+ * meaning two concurrent profiles would cross-write through whichever worker
+ * claimed the port first. This module gives each profile an isolated, SQLite-only
+ * store with its own worker/server ports:
+ *
+ *   CLAUDE_MEM_DATA_DIR        ~/.claude-mem/profiles/<profile>
+ *   CLAUDE_MEM_CHROMA_ENABLED  "false"  → worker runs SQLite-only, never spawns Chroma
+ *   CLAUDE_MEM_WORKER_PORT     per-profile (registry-allocated, collision-free)
+ *   CLAUDE_MEM_SERVER_PORT     per-profile (registry-allocated)
+ *
+ * Verified against claude-mem v13.4.0:
+ *   - paths.ts:18-40            CLAUDE_MEM_DATA_DIR override + ~/.claude-mem default
+ *   - SettingsDefaultsManager   process.env[key] wins over the data-dir settings.json
+ *   - worker-service.ts:343-348 CHROMA_ENABLED="false" skips spawning ChromaMcpManager
+ *   - worker-service.ts:996     the worker treats the TCP port as a global singleton
+ *
+ * Pure core (portsForSlot/assignPorts) + injectable I/O so it tests without $HOME.
+ * Opt out for a session with CUE_CLAUDE_MEM_ISOLATE=0.
+ */
+
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir as osHomedir } from "node:os";
+import { join } from "node:path";
+
+/** A worker+server TCP port pair for one profile. */
+export interface PortPair {
+  worker: number;
+  server: number;
+}
+
+/** Persisted slot assignments: profile name → slot index. */
+export interface PortRegistry {
+  version: number;
+  slots: Record<string, number>;
+}
+
+/** The four env vars cue injects to isolate a profile's claude-mem store. */
+export interface ClaudeMemEnv {
+  CLAUDE_MEM_DATA_DIR: string;
+  CLAUDE_MEM_CHROMA_ENABLED: string;
+  CLAUDE_MEM_WORKER_PORT: string;
+  CLAUDE_MEM_SERVER_PORT: string;
+}
+
+// Ports sit just below the Linux ephemeral range (32768+) so a profile's worker
+// never clashes with an OS-assigned ephemeral port. Two ports per slot:
+// worker = even, server = worker + 1 (odd). Slot N → [30000+2N, 30000+2N+1].
+const PORT_BASE = 30000;
+const MAX_SLOTS = 1000; // 30000..31999
+
+/** Map a slot index to its worker/server port pair. Pure. */
+export function portsForSlot(slot: number): PortPair {
+  return { worker: PORT_BASE + slot * 2, server: PORT_BASE + slot * 2 + 1 };
+}
+
+/**
+ * Resolve the slot for `profileName`, assigning the lowest free slot if it is
+ * new. Pure: never mutates the input registry; returns a fresh registry when a
+ * slot was assigned (so the caller knows to persist).
+ */
+export function assignPorts(
+  registry: PortRegistry,
+  profileName: string,
+): { registry: PortRegistry; ports: PortPair; assigned: boolean } {
+  const existing = registry.slots[profileName];
+  if (existing !== undefined) {
+    return { registry, ports: portsForSlot(existing), assigned: false };
+  }
+  const used = new Set(Object.values(registry.slots));
+  let slot = 0;
+  while (used.has(slot)) slot++;
+  if (slot >= MAX_SLOTS) {
+    throw new Error(`claude-mem-env: exhausted ${MAX_SLOTS} port slots`);
+  }
+  const next: PortRegistry = {
+    version: registry.version,
+    slots: { ...registry.slots, [profileName]: slot },
+  };
+  return { registry: next, ports: portsForSlot(slot), assigned: true };
+}
+
+/** Filesystem-safe per-profile claude-mem data dir under the claude-mem home. */
+export function claudeMemDataDir(profileName: string, home: string): string {
+  const safe = profileName.replace(/[^A-Za-z0-9._+@-]/g, "_");
+  return join(home, ".claude-mem", "profiles", safe);
+}
+
+/** Path to the cue-owned port registry inside the claude-mem home. */
+export function registryPath(home: string): string {
+  return join(home, ".claude-mem", "cue-ports.json");
+}
+
+const EMPTY_REGISTRY: PortRegistry = { version: 1, slots: {} };
+
+export interface ResolveDeps {
+  /** Home dir (defaults to os.homedir()). */
+  home?: string;
+  /** Environment to read overrides from (defaults to process.env). */
+  existingEnv?: Record<string, string | undefined>;
+  /** Whether isolation applies (defaults to CUE_CLAUDE_MEM_ISOLATE !== "0"). */
+  isolate?: boolean;
+  /** Registry reader (defaults to reading registryPath(home)). */
+  readRegistry?: () => PortRegistry;
+  /** Registry writer (defaults to an atomic write to registryPath(home)). */
+  writeRegistry?: (registry: PortRegistry) => void;
+}
+
+/**
+ * Compute the env overlay for a profile, or null when isolation must not apply:
+ *   - opted out via CUE_CLAUDE_MEM_ISOLATE=0, or
+ *   - the user is hand-managing CLAUDE_MEM_DATA_DIR / *_PORT in their own env.
+ * In both cases cue leaves claude-mem entirely alone.
+ */
+export function resolveClaudeMemEnv(
+  profileName: string,
+  deps: ResolveDeps = {},
+): ClaudeMemEnv | null {
+  const env = deps.existingEnv ?? process.env;
+  const isolate = deps.isolate ?? env.CUE_CLAUDE_MEM_ISOLATE !== "0";
+  if (!isolate) return null;
+  if (env.CLAUDE_MEM_DATA_DIR || env.CLAUDE_MEM_WORKER_PORT || env.CLAUDE_MEM_SERVER_PORT) {
+    return null;
+  }
+
+  const home = deps.home ?? osHomedir();
+  const readRegistry = deps.readRegistry ?? (() => defaultReadRegistry(home));
+  const writeRegistry =
+    deps.writeRegistry ?? ((registry: PortRegistry) => defaultWriteRegistry(home, registry));
+
+  const { registry, ports, assigned } = assignPorts(readRegistry(), profileName);
+  if (assigned) writeRegistry(registry);
+
+  return {
+    CLAUDE_MEM_DATA_DIR: claudeMemDataDir(profileName, home),
+    CLAUDE_MEM_CHROMA_ENABLED: "false",
+    CLAUDE_MEM_WORKER_PORT: String(ports.worker),
+    CLAUDE_MEM_SERVER_PORT: String(ports.server),
+  };
+}
+
+function defaultReadRegistry(home: string): PortRegistry {
+  const path = registryPath(home);
+  try {
+    if (!existsSync(path)) return { version: 1, slots: {} };
+    const raw = JSON.parse(readFileSync(path, "utf8")) as Partial<PortRegistry> | null;
+    if (!raw || typeof raw.slots !== "object" || raw.slots === null) {
+      return { version: 1, slots: {} };
+    }
+    return { version: raw.version ?? 1, slots: raw.slots as Record<string, number> };
+  } catch {
+    // Corrupt or unreadable registry — start fresh rather than block the launch.
+    return { version: 1, slots: {} };
+  }
+}
+
+function defaultWriteRegistry(home: string, registry: PortRegistry): void {
+  const path = registryPath(home);
+  mkdirSync(join(home, ".claude-mem"), { recursive: true });
+  // Write-then-rename so a registry read never sees a torn file. Two never-seen
+  // profiles launching in the same instant can still race the read-modify-write;
+  // that only mis-assigns on first launch and is fixable via `cue mem ports`.
+  const tmp = `${path}.tmp.${process.pid}`;
+  writeFileSync(tmp, `${JSON.stringify(registry, null, 2)}\n`);
+  renameSync(tmp, path);
+}
+
+export { EMPTY_REGISTRY };

package/src/lib/combo-history.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+
+import { recordCombo, type ComboRecord } from "./combo-history";
+
+describe("recordCombo", () => {
+  const capture = () => {
+    const lines: string[] = [];
+    return { lines, append: (l: string) => lines.push(l) };
+  };
+
+  test("writes a {ts, profile, primary} row for a real combo (≥2 parts)", () => {
+    const { lines, append } = capture();
+    const wrote = recordCombo(["gstack", "skill-writer", "core"], "2026-06-02T00:00:00.000Z", append);
+    expect(wrote).toBe(true);
+    expect(lines).toHaveLength(1);
+    const rec = JSON.parse(lines[0]!) as ComboRecord;
+    expect(rec.profile).toBe("gstack+skill-writer+core");
+    expect(rec.primary).toBe("gstack");
+    expect(rec.ts).toBe("2026-06-02T00:00:00.000Z");
+    expect(lines[0]!.endsWith("\n")).toBe(true);
+  });
+
+  test("a single-profile pick is not a combo → no write", () => {
+    const { lines, append } = capture();
+    expect(recordCombo(["gstack"], "t", append)).toBe(false);
+    expect(lines).toHaveLength(0);
+  });
+
+  test("dedupes parts before recording (so a+a+b → a+b)", () => {
+    const { lines, append } = capture();
+    recordCombo(["a", "a", "b"], "t", append);
+    expect((JSON.parse(lines[0]!) as ComboRecord).profile).toBe("a+b");
+  });
+
+  test("dedup that collapses to a single distinct part is not recorded", () => {
+    const { lines, append } = capture();
+    expect(recordCombo(["a", "a"], "t", append)).toBe(false);
+    expect(lines).toHaveLength(0);
+  });
+
+  test("trims whitespace and drops empty parts", () => {
+    const { lines, append } = capture();
+    recordCombo([" a ", "", " b "], "t", append);
+    expect((JSON.parse(lines[0]!) as ComboRecord).profile).toBe("a+b");
+  });
+
+  test("a throwing append is swallowed (best-effort) → returns false", () => {
+    const wrote = recordCombo(["a", "b"], "t", () => {
+      throw new Error("disk full");
+    });
+    expect(wrote).toBe(false);
+  });
+});

package/src/lib/combo-history.ts

@@ -0,0 +1,83 @@
+/**
+ * Combo history — a local, telemetry-independent record of multi-profile picks.
+ *
+ * When the picker confirms a combine (≥2 profiles), `recordCombo` appends one
+ * line to `~/.config/cue/combo-history.jsonl`. Unlike `analytics.jsonl` (gated
+ * on telemetry consent) and `session-log.jsonl` (written by the session-summary
+ * Stop hook), this file is written directly by the picker with no consent gate
+ * and no hook — so "remember the combos I pick" works out of the box.
+ *
+ * `pair-suggestions` folds these lines into its affinity map, so a combo picked
+ * once resurfaces (unchecked, hinted) the next time its primary is chosen.
+ *
+ * All writes are best-effort: a failure to append never blocks a launch.
+ */
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+/** Resolved path mirrors `pair-suggestions.sessionLogPath` (same config dir). */
+export function comboHistoryPath(): string {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && xdg.length > 0 ? xdg : join(homedir(), ".config");
+  return join(base, "cue", "combo-history.jsonl");
+}
+
+/** One recorded combo. `profile` is the full composite selector ("a+b+c") so
+ *  `computeAffinityMap` (which reads `.profile`) can consume it unchanged. */
+export interface ComboRecord {
+  ts: string;
+  profile: string;
+  /** Convenience field — the first part, the profile the user picked first. */
+  primary: string;
+}
+
+/**
+ * Append a combo to the history log. No-op (returns false) when there's fewer
+ * than two distinct parts — a single-profile pick isn't a combo. Deduplicates
+ * parts (preserving order) so "a+a+b" records as "a+b". `now` is injected for
+ * testability. Returns whether a line was written.
+ *
+ * `append` is injectable so tests don't touch the real config dir.
+ */
+export function recordCombo(
+  parts: string[],
+  now: string,
+  append: (line: string) => void = defaultAppend,
+): boolean {
+  const deduped: string[] = [];
+  for (const raw of parts) {
+    const part = raw.trim();
+    if (part.length > 0 && !deduped.includes(part)) deduped.push(part);
+  }
+  if (deduped.length < 2) return false;
+  const record: ComboRecord = {
+    ts: now,
+    profile: deduped.join("+"),
+    primary: deduped[0]!,
+  };
+  try {
+    append(JSON.stringify(record) + "\n");
+    return true;
+  } catch {
+    return false; // best-effort — never block a launch on a logging failure
+  }
+}
+
+/** Read the combo-history lines (newline-split, blank-tolerant). Missing file or
+ *  read error → []. Exposed so `pair-suggestions` can fold these into affinity. */
+export function readComboHistoryLines(path: string = comboHistoryPath()): string[] {
+  if (!existsSync(path)) return [];
+  try {
+    return readFileSync(path, "utf8").split("\n");
+  } catch {
+    return [];
+  }
+}
+
+function defaultAppend(line: string): void {
+  const path = comboHistoryPath();
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, line);
+}

package/src/lib/companion-detect.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "bun:test";
+
+import { detectCompanions, type CompanionDetectInput } from "./companion-detect";
+
+const KNOWN = new Set(["higgsfield", "blog-writer", "postizz", "creative-media"]);
+
+function run(
+  entries: string[],
+  extra: Partial<CompanionDetectInput> = {},
+): ReturnType<typeof detectCompanions> {
+  return detectCompanions({
+    cwd: "/work/volaria",
+    knownProfiles: KNOWN,
+    listEntries: () => entries,
+    ...extra,
+  });
+}
+
+describe("detectCompanions — images → higgsfield", () => {
+  test("≥3 image files suggest higgsfield, auto-checkable (≥0.7), with a count reason", () => {
+    const r = run(["a.png", "b.jpg", "c.webp", "d.jpeg"]);
+    const hf = r.find((s) => s.profile === "higgsfield");
+    expect(hf).toBeDefined();
+    expect(hf!.confidence).toBeGreaterThanOrEqual(0.7);
+    expect(hf!.reason).toBe("4 image assets");
+  });
+
+  test("fewer than 3 images produces no higgsfield signal", () => {
+    const r = run(["a.png", "b.png", "notes.txt"]);
+    expect(r.find((s) => s.profile === "higgsfield")).toBeUndefined();
+  });
+
+  test("confidence scales with count but caps at 0.9", () => {
+    const many = Array.from({ length: 30 }, (_, i) => `img${i}.png`);
+    const hf = run(many).find((s) => s.profile === "higgsfield");
+    expect(hf!.confidence).toBe(0.9);
+  });
+});
+
+describe("detectCompanions — video → higgsfield", () => {
+  test("a single video file suggests higgsfield", () => {
+    const hf = run(["clip.mp4"]).find((s) => s.profile === "higgsfield");
+    expect(hf).toBeDefined();
+    expect(hf!.confidence).toBeGreaterThanOrEqual(0.7);
+  });
+
+  test("images + video collapse to one higgsfield row, reasons merged", () => {
+    const r = run(["a.png", "b.png", "c.png", "reel.mov"]);
+    const hf = r.filter((s) => s.profile === "higgsfield");
+    expect(hf).toHaveLength(1);
+    expect(hf[0]!.reason).toContain("image assets");
+    expect(hf[0]!.reason).toContain("video file");
+  });
+});
+
+describe("detectCompanions — markdown → blog-writer", () => {
+  test("≥2 draft .md files suggest blog-writer but stay below auto-check", () => {
+    const bw = run(["draft-1.md", "draft-2.md"]).find((s) => s.profile === "blog-writer");
+    expect(bw).toBeDefined();
+    expect(bw!.confidence).toBeLessThan(0.7);
+  });
+
+  test("README/AGENTS/CLAUDE are not counted as drafts", () => {
+    const r = run(["README.md", "AGENTS.md", "CLAUDE.md"]);
+    expect(r.find((s) => s.profile === "blog-writer")).toBeUndefined();
+  });
+
+  test("a content/ entry alone is enough", () => {
+    const bw = run(["content", "x.txt"]).find((s) => s.profile === "blog-writer");
+    expect(bw).toBeDefined();
+  });
+});
+
+describe("detectCompanions — brand dir → postizz", () => {
+  test("cwd basename matching a registered brand suggests postizz", () => {
+    const pz = run(["whatever.txt"], { brands: new Set(["volaria", "slopix"]) }).find(
+      (s) => s.profile === "postizz",
+    );
+    expect(pz).toBeDefined();
+    expect(pz!.confidence).toBeGreaterThanOrEqual(0.7);
+    expect(pz!.reason).toBe("registered brand: volaria");
+  });
+
+  test("non-brand cwd basename yields no postizz signal", () => {
+    const r = run(["x.txt"], { cwd: "/work/random-proj", brands: new Set(["volaria"]) });
+    expect(r.find((s) => s.profile === "postizz")).toBeUndefined();
+  });
+});
+
+describe("detectCompanions — gating & robustness", () => {
+  test("companions not installed in this cue install are filtered out", () => {
+    const r = run(["a.png", "b.png", "c.png"], { knownProfiles: new Set(["blog-writer"]) });
+    expect(r.find((s) => s.profile === "higgsfield")).toBeUndefined();
+  });
+
+  test("results are sorted by confidence descending", () => {
+    const r = run(["a.png", "b.png", "c.png", "d.md", "e.md"], {
+      brands: new Set(["volaria"]),
+    });
+    const confs = r.map((s) => s.confidence);
+    expect(confs).toEqual([...confs].sort((a, b) => b - a));
+  });
+
+  test("an empty / unreadable directory yields no signals", () => {
+    expect(run([])).toEqual([]);
+    expect(detectCompanions({ cwd: "/work/x", knownProfiles: KNOWN })).toBeInstanceOf(Array);
+  });
+});