cue-ai 0.9.2 → 0.9.3

package/src/commands/debug.ts

@@ -2,7 +2,7 @@
  * `cue debug [profile]` — trace why skills/MCPs aren't loading.
  *
  * Walks the full resolution chain and reports at each step:
- * - Profile resolution (which .cue-profile, inheritance chain)
+ * - Profile resolution (which .cue.profile, inheritance chain)
  * - Skill resolution (found/missing, path, size)
  * - MCP resolution (in registry or not, env vars set)
  * - Plugin resolution (installed or not)
@@ -45,7 +45,7 @@ export async function run(args: string[]): Promise<number> {
       const resolved = await resolveProfileForCwd({ cwd, homeDir: homedir(), configDir: join(homedir(), ".config", "cue") });
       if (resolved.source === "none") {
         process.stdout.write(`    ${red("✗")} No profile found for ${cwd}\n`);
-        process.stdout.write(`    ${dim("Fix: echo <profile> > .cue-profile or pass a profile name")}\n\n`);
+        process.stdout.write(`    ${dim("Fix: echo <profile> > .cue.profile or pass a profile name")}\n\n`);
         return 1;
       }
       profileName = (resolved as any).profile;

package/src/commands/discover.ts

@@ -455,9 +455,9 @@ export function getInstalledIn(gem: GemRepo, profilesDir = join(REPO_ROOT, "prof
   return hits;
 }
 
-/** Detect active profile from cwd (`.cue-profile` file). Returns undefined if none. */
+/** Detect active profile from cwd (`.cue.profile` file). Returns undefined if none. */
 export function getActiveProfile(cwd: string = process.cwd()): string | undefined {
-  const f = join(cwd, ".cue-profile");
+  const f = join(cwd, ".cue.profile");
   if (!existsSync(f)) return undefined;
   try {
     const s = readFileSync(f, "utf8").trim();
@@ -1177,12 +1177,22 @@ ${cards}
 // names), and so the repo's authors get a backlink from cue.dev.
 // ---------------------------------------------------------------------------
 
+/**
+ * Escape a string for a double-quoted YAML scalar in generated frontmatter.
+ * Repo descriptions routinely contain `"` and `\` (e.g. `Tell Claude "deploy this"`),
+ * which break Jekyll's YAML parser if interpolated raw — failing the landing build.
+ * Escapes backslash + double-quote and collapses newlines to spaces.
+ */
+function yamlStr(s: string): string {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/[\r\n]+/g, " ");
+}
+
 function buildRepoPage(gem: GemRepo, updated: string): string {
   const icon = tierIcon(gem.gem_score);
   const profileLinks = gem.suggested_profiles.map((p) => `[${p}](../${p}.md)`).join(", ") || "_(no profile match)_";
   return `---
-title: "${gem.full_name} — Claude Code skill discovered by cue"
-description: "${(gem.description || `Claude Code skill from ${gem.full_name}`).slice(0, 160)}"
+title: "${yamlStr(`${gem.full_name} — Claude Code skill discovered by cue`)}"
+description: "${yamlStr((gem.description || `Claude Code skill from ${gem.full_name}`).slice(0, 160))}"
 layout: page
 updated: ${updated.split("T")[0]}
 tags: [claude-code, skill, ${gem.suggested_profiles.join(", ")}]

package/src/commands/export-docker.ts

@@ -108,7 +108,7 @@ COPY resources/ /app/resources/
 WORKDIR /app
 
 # Pin profile
-RUN echo "${profileName}" > .cue-profile
+RUN echo "${profileName}" > .cue.profile
 
 # Pre-materialize runtime
 RUN cue use ${profileName} || true

package/src/commands/features-batch1.test.ts

@@ -54,7 +54,7 @@ describe("cue suggest", () => {
 
   test("returns 1 with no active profile", async () => {
     const { run } = await import("./suggest");
-    // Without a .cue-profile in cwd, should fail gracefully
+    // Without a .cue.profile in cwd, should fail gracefully
     const origCwd = process.cwd();
     process.chdir(tmp);
     const { code, stderr } = await capture(() => run([]));

package/src/commands/gates.ts

@@ -85,7 +85,7 @@ function helpText(): string {
 function resolveActiveProfile(explicit: string | null): string | null {
   if (explicit) return explicit;
   // Pinned to cwd?
-  const pin = join(process.cwd(), ".cue-profile");
+  const pin = join(process.cwd(), ".cue.profile");
   if (existsSync(pin)) {
     try {
       const txt = readFileSync(pin, "utf8").trim().split("\n")[0]?.trim();

package/src/commands/import-profile.ts

@@ -86,7 +86,7 @@ async function cmdImport(args: string[]): Promise<number> {
 
   process.stdout.write(`✅ Imported profile "${name}" to profiles/${name}/\n`);
   process.stdout.write(`   Activate with: cue use ${name}\n`);
-  process.stdout.write(`   Pin with: echo ${name} > .cue-profile\n`);
+  process.stdout.write(`   Pin with: echo ${name} > .cue.profile\n`);
   return 0;
 }
 

package/src/commands/init.ts

@@ -6,7 +6,7 @@
  *      default-profile composite, opts into local analytics, and marks
  *      `.onboarded` so subsequent `cue init` calls skip straight to phase 2.
  *   2. **Per-directory pinning** (always): scan cwd, suggest the best
- *      profile, write `.cue-profile`, offer to install discovered gems.
+ *      profile, write `.cue.profile`, offer to install discovered gems.
  */
 
 import { spawnSync } from "node:child_process";
@@ -14,7 +14,7 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import * as p from "@clack/prompts";
 
-import { detectProfile } from "../lib/auto-detect";
+import { detectProfileV2 } from "../lib/auto-detect";
 import { scanProject } from "../lib/project-scanner";
 import { listProfiles } from "../lib/profile-loader";
 import { getCachedGemsForProfile, autoInstallClis } from "./discover";
@@ -61,18 +61,22 @@ export async function runGlobalOnboarding(): Promise<boolean> {
 
   // Step 1: default-profile composite.
   const defaultPick = await p.select<string>({
-    message: "Default profile — loads when no .cue-profile is pinned to a directory:",
+    message: "Default profile — loads when no .cue.profile is pinned to a directory:",
     options: [
+      {
+        value: "core",
+        label: "core only",
+        hint: "recommended - smallest default context",
+      },
       {
         value: "core+skill-writer",
         label: "core + skill-writer",
-        hint: "recommended — minimal base plus skill management",
+        hint: "optional - add skill management when needed",
       },
-      { value: "core", label: "core only", hint: "smallest — just the base" },
       { value: "__custom", label: "Custom…", hint: "type a +-separated composite" },
       { value: "__skip", label: "Skip for now", hint: "falls back to plain `core`" },
     ],
-    initialValue: "core+skill-writer",
+    initialValue: "core",
   });
   if (p.isCancel(defaultPick)) return false;
 
@@ -80,7 +84,7 @@ export async function runGlobalOnboarding(): Promise<boolean> {
   if (defaultPick === "__custom") {
     const custom = await p.text({
       message: "Composite (e.g., core+skill-writer+backend):",
-      placeholder: "core+skill-writer",
+      placeholder: "core",
       validate: (v) => {
         const parts = (v ?? "").split("+").map((s) => s.trim()).filter((s) => s.length > 0);
         if (parts.length === 0) return "Must contain at least one profile name";
@@ -244,7 +248,7 @@ export async function run(args: string[]): Promise<number> {
   }
 
   // Score
-  const suggestions = detectProfile(cwd);
+  const suggestions = detectProfileV2(cwd);
   const allProfiles = await listProfiles();
 
   // Present options
@@ -255,7 +259,7 @@ export async function run(args: string[]): Promise<number> {
     options.push({
       value: s.profile,
       label: s.profile,
-      hint: `${s.confidence}% match — ${s.signals.join(", ")}`,
+      hint: `${Math.round(s.confidence * 100)}% match — ${s.reasons.join(", ")}`,
     });
   }
 
@@ -303,7 +307,7 @@ export async function run(args: string[]): Promise<number> {
     const { run: createProfile } = await import("./create-profile");
     await createProfile([name as string, "--description", desc as string, "--icon", "🔧"]);
 
-    writeFileSync(join(cwd, ".cue-profile"), (name as string) + "\n");
+    writeFileSync(join(cwd, ".cue.profile"), (name as string) + "\n");
     await offerDiscoverGems(name as string);
     await ensureShim();
     p.outro(`✅ Created profile "${name}" and pinned to this directory.`);
@@ -311,7 +315,7 @@ export async function run(args: string[]): Promise<number> {
   }
 
   // Pin the chosen profile
-  writeFileSync(join(cwd, ".cue-profile"), (choice as string) + "\n");
+  writeFileSync(join(cwd, ".cue.profile"), (choice as string) + "\n");
   await offerDiscoverGems(choice as string);
   await ensureShim();
   p.outro(`✅ Pinned "${choice}" to this directory. Next \`claude\` launch will use it.`);

package/src/commands/install.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Tests for `cue install`. The command defaults to dry-run, so these never
+ * write real runtimes or execute package managers.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { run as installRun } from "./install";
+
+async function capture<T>(fn: () => Promise<T>): Promise<{ stdout: string; stderr: string; value: T }> {
+  const origOut = process.stdout.write.bind(process.stdout);
+  const origErr = process.stderr.write.bind(process.stderr);
+  let stdout = "";
+  let stderr = "";
+  (process.stdout as any).write = (c: string | Uint8Array) => { stdout += String(c); return true; };
+  (process.stderr as any).write = (c: string | Uint8Array) => { stderr += String(c); return true; };
+  try {
+    const value = await fn();
+    return { stdout, stderr, value };
+  } finally {
+    (process.stdout as any).write = origOut;
+    (process.stderr as any).write = origErr;
+  }
+}
+
+const envKeys = ["XDG_CONFIG_HOME", "CUE_PROFILES_DIR", "SOUL_PROFILES_DIR"] as const;
+const oldEnv = new Map<string, string | undefined>();
+for (const key of envKeys) oldEnv.set(key, process.env[key]);
+
+afterEach(() => {
+  for (const key of envKeys) {
+    const value = oldEnv.get(key);
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+});
+
+describe("cue install", () => {
+  test("dry-run JSON plans Claude and Codex runtimes for an explicit profile", async () => {
+    const root = mkdtempSync(join(tmpdir(), "cue-install-test-"));
+    process.env.XDG_CONFIG_HOME = root;
+    try {
+      const { stdout, value } = await capture(() => installRun(["core", "--json"]));
+      expect(value).toBe(0);
+      const out = JSON.parse(stdout) as {
+        dryRun: boolean;
+        profiles: string[];
+        agents: string[];
+        actions: Array<{ profile: string; agent: string; targetDir: string; status: string }>;
+      };
+      expect(out.dryRun).toBe(true);
+      expect(out.profiles).toEqual(["core"]);
+      expect(out.agents).toEqual(["claude-code", "codex"]);
+      expect(out.actions.map((a) => [a.profile, a.agent, a.status])).toEqual([
+        ["core", "claude-code", "planned"],
+        ["core", "codex", "planned"],
+      ]);
+      expect(out.actions[0]!.targetDir).toContain(join(root, "cue", "runtime", "core"));
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("--all-profiles uses the configured profile directory in dry-run", async () => {
+    const root = mkdtempSync(join(tmpdir(), "cue-install-test-"));
+    const profiles = join(root, "profiles");
+    mkdirSync(join(profiles, "alpha"), { recursive: true });
+    mkdirSync(join(profiles, "beta"), { recursive: true });
+    writeFileSync(join(profiles, "alpha", "profile.yaml"), "name: alpha\ndescription: Alpha profile\n");
+    writeFileSync(join(profiles, "beta", "profile.yaml"), "name: beta\ndescription: Beta profile\n");
+    process.env.CUE_PROFILES_DIR = profiles;
+    process.env.XDG_CONFIG_HOME = root;
+    try {
+      const { stdout, value } = await capture(() => installRun(["--all-profiles", "--agents", "claude", "--json"]));
+      expect(value).toBe(0);
+      const out = JSON.parse(stdout) as {
+        profiles: string[];
+        agents: string[];
+        actions: Array<{ profile: string; agent: string; status: string }>;
+      };
+      expect(out.profiles).toEqual(["alpha", "beta"]);
+      expect(out.agents).toEqual(["claude-code"]);
+      expect(out.actions).toHaveLength(2);
+      expect(out.actions.every((a) => a.status === "planned")).toBe(true);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("--with-clis --json includes CLI plans without executing installers", async () => {
+    const root = mkdtempSync(join(tmpdir(), "cue-install-test-"));
+    process.env.XDG_CONFIG_HOME = root;
+    try {
+      const { stdout, value } = await capture(() => installRun(["core", "--with-clis", "--json"]));
+      expect(value).toBe(0);
+      const out = JSON.parse(stdout) as {
+        dryRun: boolean;
+        cliResults: Array<{ profile: string; code: number; plan?: { plans?: unknown[]; text?: string } }>;
+      };
+      expect(out.dryRun).toBe(true);
+      expect(out.cliResults).toHaveLength(1);
+      expect(out.cliResults[0]!.profile).toBe("core");
+      expect(out.cliResults[0]!.code).toBe(0);
+      expect(out.cliResults[0]!.plan?.plans || out.cliResults[0]!.plan?.text).toBeTruthy();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("external agents require explicit scope and stay dry-run by default", async () => {
+    const root = mkdtempSync(join(tmpdir(), "cue-install-test-"));
+    const target = join(root, "target");
+    process.env.XDG_CONFIG_HOME = root;
+    try {
+      const { stdout, value } = await capture(() => installRun(["core", "--agents", "cursor", "--dir", target, "--json"]));
+      expect(value).toBe(0);
+      const out = JSON.parse(stdout) as {
+        dryRun: boolean;
+        agents: string[];
+        actions: Array<{ agent: string; targetDir: string; status: string }>;
+      };
+      expect(out.dryRun).toBe(true);
+      expect(out.agents).toEqual(["cursor"]);
+      expect(out.actions[0]).toMatchObject({ agent: "cursor", targetDir: target, status: "planned" });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("doctor JSON reports profile runtime checks", async () => {
+    const root = mkdtempSync(join(tmpdir(), "cue-install-test-"));
+    process.env.XDG_CONFIG_HOME = root;
+    try {
+      const { stdout } = await capture(() => installRun(["doctor", "core", "--json"]));
+      const out = JSON.parse(stdout) as { reports: Array<{ profile: string; agent: string; missingMcps: string[] }> };
+      expect(out.reports.length).toBeGreaterThan(0);
+      expect(out.reports[0]!.profile).toBe("core");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("repo installer dry-run describes clone without network", async () => {
+    const root = mkdtempSync(join(tmpdir(), "cue-install-test-"));
+    process.env.XDG_CONFIG_HOME = root;
+    try {
+      const { stdout, value } = await capture(() => installRun(["repo", "garrytan/gstack", "--profile", "maker", "--json"]));
+      expect(value).toBe(0);
+      const out = JSON.parse(stdout) as { dryRun: boolean; repo: string; profile: string; discoveredSkills: string[] };
+      expect(out.dryRun).toBe(true);
+      expect(out.repo).toBe("garrytan/gstack");
+      expect(out.profile).toBe("maker");
+      expect(out.discoveredSkills).toEqual([]);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("repo installer accepts flags before the repo argument", async () => {
+    const root = mkdtempSync(join(tmpdir(), "cue-install-test-"));
+    process.env.XDG_CONFIG_HOME = root;
+    try {
+      const { stdout, value } = await capture(() => installRun(["repo", "--profile", "maker", "garrytan/gstack", "--json"]));
+      expect(value).toBe(0);
+      const out = JSON.parse(stdout) as { repo: string; profile: string };
+      expect(out.repo).toBe("garrytan/gstack");
+      expect(out.profile).toBe("maker");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("missing profile context returns a usage-level error", async () => {
+    const cwd = process.cwd();
+    const dir = mkdtempSync(join(tmpdir(), "cue-install-cwd-"));
+    const configRoot = mkdtempSync(join(tmpdir(), "cue-install-empty-config-"));
+    try {
+      process.env.XDG_CONFIG_HOME = configRoot;
+      process.chdir(dir);
+      const { stderr, value } = await capture(() => installRun(["--json"]));
+      expect(value).toBe(1);
+      expect(stderr).toContain("no active profile");
+    } finally {
+      process.chdir(cwd);
+      rmSync(dir, { recursive: true, force: true });
+      rmSync(configRoot, { recursive: true, force: true });
+    }
+  });
+});