cue-ai 0.4.0 → 0.5.0

package/src/lib/auto-detect.ts

@@ -13,10 +13,15 @@ interface Signal {
 }
 
 const SIGNALS: Signal[] = [
-  // Frontend
-  { file: "next.config.js", weight: 5, profile: "frontend" },
-  { file: "next.config.ts", weight: 5, profile: "frontend" },
-  { file: "next.config.mjs", weight: 5, profile: "frontend" },
+  // Frontend / Next.js
+  { file: "next.config.js", weight: 5, profile: "nextjs" },
+  { file: "next.config.ts", weight: 5, profile: "nextjs" },
+  { file: "next.config.mjs", weight: 5, profile: "nextjs" },
+  { file: "app/layout.tsx", weight: 4, profile: "nextjs" },
+  { file: "app/page.tsx", weight: 3, profile: "nextjs" },
+  { file: "next.config.js", weight: 4, profile: "frontend" },
+  { file: "next.config.ts", weight: 4, profile: "frontend" },
+  { file: "next.config.mjs", weight: 4, profile: "frontend" },
   { file: "vite.config.ts", weight: 4, profile: "frontend" },
   { file: "vite.config.js", weight: 4, profile: "frontend" },
   { file: "tailwind.config.js", weight: 3, profile: "frontend" },
@@ -24,7 +29,7 @@ const SIGNALS: Signal[] = [
   { file: "postcss.config.js", weight: 2, profile: "frontend" },
   { file: "tsconfig.json", weight: 1, profile: "frontend" },
 
-  // Backend
+  // Backend (Node/TS)
   { file: "docker-compose.yml", weight: 3, profile: "backend" },
   { file: "docker-compose.yaml", weight: 3, profile: "backend" },
   { file: "Dockerfile", weight: 2, profile: "backend" },
@@ -34,6 +39,31 @@ const SIGNALS: Signal[] = [
   { file: "src/server.ts", weight: 3, profile: "backend" },
   { file: "src/index.ts", weight: 1, profile: "backend" },
 
+  // Python API
+  { file: "pyproject.toml", weight: 4, profile: "python-api" },
+  { file: "setup.py", weight: 3, profile: "python-api" },
+  { file: "requirements.txt", weight: 3, profile: "python-api" },
+  { file: "app/main.py", weight: 5, profile: "python-api" },
+  { file: "main.py", weight: 3, profile: "python-api" },
+  { file: "manage.py", weight: 5, profile: "python-api" },
+  { file: "uvicorn.ini", weight: 4, profile: "python-api" },
+  { file: "alembic.ini", weight: 4, profile: "python-api" },
+  { file: ".python-version", weight: 2, profile: "python-api" },
+
+  // Rust
+  { file: "Cargo.toml", weight: 5, profile: "rust" },
+  { file: "Cargo.lock", weight: 3, profile: "rust" },
+  { file: "src/main.rs", weight: 4, profile: "rust" },
+  { file: "src/lib.rs", weight: 3, profile: "rust" },
+  { file: ".cargo/config.toml", weight: 2, profile: "rust" },
+
+  // Go API
+  { file: "go.mod", weight: 5, profile: "go-api" },
+  { file: "go.sum", weight: 3, profile: "go-api" },
+  { file: "cmd/", weight: 3, profile: "go-api" },
+  { file: "internal/", weight: 2, profile: "go-api" },
+  { file: "main.go", weight: 4, profile: "go-api" },
+
   // Medusa
   { file: "medusa-config.js", weight: 5, profile: "medusa-dev" },
   { file: "medusa-config.ts", weight: 5, profile: "medusa-dev" },
@@ -58,6 +88,9 @@ const SIGNALS: Signal[] = [
   // Research
   { file: "research/", weight: 3, profile: "research" },
   { file: "papers/", weight: 3, profile: "research" },
+
+  // Three.js
+  { file: "three.js", weight: 4, profile: "threejs" },
 ];
 
 export interface DetectionResult {

package/src/lib/cache.ts

@@ -10,16 +10,13 @@
  *   - cacheHit(key)         -> true iff a non-empty cache dir exists
  *   - cachePut(key, srcDir) -> atomic-ish move of an already-prepared
  *                              directory into the cache slot
+ *   - cacheEvict(layout)    -> prune LRU entries beyond MAX_CACHE_ENTRIES
  *
  * The cache root is injected so tests can use tmpdir() instead of touching
  * the real profiles/_cache/ tree.
- *
- * TODO(future): cache eviction policy. Today the cache grows unbounded until
- * a human runs `rm -rf profiles/_cache/npx/*`. A future iteration should add
- * LRU + a size budget + a `soul cache prune` subcommand.
  */
 
-import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, utimesSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
 export interface CacheLayout {
@@ -29,6 +26,9 @@ export interface CacheLayout {
 
 const NPX_SUBDIR = "npx";
 
+/** Maximum number of cache entries before LRU eviction kicks in. */
+export const MAX_CACHE_ENTRIES = 20;
+
 /**
  * Resolve the absolute cache dir for a given key. Does NOT create it.
  *
@@ -54,7 +54,10 @@ export function cacheHit(layout: CacheLayout, key: string): boolean {
     const st = statSync(dir);
     if (!st.isDirectory()) return false;
     const entries = readdirSync(dir);
-    return entries.length > 0;
+    if (entries.length === 0) return false;
+    // Touch atime to mark as recently used (LRU tracking).
+    try { utimesSync(dir, new Date(), st.mtime); } catch {}
+    return true;
   } catch {
     return false;
   }
@@ -78,6 +81,8 @@ export function cachePut(layout: CacheLayout, key: string, srcDir: string): stri
     rmSync(dest, { recursive: true, force: true });
   }
   renameSync(srcDir, dest);
+  // Evict oldest entries if over budget.
+  cacheEvict(layout);
   return dest;
 }
 
@@ -99,3 +104,39 @@ export function cacheChildren(layout: CacheLayout, key: string): string[] {
 export function cacheSkillPath(layout: CacheLayout, key: string, skill: string): string {
   return join(cachePath(layout, key), skill);
 }
+
+/**
+ * LRU eviction: remove the least-recently-accessed entries when the cache
+ * exceeds MAX_CACHE_ENTRIES. Uses directory atime (updated on cacheHit).
+ * Non-fatal — eviction errors are silently ignored.
+ */
+export function cacheEvict(layout: CacheLayout, maxEntries = MAX_CACHE_ENTRIES): number {
+  const cacheRoot = resolve(layout.repoRoot, "profiles", "_cache", NPX_SUBDIR);
+  if (!existsSync(cacheRoot)) return 0;
+
+  let entries: { name: string; atime: number }[];
+  try {
+    entries = readdirSync(cacheRoot)
+      .map((name) => {
+        try {
+          const st = statSync(join(cacheRoot, name));
+          return st.isDirectory() ? { name, atime: st.atimeMs } : null;
+        } catch { return null; }
+      })
+      .filter((e): e is { name: string; atime: number } => e !== null);
+  } catch { return 0; }
+
+  if (entries.length <= maxEntries) return 0;
+
+  // Sort by atime ascending (oldest first), remove excess.
+  entries.sort((a, b) => a.atime - b.atime);
+  const toRemove = entries.slice(0, entries.length - maxEntries);
+  let removed = 0;
+  for (const entry of toRemove) {
+    try {
+      rmSync(join(cacheRoot, entry.name), { recursive: true, force: true });
+      removed++;
+    } catch {}
+  }
+  return removed;
+}

package/src/lib/runtime-materializer.test.ts

@@ -118,10 +118,10 @@ describe("materializeRuntime", () => {
     expect(Object.keys(settings.mcpServers)).toEqual(["claude-mem"]);
   });
 
-  test("credentialsSource: symlinks .credentials.json into runtime (token refreshes write back to source)", async () => {
+  test("credentialsSource: copies .credentials.json into runtime (token refreshes stay local)", async () => {
     const credSrc = join(root, "creds");
     const { mkdir, writeFile } = await import("node:fs/promises");
-    const { readlink } = await import("node:fs/promises");
+    const { lstat } = await import("node:fs/promises");
     await mkdir(credSrc, { recursive: true });
     await writeFile(join(credSrc, ".credentials.json"), '{"claudeAiOauth":{"token":"abc"}}');
 
@@ -135,10 +135,12 @@ describe("materializeRuntime", () => {
       credentialsSource: credSrc,
     });
 
-    // Should be a symlink to the source (so token refreshes propagate back)
-    const linkTarget = await readlink(join(out.runtimeDir, ".credentials.json"));
-    expect(linkTarget).toBe(join(credSrc, ".credentials.json"));
-    // And reading it returns the source contents
+    // Should be a regular file (copy), not a symlink — Claude Code's token
+    // refresh does atomic write (tmp → rename) which breaks symlinks.
+    const st = await lstat(join(out.runtimeDir, ".credentials.json"));
+    expect(st.isSymbolicLink()).toBe(false);
+    expect(st.isFile()).toBe(true);
+    // Contents match the source
     const contents = await readFile(join(out.runtimeDir, ".credentials.json"), "utf8");
     expect(contents).toBe('{"claudeAiOauth":{"token":"abc"}}');
   });
@@ -170,7 +172,13 @@ describe("materializeRuntime", () => {
     expect(await readlink(join(out.runtimeDir, "projects"))).toBe(join(credSrc, "projects"));
     expect(await readlink(join(out.runtimeDir, "history.jsonl"))).toBe(join(credSrc, "history.jsonl"));
     expect(await readlink(join(out.runtimeDir, ".session-stats.json"))).toBe(join(credSrc, ".session-stats.json"));
-    expect(await readlink(join(out.runtimeDir, ".credentials.json"))).toBe(join(credSrc, ".credentials.json"));
+
+    // .credentials.json is COPIED (not symlinked) because Claude Code's
+    // token refresh does atomic write which breaks symlinks.
+    const { lstat: lstatCred } = await import("node:fs/promises");
+    const credSt = await lstatCred(join(out.runtimeDir, ".credentials.json"));
+    expect(credSt.isSymbolicLink()).toBe(false);
+    expect(credSt.isFile()).toBe(true);
 
     // settings.json is cue-managed: NOT a symlink, but a real merged file.
     const { lstat } = await import("node:fs/promises");
@@ -246,18 +254,21 @@ describe("materializeRuntime", () => {
       userClaudeMd: "",
     };
 
-    // First launch with account A → builds runtime with A's symlinks + settings
+    // First launch with account A → builds runtime with A's creds + settings
     const first = await materializeRuntime({ ...args, credentialsSource: credSrcA });
     expect(first.rebuilt).toBe(true);
-    expect(await readlink(join(first.runtimeDir, ".credentials.json"))).toBe(join(credSrcA, ".credentials.json"));
+    // .credentials.json is a copy, not a symlink
+    const contentsA = await readFile(join(first.runtimeDir, ".credentials.json"), "utf8");
+    expect(contentsA).toBe('{"token":"A"}');
     let s1 = JSON.parse(await readFile(join(first.runtimeDir, "settings.json"), "utf8"));
     expect(s1.permissions.allow).toEqual(["A"]);
 
     // Second launch with account B (same profile) → hash matches → cache hit.
-    // Settings rebuilt from B; symlinks repointed to B.
+    // Settings rebuilt from B; .credentials.json re-copied from B.
     const second = await materializeRuntime({ ...args, credentialsSource: credSrcB });
     expect(second.rebuilt).toBe(false);
-    expect(await readlink(join(second.runtimeDir, ".credentials.json"))).toBe(join(credSrcB, ".credentials.json"));
+    const contentsB = await readFile(join(second.runtimeDir, ".credentials.json"), "utf8");
+    expect(contentsB).toBe('{"token":"B"}');
     let s2 = JSON.parse(await readFile(join(second.runtimeDir, "settings.json"), "utf8"));
     expect(s2.permissions.allow).toEqual(["B"]);
   });

package/src/lib/runtime-materializer.ts

@@ -13,6 +13,14 @@ import { dirname, join } from "node:path";
 
 import type { AgentKind, ResolvedProfile } from "../../profiles/_types";
 
+/** MCP server configuration as stored in the registry. */
+export interface McpServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+}
+
 export interface MaterializeInput {
   profile: ResolvedProfile;
   agent: AgentKind;
@@ -20,7 +28,7 @@ export interface MaterializeInput {
   /** Map skill id → source dir on disk (caller resolves local/npx/plugin paths). */
   skillSourceLookup: (id: string) => Promise<string>;
   /** Pre-resolved sanitized MCP registry for this agent. */
-  mcpRegistry: Record<string, unknown>;
+  mcpRegistry: Record<string, McpServerConfig>;
   /** Content of ~/.claude/CLAUDE.md (or ~/.codex/AGENTS.md) to append. */
   userClaudeMd: string;
   /** Directory to copy .credentials.json from (e.g. a pre-set CLAUDE_CONFIG_DIR). */
@@ -96,7 +104,7 @@ export async function materializeRuntime(input: MaterializeInput): Promise<Mater
   }
 
   // 2. settings.json (Claude) or config.toml (Codex) — Claude-only first cut.
-  const mcpServers: Record<string, unknown> = {};
+  const mcpServers: Record<string, McpServerConfig> = {};
   for (const m of profile.mcps) {
     if (!appliesToAgent(m, agent)) continue;
     const reg = input.mcpRegistry[m.id];
@@ -154,6 +162,20 @@ export async function materializeRuntime(input: MaterializeInput): Promise<Mater
     stamp += `## MCP Servers: ${mcpsList.join(", ")}\n\n`;
   }
 
+  // Skill usage analytics — help the model prioritize frequently-used skills
+  try {
+    const { skillStats } = await import("./analytics");
+    const stats = skillStats(profile.name);
+    if (stats.length > 0) {
+      stamp += `## Skill Usage (last 30 days)\n\n`;
+      stamp += `Prioritize these skills — they're the ones actually used:\n`;
+      for (const s of stats.slice(0, 8)) {
+        stamp += `- \`${s.skill}\` (${s.hits}× used)\n`;
+      }
+      stamp += "\n";
+    }
+  } catch { /* analytics unavailable — skip */ }
+
   // Profile fit monitoring
   stamp += `## Profile Fit Monitor\n\n` +
     `Track how well this profile matches the work being done. If you notice:\n` +
@@ -195,15 +217,34 @@ export async function materializeRuntime(input: MaterializeInput): Promise<Mater
   }
 
   // 6. Atomic swap: rm -rf old, rename tmp.
-  // Preserve .claude.json and backups/ — Claude Code writes session state here
-  // and resume depends on it surviving across rematerializations.
-  const preserveFiles = [".claude.json", "backups"];
+  //
+  // Preserve session/credential state from the OLD runtime so resume + auth
+  // survive across rematerializations:
+  //   - .claude.json      → session state, projects list, oauthAccount
+  //   - .credentials.json → OAuth tokens (refresh + access)
+  //   - backups/          → Claude Code's own .claude.json backup chain
+  //
+  // We MOVE these from the old runtime over whatever the overlay step (5)
+  // dropped into tmpDir — so a logged-in runtime stays logged in even when
+  // ~/.claude.json (the credentialsSource) is in a stale/half-logged-out
+  // state. Without this, an authmux account swap or a partial claude write
+  // to the source would propagate into every cue-materialized profile.
+  //
+  // Trade-off: to fresh-bootstrap a profile after deliberately switching
+  // accounts at the source, run:
+  //   rm ~/.config/cue/runtime/<profile>/claude/.credentials.json
+  //   rm ~/.config/cue/runtime/<profile>/claude/.claude.json
+  // Next launch will copy current source state.
+  const preserveFiles = [".claude.json", ".credentials.json", "backups"];
   for (const name of preserveFiles) {
     const oldPath = join(runtimeDir, name);
     const newPath = join(tmpDir, name);
     try {
       const st = await lstat(oldPath);
       if (st.isFile() || st.isDirectory()) {
+        // Remove whatever overlay put here (likely a symlink for .claude.json
+        // or a copy for .credentials.json) so rename can replace it cleanly.
+        await rm(newPath, { force: true, recursive: true });
         await rename(oldPath, newPath);
       }
     } catch { /* doesn't exist — skip */ }
@@ -260,9 +301,9 @@ async function overlaySourceState(targetDir: string, sourceDir: string): Promise
       existingType = st.isSymbolicLink() ? "symlink" : "other";
     } catch { /* missing */ }
 
-    if (existingType === "other") continue; // cue override — don't touch
+    if (existingType === "other" && name !== ".credentials.json") continue; // cue override — don't touch
 
-    if (existingType === "symlink") {
+    if (existingType === "symlink" || (existingType === "other" && name === ".credentials.json")) {
       // Replace if it points elsewhere (e.g. previous account on cache hit).
       try {
         await rm(targetPath, { force: true });
@@ -295,7 +336,7 @@ async function buildClaudeSettings(
     if (!appliesToAgent(plugin, agent)) continue;
     enabledPlugins[plugin.id] = true;
   }
-  const mcpServers: Record<string, unknown> = {};
+  const mcpServers: Record<string, McpServerConfig> = {};
   for (const m of profile.mcps) {
     if (!appliesToAgent(m, agent)) continue;
     const reg = input.mcpRegistry[m.id];
@@ -352,20 +393,22 @@ async function getLastSessionSummary(profileName: string): Promise<string | null
 
     if (!projectDir) return null;
 
-    // Find most recent .jsonl
-    const sessions = readdirSync(projectDir)
-      .filter((f) => f.endsWith(".jsonl"))
+    // Find most recent .jsonl (limit scan to avoid slow stat on large dirs)
+    const allFiles = readdirSync(projectDir).filter((f) => f.endsWith(".jsonl"));
+    if (allFiles.length === 0) return null;
+
+    // Sort by name (includes timestamp) — take last 3 only
+    const recent = allFiles.sort().slice(-3);
+    const sessions = recent
       .map((f) => ({ name: f, mtime: statSync(join(projectDir, f)).mtimeMs }))
       .sort((a, b) => b.mtime - a.mtime);
 
-    if (sessions.length === 0) return null;
-
     const lastFile = join(projectDir, sessions[0]!.name);
     const lastMtime = new Date(sessions[0]!.mtime);
     const ago = formatTimeAgo(lastMtime);
 
     // Extract a quick summary: last few assistant messages
-    const res = spawnSync("tail", ["-50", lastFile], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    const res = spawnSync("tail", ["-50", lastFile], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 2000 });
     if (!res.stdout) return null;
 
     const lines = res.stdout.split("\n").filter(Boolean);
@@ -422,7 +465,7 @@ async function getSkillChains(skillsList: string[]): Promise<string | null> {
     const res = spawnSync("grep", ["-roh", "skills/[a-z][a-z0-9-]*/SKILL.md", projectsDir], {
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf8",
-      timeout: 5000,
+      timeout: 2000,
     });
 
     if (!res.stdout) return null;

package/src/lib/star-prompt.ts

@@ -10,13 +10,23 @@ import { spawnSync } from "node:child_process";
 
 const CONFIG_DIR = join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cue");
 const FLAG_FILE = join(CONFIG_DIR, ".star-prompted");
+const ANALYTICS_FILE = join(CONFIG_DIR, "analytics.jsonl");
 const REPO = "recodeee/cue";
+const SESSION_THRESHOLD = 10;
 
 export async function maybePromptStar(): Promise<void> {
   // Only prompt once ever
   if (existsSync(FLAG_FILE)) return;
   // Only in interactive TTY
   if (!process.stdin.isTTY || !process.stdout.isTTY) return;
+
+  // Only after N sessions
+  let sessionCount = 0;
+  try {
+    const content = require("node:fs").readFileSync(ANALYTICS_FILE, "utf8");
+    sessionCount = (content.match(/"event":"start"/g) ?? []).length;
+  } catch {}
+  if (sessionCount < SESSION_THRESHOLD) return;
   // Check if gh CLI is available
   const ghCheck = spawnSync("gh", ["--version"], { encoding: "utf8", timeout: 3000 });
   if (ghCheck.status !== 0) { markDone(); return; }

package/profiles/_cache/bun/ajv@8.20.0@@@1/.runkit_example.js

@@ -1,23 +0,0 @@
-const Ajv = require("ajv")
-const ajv = new Ajv({allErrors: true})
-
-const schema = {
-  type: "object",
-  properties: {
-    foo: {type: "string"},
-    bar: {type: "number", maximum: 3},
-  },
-  required: ["foo", "bar"],
-  additionalProperties: false,
-}
-
-const validate = ajv.compile(schema)
-
-test({foo: "abc", bar: 2})
-test({foo: 2, bar: 4})
-
-function test(data) {
-  const valid = validate(data)
-  if (valid) console.log("Valid!")
-  else console.log("Invalid: " + ajv.errorsText(validate.errors))
-}

package/profiles/_cache/bun/ajv@8.20.0@@@1/LICENSE

@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015-2021 Evgeny Poberezkin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-