cue-ai 0.4.0 → 0.5.0

package/src/commands/cost.ts

@@ -2,15 +2,38 @@
  * `cue cost [profile]` — estimate token budget for a profile.
  */
 
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, existsSync, readdirSync } from "node:fs";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { loadProfile } from "../lib/profile-loader";
+import { loadProfile, listProfiles } from "../lib/profile-loader";
 import { resolveProfileForCwd } from "../lib/cwd-resolver";
 
 const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const SKILLS_ROOT = join(REPO_ROOT, "resources", "skills", "skills");
+
+// Expand wildcard (*/*) to all actual skill IDs on disk.
+function expandSkillIds(ids: string[]): string[] {
+  const result: string[] = [];
+  for (const id of ids) {
+    if (id === "*/*") {
+      try {
+        const cats = readdirSync(SKILLS_ROOT, { withFileTypes: true }).filter(d => d.isDirectory());
+        for (const cat of cats) {
+          const skills = readdirSync(join(SKILLS_ROOT, cat.name), { withFileTypes: true }).filter(d => d.isDirectory());
+          for (const s of skills) {
+            if (existsSync(join(SKILLS_ROOT, cat.name, s.name, "SKILL.md"))) {
+              result.push(`${cat.name}/${s.name}`);
+            }
+          }
+        }
+      } catch {}
+    } else if (!id.includes("*")) {
+      result.push(id);
+    }
+  }
+  return result;
+}
 const MCP_CONFIGS_DIR = join(REPO_ROOT, "resources", "mcps", "configs");
 
 function estimateTokens(text: string): number {
@@ -37,10 +60,61 @@ function getMcpToolCount(id: string): number {
   return 1;
 }
 
+async function runCompare(json: boolean): Promise<number> {
+  const profiles = await listProfiles();
+  const results: { name: string; skills: number; mcps: number; tokens: number; cost100: string }[] = [];
+
+  for (const name of profiles) {
+    try {
+      const profile = await loadProfile(name);
+      const skillIds = expandSkillIds(profile.skills.local.map((s: any) => s.id));
+      const skillTokens = skillIds.reduce((sum: number, id: string) => sum + getSkillTokens(id), 0);
+      const mcpIds = profile.mcps.map((m: any) => m.id);
+      const mcpToolCount = mcpIds.reduce((sum: number, id: string) => sum + getMcpToolCount(id), 0);
+      const total = skillTokens + (mcpToolCount * 50) + 200;
+      results.push({
+        name,
+        skills: skillIds.length,
+        mcps: mcpIds.length,
+        tokens: total,
+        cost100: (total * 0.000003 * 100).toFixed(2),
+      });
+    } catch { /* skip broken profiles */ }
+  }
+
+  results.sort((a, b) => a.tokens - b.tokens);
+
+  if (json) {
+    process.stdout.write(JSON.stringify(results, null, 2) + "\n");
+    return 0;
+  }
+
+  const maxTokens = results[results.length - 1]?.tokens ?? 1;
+
+  process.stdout.write("📊 Token budget comparison (all profiles)\n\n");
+  process.stdout.write(`  ${"Profile".padEnd(20)} ${"Skills".padStart(6)} ${"MCPs".padStart(5)} ${"Tokens".padStart(8)} ${"$/100msg".padStart(8)}  Budget\n`);
+  process.stdout.write(`  ${"─".repeat(20)} ${"─".repeat(6)} ${"─".repeat(5)} ${"─".repeat(8)} ${"─".repeat(8)}  ${"─".repeat(20)}\n`);
+
+  for (const r of results) {
+    const barLen = Math.max(1, Math.round((r.tokens / maxTokens) * 20));
+    const bar = "█".repeat(barLen) + "░".repeat(20 - barLen);
+    const level = r.tokens > 20000 ? "🔴" : r.tokens > 8000 ? "🟡" : "🟢";
+    process.stdout.write(`  ${r.name.padEnd(20)} ${String(r.skills).padStart(6)} ${String(r.mcps).padStart(5)} ${r.tokens.toLocaleString().padStart(8)} ${"$" + r.cost100.padStart(7)}  ${bar} ${level}\n`);
+  }
+
+  process.stdout.write(`\n  ${results.length} profiles compared. Cheapest: ${results[0]?.name}, most expensive: ${results[results.length - 1]?.name}\n`);
+  return 0;
+}
+
 export async function run(args: string[]): Promise<number> {
   const json = args.includes("--json");
+  const compare = args.includes("--compare");
   let profileName = args.find(a => !a.startsWith("-"));
 
+  if (compare) {
+    return runCompare(json);
+  }
+
   if (!profileName) {
     try { profileName = await resolveProfileForCwd(process.cwd()); } catch {
       process.stderr.write("No active profile. Specify one: cue cost <profile>\n");
@@ -51,7 +125,7 @@ export async function run(args: string[]): Promise<number> {
   const profile = await loadProfile(profileName!);
 
   // Skills cost
-  const skillIds = profile.skills.local.map(s => s.id);
+  const skillIds = expandSkillIds(profile.skills.local.map(s => s.id));
   const skillTokens = skillIds.reduce((sum, id) => sum + getSkillTokens(id), 0);
 
   // MCP cost (tool descriptions)

package/src/commands/diff.ts

@@ -1,13 +1,32 @@
 /**
  * `cue diff <profileA> <profileB>` — compare two profiles.
+ * `cue diff --live <target>` — show impact of switching from current to target.
  */
 
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
 import { loadProfile } from "../lib/profile-loader";
+import { resolveProfileForCwd } from "../lib/cwd-resolver";
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const SKILLS_ROOT = join(REPO_ROOT, "resources", "skills", "skills");
+
+function estimateTokens(text: string): number { return Math.ceil(text.length / 4); }
+function getSkillTokens(id: string): number {
+  try { return estimateTokens(readFileSync(join(SKILLS_ROOT, id, "SKILL.md"), "utf8")); } catch { return 0; }
+}
 
 export async function run(args: string[]): Promise<number> {
   const json = args.includes("--json");
+  const live = args.includes("--live");
   const names = args.filter(a => !a.startsWith("-"));
 
+  if (live) {
+    return runLive(names[0], json);
+  }
+
   if (names.length < 2) {
     process.stderr.write("Usage: cue diff <profileA> <profileB>\n");
     return 1;
@@ -85,3 +104,89 @@ export async function run(args: string[]): Promise<number> {
 
   return 0;
 }
+
+async function runLive(target: string | undefined, json: boolean): Promise<number> {
+  let current: string;
+  try {
+    const result = await resolveProfileForCwd({ cwd: process.cwd(), homeDir: require("node:os").homedir(), configDir: join(require("node:os").homedir(), ".config", "cue") });
+    if (result.source === "none") throw new Error("none");
+    current = result.profile;
+  } catch {
+    process.stderr.write("No active profile. Use: cue diff <current> <target>\n");
+    return 1;
+  }
+  if (!target) {
+    process.stderr.write("Usage: cue diff --live <target-profile>\n");
+    return 1;
+  }
+
+  let profileA, profileB;
+  try { profileA = await loadProfile(current); } catch (e) { process.stderr.write(`${e}\n`); return 1; }
+  try { profileB = await loadProfile(target); } catch (e) { process.stderr.write(`${e}\n`); return 1; }
+
+  const skillsA = new Set(profileA.skills.local.map(s => s.id));
+  const skillsB = new Set(profileB.skills.local.map(s => s.id));
+  const mcpsA = new Set(profileA.mcps.map(m => m.id));
+  const mcpsB = new Set(profileB.mcps.map(m => m.id));
+
+  const removed = [...skillsA].filter(s => !skillsB.has(s));
+  const added = [...skillsB].filter(s => !skillsA.has(s));
+  const mcpsRemoved = [...mcpsA].filter(m => !mcpsB.has(m));
+  const mcpsAdded = [...mcpsB].filter(m => !mcpsA.has(m));
+
+  const tokensA = [...skillsA].reduce((sum, id) => sum + getSkillTokens(id), 0) + 200;
+  const tokensB = [...skillsB].reduce((sum, id) => sum + getSkillTokens(id), 0) + 200;
+  const tokenDiff = tokensB - tokensA;
+  const costDiff = (tokenDiff * 0.000003 * 100); // per 100 messages
+
+  if (json) {
+    process.stdout.write(JSON.stringify({
+      from: current, to: target,
+      skills: { removed, added, removedCount: removed.length, addedCount: added.length },
+      mcps: { removed: mcpsRemoved, added: mcpsAdded },
+      tokens: { from: tokensA, to: tokensB, diff: tokenDiff },
+      costPer100: costDiff,
+    }, null, 2) + "\n");
+    return 0;
+  }
+
+  const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
+  const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
+  const red = (s: string) => `\x1b[31m${s}\x1b[0m`;
+  const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
+
+  process.stdout.write(`\n  Switching: ${bold(current)} → ${bold(target)}\n\n`);
+
+  // Summary line
+  const parts: string[] = [];
+  if (removed.length) parts.push(red(`-${removed.length} skills`));
+  if (added.length) parts.push(green(`+${added.length} skills`));
+  if (mcpsRemoved.length) parts.push(red(`-${mcpsRemoved.length} MCPs`));
+  if (mcpsAdded.length) parts.push(green(`+${mcpsAdded.length} MCPs`));
+  process.stdout.write(`  ${parts.join(", ")}\n`);
+
+  // Token impact
+  const arrow = tokenDiff < 0 ? green(`↓ saves ${Math.abs(tokenDiff).toLocaleString()} tokens/session`) :
+    tokenDiff > 0 ? red(`↑ adds ${tokenDiff.toLocaleString()} tokens/session`) : "no change";
+  process.stdout.write(`  ${arrow}\n`);
+
+  if (tokenDiff !== 0) {
+    const costStr = costDiff < 0 ? green(`saves $${Math.abs(costDiff).toFixed(2)}`) : red(`costs $${costDiff.toFixed(2)} more`);
+    process.stdout.write(`  ${costStr} per 100 messages\n`);
+  }
+
+  // Details
+  if (removed.length > 0) {
+    process.stdout.write(`\n  ${red("Removed skills:")}\n`);
+    for (const s of removed.slice(0, 10)) process.stdout.write(`    - ${s}\n`);
+    if (removed.length > 10) process.stdout.write(`    ${dim(`...+${removed.length - 10} more`)}\n`);
+  }
+  if (added.length > 0) {
+    process.stdout.write(`\n  ${green("Added skills:")}\n`);
+    for (const s of added.slice(0, 10)) process.stdout.write(`    + ${s}\n`);
+    if (added.length > 10) process.stdout.write(`    ${dim(`...+${added.length - 10} more`)}\n`);
+  }
+
+  process.stdout.write(`\n  ${dim("Apply with:")} cue use ${target}\n\n`);
+  return 0;
+}

package/src/commands/import-profile.ts

@@ -93,24 +93,28 @@ async function cmdImport(args: string[]): Promise<number> {
 async function cmdExport(args: string[]): Promise<number> {
   const profileName = args.find(a => !a.startsWith("-"));
   if (!profileName) {
-    process.stderr.write("Usage: cue export <profile> [--output <path>]\n");
+    process.stderr.write("Usage: cue export <profile> [--output <path>] [--portable]\n");
     return 1;
   }
 
   const outputIdx = args.indexOf("--output");
   const outputPath = outputIdx >= 0 ? args[outputIdx + 1] : null;
+  const portable = args.includes("--portable");
 
   const profile = await loadProfile(profileName);
   const yaml = require("yaml");
 
-  const portable = {
+  const SKILLS_ROOT = join(REPO_ROOT, "resources", "skills", "skills");
+
+  const base: Record<string, unknown> = {
     name: profile.name,
     description: profile.description,
     icon: profile.icon,
     _portable: {
       exported: new Date().toISOString(),
-      cue_version: "0.3.0",
+      cue_version: "0.4.1",
       inheritance_resolved: true,
+      self_contained: portable,
     },
     skills: { local: profile.skills.local.map(s => s.id) },
     mcps: profile.mcps.map(m => m.id),
@@ -118,11 +122,30 @@ async function cmdExport(args: string[]): Promise<number> {
     env: profile.env,
   };
 
-  const output = yaml.stringify(portable);
+  if (portable) {
+    // Bundle skill content inline
+    const skillContents: Record<string, string> = {};
+    for (const s of profile.skills.local) {
+      const skillPath = join(SKILLS_ROOT, s.id, "SKILL.md");
+      try {
+        skillContents[s.id] = readFileSync(skillPath, "utf8");
+      } catch { /* skill not on disk — skip */ }
+    }
+    if (Object.keys(skillContents).length > 0) {
+      (base as any)._skill_contents = skillContents;
+    }
+  }
+
+  const output = yaml.stringify(base);
 
   if (outputPath) {
     writeFileSync(outputPath, output);
-    process.stdout.write(`✅ Exported "${profileName}" to ${outputPath}\n`);
+    const size = (Buffer.byteLength(output) / 1024).toFixed(1);
+    process.stdout.write(`✅ Exported "${profileName}" to ${outputPath} (${size} KB)\n`);
+    if (portable) {
+      process.stdout.write(`   Self-contained: includes ${Object.keys((base as any)._skill_contents ?? {}).length} skill(s) inline\n`);
+      process.stdout.write(`   Share this file — recipient imports with: cue import ${outputPath}\n`);
+    }
   } else {
     process.stdout.write(output);
   }

package/src/commands/launch.e2e.test.ts

@@ -0,0 +1,119 @@
+/**
+ * E2e test for `cue launch` — tests the full resolve → materialize → exec flow.
+ * Uses --rematerialize to avoid actually exec'ing claude/codex.
+ */
+
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, writeFile, rm, readFile, readdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const CUE_BIN = join(import.meta.dir, "../index.ts");
+
+function cue(args: string[], opts: { cwd?: string; env?: Record<string, string> } = {}): { status: number; stdout: string; stderr: string } {
+  const res = spawnSync("bun", ["run", CUE_BIN, ...args], {
+    encoding: "utf8",
+    timeout: 15000,
+    cwd: opts.cwd ?? process.cwd(),
+    env: { ...process.env, ...opts.env },
+  });
+  return { status: res.status ?? 1, stdout: res.stdout ?? "", stderr: res.stderr ?? "" };
+}
+
+describe("cue launch e2e", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "cue-e2e-launch-"));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  test("launch --rematerialize with .cue-profile resolves and builds runtime", async () => {
+    // Create a .cue-profile pointing to a real profile
+    await writeFile(join(tmpDir, ".cue-profile"), "caveman-quick\n");
+
+    const res = cue(["launch", "claude", "--rematerialize"], { cwd: tmpDir });
+
+    expect(res.status).toBe(0);
+    expect(res.stdout).toContain("caveman-quick");
+    expect(res.stdout).toContain("runtimeDir");
+
+    // Parse the JSON output
+    const jsonMatch = res.stdout.match(/\{[\s\S]*\}/);
+    expect(jsonMatch).not.toBeNull();
+    const output = JSON.parse(jsonMatch![0]);
+    expect(output.profile).toBe("caveman-quick");
+    expect(output.agent).toBe("claude-code");
+    expect(output.hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+
+  test("launch --rematerialize second call is cache hit (rebuilt=false)", async () => {
+    await writeFile(join(tmpDir, ".cue-profile"), "core\n");
+
+    const first = cue(["launch", "claude", "--rematerialize"], { cwd: tmpDir });
+    expect(first.status).toBe(0);
+    const firstJson = JSON.parse(first.stdout.match(/\{[\s\S]*\}/)![0]);
+    expect(firstJson.rebuilt).toBe(true);
+
+    // Second call with same profile — may or may not be cache hit depending
+    // on whether CLAUDE.md includes dynamic content (timestamps, session summary).
+    // At minimum, it should succeed.
+    const second = cue(["launch", "claude", "--rematerialize"], { cwd: tmpDir });
+    expect(second.status).toBe(0);
+    const secondJson = JSON.parse(second.stdout.match(/\{[\s\S]*\}/)![0]);
+    expect(secondJson.profile).toBe("core");
+  });
+
+  test("launch resolves profile from .cue-profile in parent directory", async () => {
+    // Create a subdirectory and put .cue-profile in parent
+    const { mkdir } = await import("node:fs/promises");
+    const subDir = join(tmpDir, "src", "lib");
+    await mkdir(subDir, { recursive: true });
+    await writeFile(join(tmpDir, ".cue-profile"), "rust\n");
+
+    const res = cue(["launch", "claude", "--rematerialize"], { cwd: subDir });
+    expect(res.status).toBe(0);
+    const output = JSON.parse(res.stdout.match(/\{[\s\S]*\}/)![0]);
+    expect(output.profile).toBe("rust");
+  });
+
+  test("launch produces CLAUDE.md with profile stamp in runtime dir", async () => {
+    await writeFile(join(tmpDir, ".cue-profile"), "backend\n");
+
+    const res = cue(["launch", "claude", "--rematerialize"], { cwd: tmpDir });
+    expect(res.status).toBe(0);
+
+    const output = JSON.parse(res.stdout.match(/\{[\s\S]*\}/)![0]);
+    const claudeMd = await readFile(join(output.runtimeDir, "CLAUDE.md"), "utf8");
+    expect(claudeMd).toContain("profile=backend");
+    expect(claudeMd).toContain("Active Profile:");
+  });
+
+  test("launch produces settings.json with MCPs and plugins", async () => {
+    await writeFile(join(tmpDir, ".cue-profile"), "backend\n");
+
+    const res = cue(["launch", "claude", "--rematerialize"], { cwd: tmpDir });
+    expect(res.status).toBe(0);
+
+    const output = JSON.parse(res.stdout.match(/\{[\s\S]*\}/)![0]);
+    const settings = JSON.parse(await readFile(join(output.runtimeDir, "settings.json"), "utf8"));
+    expect(settings).toHaveProperty("mcpServers");
+    expect(settings).toHaveProperty("enabledPlugins");
+  });
+
+  test("launch creates skills/ symlinks in runtime dir", async () => {
+    await writeFile(join(tmpDir, ".cue-profile"), "backend\n");
+
+    const res = cue(["launch", "claude", "--rematerialize"], { cwd: tmpDir });
+    expect(res.status).toBe(0);
+
+    const output = JSON.parse(res.stdout.match(/\{[\s\S]*\}/)![0]);
+    const skillsDir = join(output.runtimeDir, "skills");
+    const entries = await readdir(skillsDir);
+    expect(entries.length).toBeGreaterThan(0);
+  });
+});

package/src/commands/launch.ts

@@ -461,6 +461,25 @@ export async function run(args: string[]): Promise<number> {
     credentialsSource,
   });
 
+  // Auto-doctor on first build: warn about missing CLIs/MCPs
+  if (runtime.rebuilt) {
+    try {
+      const { existsSync } = await import("node:fs");
+      const doctorFlag = join(configDir(), "runtime", profileName, ".doctor-done");
+      if (!existsSync(doctorFlag)) {
+        const { spawnSync } = await import("node:child_process");
+        const res = spawnSync(process.argv[0]!, [join(import.meta.dir, "../index.ts"), "doctor", "--quiet"], {
+          encoding: "utf8", timeout: 5000, stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (res.stdout?.includes("❌") || res.stdout?.includes("missing")) {
+          process.stderr.write("\x1b[33m⚠ cue doctor found issues. Run `cue doctor --fix` to repair.\x1b[0m\n");
+        }
+        const { writeFileSync } = await import("node:fs");
+        writeFileSync(doctorFlag, new Date().toISOString());
+      }
+    } catch { /* non-fatal */ }
+  }
+
   // --rematerialize: report and exit (no exec)
   if (parsed.rematerialize) {
     process.stdout.write(

package/src/commands/lock.ts

@@ -2,12 +2,14 @@
  * `cue lock <profile>` / `cue unlock <profile>` — profile locking.
  */
 
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
 
 const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const PROFILES_DIR = process.env.CUE_PROFILES_DIR ?? join(REPO_ROOT, "profiles");
+const SKILLS_ROOT = join(REPO_ROOT, "resources", "skills", "skills");
 
 export function isProfileLocked(profileName: string): { locked: boolean; by?: string; reason?: string } {
   const yamlPath = join(PROFILES_DIR, profileName, "profile.yaml");
@@ -84,5 +86,23 @@ export async function run(args: string[]): Promise<number> {
 
   writeFileSync(yamlPath, content);
   process.stdout.write(`🔒 Locked profile "${profileName}"${by ? ` (by ${by})` : ""}\n`);
+
+  // Generate profile.lock with skill content hashes
+  const { loadProfile } = await import("../lib/profile-loader");
+  try {
+    const profile = await loadProfile(profileName);
+    const lockEntries: Record<string, string> = {};
+    for (const s of profile.skills.local) {
+      const skillPath = join(SKILLS_ROOT, s.id, "SKILL.md");
+      if (existsSync(skillPath)) {
+        const hash = createHash("sha256").update(readFileSync(skillPath)).digest("hex").slice(0, 12);
+        lockEntries[s.id] = hash;
+      }
+    }
+    const lockFile = join(PROFILES_DIR, profileName, "profile.lock");
+    writeFileSync(lockFile, JSON.stringify({ locked_at: new Date().toISOString(), skills: lockEntries }, null, 2) + "\n");
+    process.stdout.write(`📋 Generated profile.lock (${Object.keys(lockEntries).length} skill hashes)\n`);
+  } catch { /* non-fatal */ }
+
   return 0;
 }

package/src/commands/marketplace.ts

@@ -14,11 +14,61 @@
 import { spawnSync } from "node:child_process";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { readFileSync, existsSync } from "node:fs";
 
 import { resolveProfileForCwd } from "../lib/cwd-resolver";
 
 const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const PROFILES_DIR = process.env.CUE_PROFILES_DIR ?? join(REPO_ROOT, "profiles");
+const REGISTRY_PATH = join(REPO_ROOT, "docs", "registry", "index.json");
+const REGISTRY_URL = "https://recodeee.github.io/cue/registry/index.json";
+
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+
+interface RegistrySkill {
+  id: string; name: string; description: string;
+  repo: string; path: string; tags: string[];
+  requires: string[]; profile: string;
+}
+interface RegistryMcp {
+  id: string; name: string; description: string;
+  repo: string; install: string; tags: string[];
+}
+interface Registry {
+  version: number; skills: RegistrySkill[]; mcps: RegistryMcp[];
+}
+
+function loadRegistry(): Registry | null {
+  // Try local first, then fetch remote
+  if (existsSync(REGISTRY_PATH)) {
+    try { return JSON.parse(readFileSync(REGISTRY_PATH, "utf8")); } catch {}
+  }
+  // Try fetching remote (sync via spawnSync curl)
+  const res = spawnSync("curl", ["-sfL", "--max-time", "5", REGISTRY_URL], { encoding: "utf8" });
+  if (res.status === 0 && res.stdout) {
+    try { return JSON.parse(res.stdout); } catch {}
+  }
+  return null;
+}
+
+function searchRegistry(query: string, registry: Registry): { skills: RegistrySkill[]; mcps: RegistryMcp[] } {
+  const q = query.toLowerCase();
+  const skills = registry.skills.filter(s =>
+    s.name.toLowerCase().includes(q) ||
+    s.description.toLowerCase().includes(q) ||
+    s.tags.some(t => t.includes(q)) ||
+    s.id.includes(q)
+  );
+  const mcps = registry.mcps.filter(m =>
+    m.name.toLowerCase().includes(q) ||
+    m.description.toLowerCase().includes(q) ||
+    m.tags.some(t => t.includes(q)) ||
+    m.id.includes(q)
+  );
+  return { skills, mcps };
+}
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -85,14 +135,49 @@ async function cmdSearchSkills(query: string, json: boolean): Promise<number> {
 }
 
 async function cmdSearch(query: string, json: boolean): Promise<number> {
-  if (!json) process.stdout.write(`🔍 Searching MCPs and skills for "${query}"...\n\n`);
+  if (!query) {
+    process.stderr.write("Usage: cue marketplace search <query>\n");
+    return 1;
+  }
+
+  // Search built-in registry first
+  const registry = loadRegistry();
+  if (registry) {
+    const results = searchRegistry(query, registry);
+    if (json) {
+      process.stdout.write(JSON.stringify(results, null, 2) + "\n");
+      return 0;
+    }
+    if (results.skills.length > 0) {
+      process.stdout.write("── Skills ──\n\n");
+      for (const s of results.skills) {
+        process.stdout.write(`  ${s.name}  (${s.repo})\n`);
+        process.stdout.write(`    ${s.description}\n`);
+        process.stdout.write(`    tags: ${s.tags.join(", ")}${s.requires.length ? `  requires: ${s.requires.join(", ")}` : ""}\n\n`);
+      }
+    }
+    if (results.mcps.length > 0) {
+      process.stdout.write("── MCPs ──\n\n");
+      for (const m of results.mcps) {
+        process.stdout.write(`  ${m.name}  (${m.install})\n`);
+        process.stdout.write(`    ${m.description}\n`);
+        process.stdout.write(`    tags: ${m.tags.join(", ")}\n\n`);
+      }
+    }
+    if (results.skills.length === 0 && results.mcps.length === 0) {
+      process.stdout.write(`No results for "${query}" in the registry.\n`);
+    } else {
+      process.stdout.write(`Install with: cue marketplace install-skill <repo>\n`);
+    }
+    return 0;
+  }
 
+  // Fallback to Smithery + npx
+  if (!json) process.stdout.write(`🔍 Searching MCPs and skills for "${query}"...\n\n`);
   if (!json) process.stdout.write("── MCPs (Smithery) ──\n\n");
   await cmdSearchMcps(query, json);
-
   if (!json) process.stdout.write("\n── Skills ──\n\n");
   await cmdSearchSkills(query, json);
-
   return 0;
 }