@astrofoundry/pi-astro 0.11.0 → 0.11.2

package/extensions/astro-footer/format.test.ts

@@ -53,10 +53,10 @@ describe("formatPercent", () => {
         expect(formatPercent(null)).toBe("—");
     });
 
-    it("rounds to nearest integer percent", () => {
+    it("rounds to nearest integer percent (input is 0-100, not 0-1)", () => {
         expect(formatPercent(0)).toBe("0%");
-        expect(formatPercent(0.4567)).toBe("46%");
-        expect(formatPercent(1)).toBe("100%");
+        expect(formatPercent(45.67)).toBe("46%");
+        expect(formatPercent(100)).toBe("100%");
     });
 });
 

package/extensions/astro-footer/format.ts

@@ -13,7 +13,7 @@ export function formatCost(usd: number): string {
 
 export function formatPercent(percent: number | null): string {
     if (percent === null) return "—";
-    return `${Math.round(percent * 100)}%`;
+    return `${Math.round(percent)}%`;
 }
 
 export function formatPathBasename(cwd: string): string {

package/extensions/astro-footer/icons.test.ts

@@ -40,15 +40,19 @@ describe("detectNerdFonts", () => {
 });
 
 describe("iconsFor", () => {
-    it("returns nerd-font icons when true", () => {
+    it("returns nerd-font icons when true (separator pipe, model diamond, path 'dir')", () => {
         const icons = iconsFor(true);
-        expect(icons.separator).toBe("");
+        expect(icons.separator).toBe("|");
+        expect(icons.model).toBe("◈");
+        expect(icons.path).toBe("dir");
         expect(icons.git).toBe("");
     });
 
-    it("returns ascii icons when false", () => {
+    it("returns ascii icons when false (pipe separator, dir prefix, ◈ model)", () => {
         const icons = iconsFor(false);
-        expect(icons.separator).toBe("›");
+        expect(icons.separator).toBe("|");
+        expect(icons.model).toBe("◈");
+        expect(icons.path).toBe("dir");
         expect(icons.git).toBe("git");
     });
 });

package/extensions/astro-footer/icons.ts

@@ -12,26 +12,26 @@ export interface IconSet {
 
 const NERD: IconSet = {
     pi: "π",
-    model: "",
+    model: "◈",
     thinking: "",
-    path: "",
+    path: "dir",
     git: "",
     tokens: "",
     cost: "",
     context: "",
-    separator: "",
+    separator: "|",
 };
 
 const ASCII: IconSet = {
     pi: "π",
-    model: "@",
+    model: "◈",
     thinking: "?",
-    path: "/",
+    path: "dir",
     git: "git",
     tokens: "tok",
     cost: "$",
     context: "ctx",
-    separator: "›",
+    separator: "|",
 };
 
 const NERD_TERM_PROGRAMS = new Set(["iTerm.app", "WezTerm", "ghostty"]);

package/extensions/astro-footer/index.test.ts

@@ -165,7 +165,7 @@ describe("astro-footer extension", () => {
                     },
                 ],
             },
-            getContextUsage: () => ({ tokens: 50, contextWindow: 200_000, percent: 0.25 }),
+            getContextUsage: () => ({ tokens: 50, contextWindow: 200_000, percent: 25 }),
         });
         await pi.handlers.session_start({}, ctx);
         const factory = ctx.ui.setFooter.mock.calls[0][0] as (
@@ -187,7 +187,7 @@ describe("astro-footer extension", () => {
         const lines = component.render(120);
         expect(lines).toHaveLength(1);
         const line = lines[0];
-        expect(line).toContain("claude-sonnet-4-6");
+        expect(line).toContain("Anthropic: Claude Sonnet 4 6");
         expect(line).toContain("proj");
         expect(line).toContain("main");
         expect(line).toContain("1.2k");

package/extensions/astro-footer/model-name.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { formatModelDisplay } from "./model-name.ts";
+
+describe("formatModelDisplay", () => {
+    it("formats moonshotai/kimi-k2.6 as MoonshotAI: Kimi K2.6", () => {
+        expect(formatModelDisplay("moonshotai/kimi-k2.6")).toBe("MoonshotAI: Kimi K2.6");
+    });
+
+    it("formats anthropic/claude-sonnet-4-6", () => {
+        expect(formatModelDisplay("anthropic/claude-sonnet-4-6")).toBe("Anthropic: Claude Sonnet 4 6");
+    });
+
+    it("uppercases known acronyms in the leaf (gpt → GPT)", () => {
+        expect(formatModelDisplay("openai/gpt-5.4-mini")).toBe("OpenAI: GPT 5.4 Mini");
+    });
+
+    it("uses the provider mapping (xai → xAI)", () => {
+        expect(formatModelDisplay("xai/grok-4")).toBe("xAI: Grok 4");
+    });
+
+    it("falls back to capitalising unknown providers", () => {
+        expect(formatModelDisplay("acme/super-model")).toBe("Acme: Super Model");
+    });
+
+    it("handles ids without a provider prefix", () => {
+        expect(formatModelDisplay("kimi-k2.6")).toBe("Kimi K2.6");
+    });
+
+    it("returns empty string for empty input", () => {
+        expect(formatModelDisplay("")).toBe("");
+    });
+
+    it("trims whitespace", () => {
+        expect(formatModelDisplay("  anthropic/claude-haiku-4-5  ")).toBe("Anthropic: Claude Haiku 4 5");
+    });
+
+    it("preserves slashes inside the leaf when the model id has multiple slashes", () => {
+        expect(formatModelDisplay("openai/o4/mini")).toBe("OpenAI: O4/mini");
+    });
+});

package/extensions/astro-footer/model-name.ts

@@ -0,0 +1,46 @@
+const PROVIDER_DISPLAY: Record<string, string> = {
+    anthropic: "Anthropic",
+    openai: "OpenAI",
+    "openai-codex": "OpenAI Codex",
+    moonshotai: "MoonshotAI",
+    google: "Google",
+    meta: "Meta",
+    "meta-llama": "Meta Llama",
+    mistralai: "MistralAI",
+    xai: "xAI",
+    deepseek: "DeepSeek",
+    perplexity: "Perplexity",
+    openrouter: "OpenRouter",
+    cohere: "Cohere",
+    together: "Together",
+    groq: "Groq",
+    qwen: "Qwen",
+};
+
+const ACRONYMS = new Set(["gpt", "ai", "llm", "api", "moe", "ssm", "vl"]);
+
+function capitalize(s: string): string {
+    if (s.length === 0) return s;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+function formatLeafWord(word: string): string {
+    if (word.length === 0) return word;
+    if (/^\d/.test(word)) return word;
+    if (ACRONYMS.has(word.toLowerCase())) return word.toUpperCase();
+    return capitalize(word);
+}
+
+export function formatModelDisplay(id: string): string {
+    const trimmed = id.trim();
+    if (trimmed.length === 0) return "";
+    if (!trimmed.includes("/")) {
+        return trimmed.split("-").map(formatLeafWord).join(" ");
+    }
+    const slash = trimmed.indexOf("/");
+    const providerRaw = trimmed.slice(0, slash);
+    const leaf = trimmed.slice(slash + 1);
+    const provider = PROVIDER_DISPLAY[providerRaw.toLowerCase()] ?? capitalize(providerRaw);
+    const leafFormatted = leaf.split("-").map(formatLeafWord).join(" ");
+    return `${provider}: ${leafFormatted}`;
+}

package/extensions/astro-footer/segments.test.ts

@@ -28,10 +28,10 @@ describe("segments", () => {
         expect(renderModel(fakeTheme, ICONS, undefined)).toBeNull();
     });
 
-    it("renderModel uses the last segment of a slash-separated id", () => {
-        const out = renderModel(fakeTheme, ICONS, "anthropic/claude-sonnet-4-6");
-        expect(out).toContain("claude-sonnet-4-6");
-        expect(out).not.toContain("anthropic/");
+    it("renderModel pretty-prints provider + model name in accent colour", () => {
+        const out = renderModel(fakeTheme, ICONS, "moonshotai/kimi-k2.6");
+        expect(out).toContain("<accent>◈</accent>");
+        expect(out).toContain("<accent>MoonshotAI: Kimi K2.6</accent>");
     });
 
     it("renderThinking returns null when level missing", () => {
@@ -87,18 +87,21 @@ describe("segments", () => {
     });
 
     it("renderContext uses dim colour below 70%", () => {
-        const out = renderContext(fakeTheme, ICONS, 0.5);
+        const out = renderContext(fakeTheme, ICONS, 50);
         expect(out).toContain("<dim>");
+        expect(out).toContain("50%");
     });
 
     it("renderContext uses warning colour at and above 70%", () => {
-        const out = renderContext(fakeTheme, ICONS, 0.7);
+        const out = renderContext(fakeTheme, ICONS, 70);
         expect(out).toContain("<warning>");
+        expect(out).toContain("70%");
     });
 
     it("renderContext uses error colour at and above 90%", () => {
-        const out = renderContext(fakeTheme, ICONS, 0.95);
+        const out = renderContext(fakeTheme, ICONS, 95);
         expect(out).toContain("<error>");
+        expect(out).toContain("95%");
     });
 
     it("renderExtensionStatus uses muted colour", () => {

package/extensions/astro-footer/segments.ts

@@ -1,6 +1,7 @@
 import type { ThemeColor } from "@mariozechner/pi-coding-agent";
 import type { IconSet } from "./icons.ts";
 import { formatCost, formatPathBasename, formatPercent, formatTokens } from "./format.ts";
+import { formatModelDisplay } from "./model-name.ts";
 
 export interface ThemeFn {
     fg: (role: ThemeColor, text: string) => string;
@@ -30,8 +31,8 @@ export function renderPi(theme: ThemeFn, icons: IconSet): string {
 
 export function renderModel(theme: ThemeFn, icons: IconSet, modelId: string | undefined): string | null {
     if (!modelId) return null;
-    const short = modelId.split("/").pop() ?? modelId;
-    return `${theme.fg("muted", icons.model)} ${theme.fg("text", short)}`.trim();
+    const display = formatModelDisplay(modelId);
+    return `${theme.fg("accent", icons.model)} ${theme.fg("accent", display)}`.trim();
 }
 
 export function renderThinking(theme: ThemeFn, icons: IconSet, level: string | undefined): string | null {
@@ -67,7 +68,7 @@ export function renderContext(
     percent: number | null,
 ): string | null {
     if (percent === null) return null;
-    const role: ThemeColor = percent >= 0.9 ? "error" : percent >= 0.7 ? "warning" : "dim";
+    const role: ThemeColor = percent >= 90 ? "error" : percent >= 70 ? "warning" : "dim";
     return `${theme.fg(role, icons.context)} ${theme.fg(role, formatPercent(percent))}`.trim();
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Personal pi customizations (extensions, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"