@selesai/code 0.7.0 → 0.8.1

package/dist/extensions/pi-powerline-footer/tests/working-vibes.test.ts

@@ -4,8 +4,22 @@ import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync }
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import { parseVibeGenerateArgs } from "../working-vibes.ts";
+
 const FAUX_PROVIDER_PATH = new URL("../node_modules/@earendil-works/pi-ai/dist/providers/faux.js", import.meta.url).href;
 
+async function importFauxProviderTools() {
+  try {
+    return await import("@earendil-works/pi-ai/compat");
+  } catch (error) {
+    const code = error && typeof error === "object" ? Reflect.get(error, "code") : undefined;
+    if (code !== "ERR_PACKAGE_PATH_NOT_EXPORTED" && code !== "ERR_MODULE_NOT_FOUND") {
+      throw error;
+    }
+    return import(FAUX_PROVIDER_PATH);
+  }
+}
+
 function ensurePiModuleLinks(): { cleanup: () => void } {
   const nodeModulesDir = join(process.cwd(), "node_modules", "@earendil-works");
   mkdirSync(nodeModulesDir, { recursive: true });
@@ -39,6 +53,15 @@ function ensurePiModuleLinks(): { cleanup: () => void } {
   };
 }
 
+test("parseVibeGenerateArgs supports multi-word themes", () => {
+  assert.deepEqual(parseVibeGenerateArgs(["pirate", "200"]), { theme: "pirate", count: 200 });
+  assert.deepEqual(parseVibeGenerateArgs(["star", "trek", "200"]), { theme: "star trek", count: 200 });
+  assert.deepEqual(parseVibeGenerateArgs(["star", "trek"]), { theme: "star trek", count: 100 });
+  assert.deepEqual(parseVibeGenerateArgs(["star", "trek", "abc"]), { theme: "star trek abc", count: 100 });
+  assert.deepEqual(parseVibeGenerateArgs(["lord", "of", "rings", "999"]), { theme: "lord of rings", count: 500 });
+  assert.equal(parseVibeGenerateArgs([]), null);
+});
+
 test("generateVibesBatch includes a system prompt so faux providers can return text", async () => {
   const links = ensurePiModuleLinks();
   const home = mkdtempSync(join(tmpdir(), "powerline-vibes-home-"));
@@ -46,50 +69,114 @@ test("generateVibesBatch includes a system prompt so faux providers can return t
   process.env.HOME = home;
 
   try {
-    const { fauxAssistantMessage, registerFauxProvider } = await import(FAUX_PROVIDER_PATH);
+    const { fauxAssistantMessage, fauxProvider } = await importFauxProviderTools();
     const { generateVibesBatch, initVibeManager, setVibeModel } = await import("../working-vibes.ts");
 
-    const registration = registerFauxProvider({
+    const registration = fauxProvider({
       provider: "test-provider",
       models: [{ id: "test-model" }],
     });
 
-    try {
-      const model = registration.getModel("test-model");
-      assert.ok(model);
-
-      registration.setResponses([
-        (context) => {
-          assert.match(context.systemPrompt ?? "", /loading messages/i);
-          return fauxAssistantMessage("Engaging warp drive...\nRunning diagnostics...");
-        },
-      ]);
-
-      initVibeManager({
-        modelRegistry: {
-          find(provider: string, modelId: string) {
-            return provider === "test-provider" && modelId === "test-model" ? model : undefined;
-          },
-          async getApiKeyAndHeaders() {
-            return { ok: true, apiKey: "test-key", headers: {} };
-          },
-        },
-      });
-
-      assert.equal(setVibeModel("test-provider/test-model"), true);
-
-      const result = await generateVibesBatch("star trek", 2);
-
-      assert.equal(result.success, true);
-      assert.equal(result.count, 2);
-      assert.equal(existsSync(result.filePath), true);
-      assert.deepEqual(readFileSync(result.filePath, "utf8").trim().split("\n"), [
-        "Engaging warp drive...",
-        "Running diagnostics...",
-      ]);
-    } finally {
-      registration.unregister();
+    const model = registration.getModel("test-model");
+    assert.ok(model);
+
+    registration.setResponses([
+      (context) => {
+        assert.match(context.systemPrompt ?? "", /loading messages/i);
+        return fauxAssistantMessage("Engaging warp drive...\nRunning diagnostics...");
+      },
+    ]);
+
+    initVibeManager({
+      modelRegistry: {
+        find(provider: string, modelId: string) {
+          return provider === "test-provider" && modelId === "test-model" ? model : undefined;
+        },
+        async getApiKeyAndHeaders() {
+          return { ok: true, apiKey: "test-key", headers: {} };
+        },
+        getProvider(provider: string) {
+          return provider === "test-provider" ? registration.provider : undefined;
+        },
+        async getProviderAuth() {
+          return undefined;
+        },
+      },
+    });
+
+    assert.equal(setVibeModel("test-provider/test-model"), true);
+
+    const result = await generateVibesBatch("star trek", 2);
+
+    assert.equal(result.success, true);
+    assert.equal(result.count, 2);
+    assert.equal(existsSync(result.filePath), true);
+    assert.deepEqual(readFileSync(result.filePath, "utf8").trim().split("\n"), [
+      "Engaging warp drive...",
+      "Running diagnostics...",
+    ]);
+  } finally {
+    if (previousHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = previousHome;
     }
+    rmSync(home, { recursive: true, force: true });
+    links.cleanup();
+  }
+});
+
+test("generateVibesBatch forwards resolved provider env and credential base URL", async () => {
+  const links = ensurePiModuleLinks();
+  const home = mkdtempSync(join(tmpdir(), "powerline-vibes-home-"));
+  const previousHome = process.env.HOME;
+  process.env.HOME = home;
+
+  try {
+    const { fauxAssistantMessage, fauxProvider } = await importFauxProviderTools();
+    const { generateVibesBatch, initVibeManager, setVibeModel } = await import("../working-vibes.ts");
+
+    const registration = fauxProvider({
+      provider: "test-provider",
+      models: [{ id: "test-model" }],
+    });
+
+    const model = registration.getModel("test-model");
+    assert.ok(model);
+
+    registration.setResponses([
+      (_context, options, _state, requestModel) => {
+        assert.deepEqual(options?.env, { AWS_PROFILE: "vibes" });
+        assert.equal(requestModel.baseUrl, "https://credential.example/v1");
+        return fauxAssistantMessage("Signing the request...");
+      },
+    ]);
+
+    initVibeManager({
+      modelRegistry: {
+        find(provider: string, modelId: string) {
+          return provider === "test-provider" && modelId === "test-model" ? model : undefined;
+        },
+        async getApiKeyAndHeaders() {
+          return { ok: true, apiKey: "test-key", headers: {}, env: { AWS_PROFILE: "vibes" } };
+        },
+        getProvider(provider: string) {
+          return provider === "test-provider" ? registration.provider : undefined;
+        },
+        async getProviderAuth() {
+          return { auth: { apiKey: "test-key", baseUrl: "https://credential.example/v1" } };
+        },
+      },
+    });
+
+    assert.equal(setVibeModel("test-provider/test-model"), true);
+
+    const result = await generateVibesBatch("bedrock", 1);
+
+    assert.equal(result.success, true);
+    assert.deepEqual(readFileSync(result.filePath, "utf8").trim().split("\n"), [
+      "Signing the request...",
+    ]);
   } finally {
     if (previousHome === undefined) {
       delete process.env.HOME;
@@ -108,55 +195,57 @@ test("on-demand vibe generation includes a system prompt for providers that requ
   process.env.HOME = home;
 
   try {
-    const { fauxAssistantMessage, registerFauxProvider } = await import(FAUX_PROVIDER_PATH);
+    const { fauxAssistantMessage, fauxProvider } = await importFauxProviderTools();
     const { initVibeManager, onVibeAgentStart, onVibeBeforeAgentStart, setVibeModel, setVibeTheme } = await import("../working-vibes.ts");
 
-    const registration = registerFauxProvider({
+    const registration = fauxProvider({
       provider: "test-provider",
       models: [{ id: "test-model" }],
     });
 
-    try {
-      const model = registration.getModel("test-model");
-      assert.ok(model);
+    const model = registration.getModel("test-model");
+    assert.ok(model);
 
-      registration.setResponses([
-        (context) => {
-          assert.match(context.systemPrompt ?? "", /loading messages/i);
-          return fauxAssistantMessage("Engaging warp drive...");
-        },
-      ]);
+    registration.setResponses([
+      (context) => {
+        assert.match(context.systemPrompt ?? "", /loading messages/i);
+        return fauxAssistantMessage("Engaging warp drive...");
+      },
+    ]);
 
-      initVibeManager({
-        modelRegistry: {
-          find(provider: string, modelId: string) {
-            return provider === "test-provider" && modelId === "test-model" ? model : undefined;
-          },
-          async getApiKeyAndHeaders() {
-            return { ok: true, apiKey: "test-key", headers: {} };
-          },
+    initVibeManager({
+      modelRegistry: {
+        find(provider: string, modelId: string) {
+          return provider === "test-provider" && modelId === "test-model" ? model : undefined;
         },
-      });
-
-      assert.equal(setVibeTheme("star trek"), true);
-      assert.equal(setVibeModel("test-provider/test-model"), true);
+        async getApiKeyAndHeaders() {
+          return { ok: true, apiKey: "test-key", headers: {} };
+        },
+        getProvider(provider: string) {
+          return provider === "test-provider" ? registration.provider : undefined;
+        },
+        async getProviderAuth() {
+          return undefined;
+        },
+      },
+    });
 
-      const updates: Array<string | undefined> = [];
-      onVibeAgentStart();
-      onVibeBeforeAgentStart("fix a bug", (message) => {
-        updates.push(message);
-      });
+    assert.equal(setVibeTheme("star trek"), true);
+    assert.equal(setVibeModel("test-provider/test-model"), true);
 
-      const start = Date.now();
-      while (!updates.includes("Engaging warp drive...") && Date.now() - start < 1000) {
-        await new Promise((resolve) => setTimeout(resolve, 10));
-      }
+    const updates: Array<string | undefined> = [];
+    onVibeAgentStart();
+    onVibeBeforeAgentStart("fix a bug", (message) => {
+      updates.push(message);
+    });
 
-      assert.equal(updates[0], "Channeling star trek...");
-      assert.ok(updates.includes("Engaging warp drive..."));
-    } finally {
-      registration.unregister();
+    const start = Date.now();
+    while (!updates.includes("Engaging warp drive...") && Date.now() - start < 1000) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
     }
+
+    assert.equal(updates[0], "Channeling star trek...");
+    assert.ok(updates.includes("Engaging warp drive..."));
   } finally {
     if (previousHome === undefined) {
       delete process.env.HOME;
@@ -175,45 +264,47 @@ test("generateVibesBatch preserves provider errors instead of reporting an empty
   process.env.HOME = home;
 
   try {
-    const { fauxAssistantMessage, registerFauxProvider } = await import(FAUX_PROVIDER_PATH);
+    const { fauxAssistantMessage, fauxProvider } = await importFauxProviderTools();
     const { generateVibesBatch, initVibeManager, setVibeModel } = await import("../working-vibes.ts");
 
-    const registration = registerFauxProvider({
+    const registration = fauxProvider({
       provider: "test-provider",
       models: [{ id: "test-model" }],
     });
 
-    try {
-      const model = registration.getModel("test-model");
-      assert.ok(model);
+    const model = registration.getModel("test-model");
+    assert.ok(model);
 
-      registration.setResponses([
-        fauxAssistantMessage([], {
-          stopReason: "error",
-          errorMessage: "Instructions are required",
-        }),
-      ]);
+    registration.setResponses([
+      fauxAssistantMessage([], {
+        stopReason: "error",
+        errorMessage: "Instructions are required",
+      }),
+    ]);
 
-      initVibeManager({
-        modelRegistry: {
-          find(provider: string, modelId: string) {
-            return provider === "test-provider" && modelId === "test-model" ? model : undefined;
-          },
-          async getApiKeyAndHeaders() {
-            return { ok: true, apiKey: "test-key", headers: {} };
-          },
+    initVibeManager({
+      modelRegistry: {
+        find(provider: string, modelId: string) {
+          return provider === "test-provider" && modelId === "test-model" ? model : undefined;
+        },
+        async getApiKeyAndHeaders() {
+          return { ok: true, apiKey: "test-key", headers: {} };
+        },
+        getProvider(provider: string) {
+          return provider === "test-provider" ? registration.provider : undefined;
         },
-      });
+        async getProviderAuth() {
+          return undefined;
+        },
+      },
+    });
 
-      assert.equal(setVibeModel("test-provider/test-model"), true);
+    assert.equal(setVibeModel("test-provider/test-model"), true);
 
-      const result = await generateVibesBatch("noir", 2);
+    const result = await generateVibesBatch("noir", 2);
 
-      assert.equal(result.success, false);
-      assert.equal(result.error, "Instructions are required");
-    } finally {
-      registration.unregister();
-    }
+    assert.equal(result.success, false);
+    assert.equal(result.error, "Instructions are required");
   } finally {
     if (previousHome === undefined) {
       delete process.env.HOME;

package/dist/extensions/pi-powerline-footer/theme.ts

@@ -11,6 +11,7 @@ import type { Theme, ThemeColor } from "@selesai/code";
 import { existsSync, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { getAgentPath } from "./paths.ts";
 import type { ColorScheme, ColorValue, SemanticColor, ThemeLike } from "./types.ts";
 
 export interface PowerlineThemeConfig {
@@ -34,6 +35,7 @@ const DEFAULT_COLORS: Required<ColorScheme> = {
   contextError: "error",
   cost: "text",
   tokens: "muted",
+  queue: "accent",
   separator: "dim",
   border: "borderMuted",
 };
@@ -47,8 +49,10 @@ const RAINBOW_COLORS = [
 // Cache for user theme overrides
 let userThemeCache: ColorScheme | null = null;
 let userThemeCacheTime = 0;
+let userThemeCacheKey = "";
 let themeConfigCache: PowerlineThemeConfig | null = null;
 let themeConfigCacheTime = 0;
+let themeConfigCacheKey = "";
 const CACHE_TTL = 5000; // 5 seconds
 const warnedInvalidThemeColors = new Set<string>();
 
@@ -82,50 +86,60 @@ function sanitizeUserThemeOverrides(value: unknown): ColorScheme {
 }
 
 /**
- * Get the path to the theme.json file
+ * Get theme.json lookup paths.
  */
-function getThemePath(): string {
+function getThemePaths(): string[] {
   const extDir = dirname(fileURLToPath(import.meta.url));
-  return join(extDir, "theme.json");
+  return Array.from(new Set([
+    getAgentPath("extensions", "powerline-footer", "theme.json"),
+    join(extDir, "theme.json"),
+  ]));
 }
 
 /**
- * Load user theme config from theme.json
+ * Load user theme config from theme.json.
  */
 export function loadThemeConfig(): PowerlineThemeConfig {
   const now = Date.now();
-  if (themeConfigCache && now - themeConfigCacheTime < CACHE_TTL) {
+  const themePaths = getThemePaths();
+  const cacheKey = themePaths.join("\0");
+  if (themeConfigCache && themeConfigCacheKey === cacheKey && now - themeConfigCacheTime < CACHE_TTL) {
     return themeConfigCache;
   }
 
-  const themePath = getThemePath();
-  try {
-    if (existsSync(themePath)) {
-      const content = readFileSync(themePath, "utf-8");
-      const parsed = JSON.parse(content);
-      themeConfigCache = isRecord(parsed) ? parsed : {};
-      themeConfigCacheTime = now;
-      return themeConfigCache;
+  for (const themePath of themePaths) {
+    try {
+      if (existsSync(themePath)) {
+        const content = readFileSync(themePath, "utf-8");
+        const parsed = JSON.parse(content);
+        themeConfigCache = isRecord(parsed) ? parsed : {};
+        themeConfigCacheTime = now;
+        themeConfigCacheKey = cacheKey;
+        return themeConfigCache;
+      }
+    } catch (error) {
+      // Theme overrides are optional. If the file is unreadable or malformed,
+      // keep rendering with built-in defaults instead of breaking the footer.
+      console.debug(`[powerline-theme] Failed to load ${themePath}:`, error);
     }
-  } catch (error) {
-    // Theme overrides are optional. If the file is unreadable or malformed,
-    // keep rendering with built-in defaults instead of breaking the footer.
-    console.debug(`[powerline-theme] Failed to load ${themePath}:`, error);
   }
 
   themeConfigCache = {};
   themeConfigCacheTime = now;
+  themeConfigCacheKey = cacheKey;
   return themeConfigCache;
 }
 
 function loadUserTheme(): ColorScheme {
   const now = Date.now();
-  if (userThemeCache && now - userThemeCacheTime < CACHE_TTL) {
+  const cacheKey = getThemePaths().join("\0");
+  if (userThemeCache && userThemeCacheKey === cacheKey && now - userThemeCacheTime < CACHE_TTL) {
     return userThemeCache;
   }
 
   userThemeCache = sanitizeUserThemeOverrides(loadThemeConfig().colors);
   userThemeCacheTime = now;
+  userThemeCacheKey = cacheKey;
   return userThemeCache;
 }