@astrofoundry/pi-astro 0.12.2 → 0.13.1

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

@@ -1,6 +1,8 @@
 import { describe, expect, it } from "vitest";
 import { iconsFor } from "./icons.ts";
+import { ZERO_COUNTS } from "./git-status.ts";
 import {
+    renderCache,
     renderContext,
     renderCost,
     renderExtensionStatus,
@@ -8,6 +10,9 @@ import {
     renderModel,
     renderPath,
     renderPi,
+    renderSessionName,
+    renderSessionTime,
+    renderSubagents,
     renderThinking,
     renderTokens,
     type ThemeFn,
@@ -48,69 +53,156 @@ describe("segments", () => {
     });
 
     it("renderThinking falls back gracefully on unknown level", () => {
-        const out = renderThinking(fakeTheme, ICONS, "weird");
-        expect(out).toContain("think:weird");
+        expect(renderThinking(fakeTheme, ICONS, "weird")).toContain("think:weird");
     });
 
-    it("renderPath shows the basename of cwd", () => {
-        const out = renderPath(fakeTheme, ICONS, "/Users/astro/proj");
+    it("renderPath shows the basename of cwd in basename mode", () => {
+        const out = renderPath(fakeTheme, ICONS, "/Users/astro/proj", "basename");
         expect(out).toContain("proj");
     });
 
     it("renderGit returns null when no branch", () => {
-        expect(renderGit(fakeTheme, ICONS, null)).toBeNull();
+        expect(renderGit(fakeTheme, ICONS, null, ZERO_COUNTS)).toBeNull();
     });
 
-    it("renderGit shows branch name in success colour", () => {
-        const out = renderGit(fakeTheme, ICONS, "feat-foo");
-        expect(out).toContain("<success>feat-foo</success>");
+    it("renderGit shows branch in success colour when clean", () => {
+        const out = renderGit(fakeTheme, ICONS, "main", ZERO_COUNTS);
+        expect(out).toContain("<success>main</success>");
+        expect(out).not.toContain("+");
+        expect(out).not.toContain("*");
     });
 
-    it("renderTokens hides when total is zero", () => {
-        expect(renderTokens(fakeTheme, ICONS, 0)).toBeNull();
+    it("renderGit shows ± counts and warning colour when dirty", () => {
+        const out = renderGit(fakeTheme, ICONS, "feat", { staged: 2, unstaged: 3, untracked: 1 });
+        expect(out).toContain("<warning>feat</warning>");
+        expect(out).toContain("<success>+2</success>");
+        expect(out).toContain("<warning>*3</warning>");
+        expect(out).toContain("<muted>?1</muted>");
     });
 
-    it("renderTokens formats large totals", () => {
-        expect(renderTokens(fakeTheme, ICONS, 1234)).toContain("1.2k");
+    it("renderTokens hides when both totals are zero", () => {
+        expect(renderTokens(fakeTheme, ICONS, 0, 0)).toBeNull();
     });
 
-    it("renderCost hides when zero", () => {
-        expect(renderCost(fakeTheme, ICONS, 0)).toBeNull();
+    it("renderTokens splits input/output with arrows", () => {
+        const out = renderTokens(fakeTheme, ICONS, 1234, 567);
+        expect(out).toContain("↑");
+        expect(out).toContain("1.2k");
+        expect(out).toContain("↓");
+        expect(out).toContain("567");
     });
 
-    it("renderCost formats sub-dollar costs", () => {
-        expect(renderCost(fakeTheme, ICONS, 0.123)).toContain("$0.123");
+    it("renderCost shows (sub) when subscription-covered", () => {
+        const out = renderCost(fakeTheme, ICONS, { costUsd: 0, isSubscription: true });
+        expect(out).toContain("<success>(sub)</success>");
     });
 
-    it("renderContext hides when input is null or percent is null", () => {
+    it("renderCost hides when zero and not subscription", () => {
+        expect(renderCost(fakeTheme, ICONS, { costUsd: 0, isSubscription: false })).toBeNull();
+    });
+
+    it("renderCost formats sub-dollar costs when not subscription", () => {
+        const out = renderCost(fakeTheme, ICONS, { costUsd: 0.123, isSubscription: false });
+        expect(out).toContain("$0.123");
+    });
+
+    it("renderContext hides when input is null or percent null", () => {
         expect(renderContext(fakeTheme, ICONS, null)).toBeNull();
-        expect(renderContext(fakeTheme, ICONS, { percent: null, contextWindow: 256_000 })).toBeNull();
+        expect(
+            renderContext(fakeTheme, ICONS, { percent: null, contextWindow: 256_000, autoCompact: true }),
+        ).toBeNull();
     });
 
     it("renderContext uses dim colour below 70%", () => {
-        const out = renderContext(fakeTheme, ICONS, { percent: 50, contextWindow: 256_000 });
+        const out = renderContext(fakeTheme, ICONS, {
+            percent: 50,
+            contextWindow: 256_000,
+            autoCompact: false,
+        });
         expect(out).toContain("<dim>");
         expect(out).toContain("50.0%/256k");
     });
 
-    it("renderContext uses warning colour at and above 70%", () => {
-        const out = renderContext(fakeTheme, ICONS, { percent: 70, contextWindow: 200_000 });
+    it("renderContext uses warning at 70%", () => {
+        const out = renderContext(fakeTheme, ICONS, {
+            percent: 70,
+            contextWindow: 200_000,
+            autoCompact: false,
+        });
         expect(out).toContain("<warning>");
         expect(out).toContain("70.0%/200k");
     });
 
-    it("renderContext uses error colour at and above 90%", () => {
-        const out = renderContext(fakeTheme, ICONS, { percent: 95.5, contextWindow: 1_000_000 });
+    it("renderContext uses error at 90%+", () => {
+        const out = renderContext(fakeTheme, ICONS, {
+            percent: 95.5,
+            contextWindow: 1_000_000,
+            autoCompact: false,
+        });
         expect(out).toContain("<error>");
         expect(out).toContain("95.5%/1.0M");
     });
 
+    it("renderContext appends AC indicator when auto-compact is on", () => {
+        const out = renderContext(fakeTheme, ICONS, {
+            percent: 25,
+            contextWindow: 256_000,
+            autoCompact: true,
+        });
+        expect(out).toContain("AC");
+    });
+
     it("renderContext omits the /total suffix when contextWindow is missing", () => {
-        const out = renderContext(fakeTheme, ICONS, { percent: 25, contextWindow: 0 });
+        const out = renderContext(fakeTheme, ICONS, {
+            percent: 25,
+            contextWindow: 0,
+            autoCompact: false,
+        });
         expect(out).toContain("25.0%");
         expect(out).not.toContain("25.0%/");
     });
 
+    it("renderSubagents hides when count is 0", () => {
+        expect(renderSubagents(fakeTheme, ICONS, 0)).toBeNull();
+    });
+
+    it("renderSubagents shows the count in accent colour", () => {
+        const out = renderSubagents(fakeTheme, ICONS, 3);
+        expect(out).toContain("<accent>3</accent>");
+    });
+
+    it("renderSessionTime hides under 60 seconds", () => {
+        expect(renderSessionTime(fakeTheme, ICONS, 0)).toBeNull();
+        expect(renderSessionTime(fakeTheme, ICONS, 30_000)).toBeNull();
+        expect(renderSessionTime(fakeTheme, ICONS, 59_999)).toBeNull();
+    });
+
+    it("renderSessionTime formats minutes and seconds at and above 1 minute", () => {
+        const out = renderSessionTime(fakeTheme, ICONS, 12 * 60_000 + 34_000);
+        expect(out).toContain("12m34s");
+    });
+
+    it("renderSessionName hides when undefined", () => {
+        expect(renderSessionName(fakeTheme, ICONS, undefined)).toBeNull();
+    });
+
+    it("renderSessionName shows the name", () => {
+        const out = renderSessionName(fakeTheme, ICONS, "before-rewrite");
+        expect(out).toContain("before-rewrite");
+    });
+
+    it("renderCache hides when both are 0", () => {
+        expect(renderCache(fakeTheme, ICONS, 0, 0)).toBeNull();
+    });
+
+    it("renderCache shows both counts with cR/cW prefixes", () => {
+        const out = renderCache(fakeTheme, ICONS, 8500, 2100);
+        expect(out).toContain("cR");
+        expect(out).toContain("8.5k");
+        expect(out).toContain("cW");
+        expect(out).toContain("2.1k");
+    });
+
     it("renderExtensionStatus uses muted colour", () => {
         expect(renderExtensionStatus(fakeTheme, "🪨 caveman:full")).toBe("<muted>🪨 caveman:full</muted>");
     });

package/extensions/astro-footer/segments.ts

@@ -1,6 +1,14 @@
 import type { ThemeColor } from "@mariozechner/pi-coding-agent";
 import type { IconSet } from "./icons.ts";
-import { formatCost, formatPathBasename, formatPercent, formatTokens } from "./format.ts";
+import {
+    formatCost,
+    formatDuration,
+    formatPath,
+    formatPercent,
+    formatTokens,
+    type PathMode,
+} from "./format.ts";
+import type { GitCounts } from "./git-status.ts";
 import { formatModelDisplay } from "./model-name.ts";
 
 export interface ThemeFn {
@@ -42,41 +50,92 @@ export function renderThinking(theme: ThemeFn, icons: IconSet, level: string | u
     return `${theme.fg(color, icons.thinking)} ${theme.fg(color, `think:${label}`)}`.trim();
 }
 
-export function renderPath(theme: ThemeFn, icons: IconSet, cwd: string): string {
-    const name = formatPathBasename(cwd);
+export function renderPath(theme: ThemeFn, icons: IconSet, cwd: string, mode: PathMode): string {
+    const name = formatPath(cwd, mode);
     return `${theme.fg("dim", icons.path)} ${theme.fg("accent", name)}`.trim();
 }
 
-export function renderGit(theme: ThemeFn, icons: IconSet, branch: string | null): string | null {
+export function renderGit(
+    theme: ThemeFn,
+    icons: IconSet,
+    branch: string | null,
+    counts: GitCounts,
+): string | null {
     if (!branch) return null;
-    return `${theme.fg("success", icons.git)} ${theme.fg("success", branch)}`.trim();
+    const dirty = counts.staged > 0 || counts.unstaged > 0 || counts.untracked > 0;
+    const role: ThemeColor = dirty ? "warning" : "success";
+    const parts: string[] = [];
+    parts.push(theme.fg(role, icons.git));
+    parts.push(theme.fg(role, branch));
+    if (counts.staged > 0) parts.push(theme.fg("success", `+${counts.staged}`));
+    if (counts.unstaged > 0) parts.push(theme.fg("warning", `*${counts.unstaged}`));
+    if (counts.untracked > 0) parts.push(theme.fg("muted", `?${counts.untracked}`));
+    return parts.join(" ");
+}
+
+export function renderTokens(
+    theme: ThemeFn,
+    icons: IconSet,
+    inputTokens: number,
+    outputTokens: number,
+): string | null {
+    if (inputTokens === 0 && outputTokens === 0) return null;
+    return `${theme.fg("muted", icons.tokensIn)}${theme.fg("text", formatTokens(inputTokens))} ${theme.fg("muted", icons.tokensOut)}${theme.fg("text", formatTokens(outputTokens))}`;
 }
 
-export function renderTokens(theme: ThemeFn, icons: IconSet, totalTokens: number): string | null {
-    if (totalTokens === 0) return null;
-    return `${theme.fg("muted", icons.tokens)} ${theme.fg("text", formatTokens(totalTokens))}`.trim();
+export interface CostInput {
+    costUsd: number;
+    isSubscription: boolean;
 }
 
-export function renderCost(theme: ThemeFn, icons: IconSet, costUsd: number): string | null {
-    if (costUsd === 0) return null;
-    return `${theme.fg("muted", icons.cost)} ${theme.fg("text", formatCost(costUsd))}`.trim();
+export function renderCost(theme: ThemeFn, icons: IconSet, input: CostInput): string | null {
+    if (input.isSubscription) {
+        return `${theme.fg("muted", icons.cost)} ${theme.fg("success", "(sub)")}`.trim();
+    }
+    if (input.costUsd === 0) return null;
+    return `${theme.fg("muted", icons.cost)} ${theme.fg("text", formatCost(input.costUsd))}`.trim();
 }
 
 export interface ContextSegmentInput {
     percent: number | null;
     contextWindow: number | null;
+    autoCompact: boolean;
 }
 
-export function renderContext(
-    theme: ThemeFn,
-    icons: IconSet,
-    input: ContextSegmentInput | null,
-): string | null {
+export function renderContext(theme: ThemeFn, icons: IconSet, input: ContextSegmentInput | null): string | null {
     if (!input || input.percent === null) return null;
     const role: ThemeColor = input.percent >= 90 ? "error" : input.percent >= 70 ? "warning" : "dim";
     const total = input.contextWindow && input.contextWindow > 0 ? `/${formatTokens(input.contextWindow)}` : "";
     const value = `${formatPercent(input.percent)}${total}`;
-    return `${theme.fg(role, icons.context)} ${theme.fg(role, value)}`.trim();
+    const ac = input.autoCompact ? ` ${theme.fg("muted", icons.autoCompact)}` : "";
+    return `${theme.fg(role, icons.context)} ${theme.fg(role, value)}${ac}`;
+}
+
+export function renderSubagents(theme: ThemeFn, icons: IconSet, count: number): string | null {
+    if (count <= 0) return null;
+    return `${theme.fg("muted", icons.subagents)} ${theme.fg("accent", `${count}`)}`.trim();
+}
+
+const SESSION_TIME_MIN_MS = 60_000;
+
+export function renderSessionTime(theme: ThemeFn, icons: IconSet, ms: number): string | null {
+    if (ms < SESSION_TIME_MIN_MS) return null;
+    return `${theme.fg("muted", icons.sessionTime)} ${theme.fg("text", formatDuration(ms))}`.trim();
+}
+
+export function renderSessionName(theme: ThemeFn, icons: IconSet, name: string | undefined): string | null {
+    if (!name) return null;
+    return `${theme.fg("muted", icons.sessionName)} ${theme.fg("text", name)}`.trim();
+}
+
+export function renderCache(
+    theme: ThemeFn,
+    icons: IconSet,
+    cacheRead: number,
+    cacheWrite: number,
+): string | null {
+    if (cacheRead === 0 && cacheWrite === 0) return null;
+    return `${theme.fg("muted", icons.cacheRead)}${theme.fg("text", formatTokens(cacheRead))} ${theme.fg("muted", icons.cacheWrite)}${theme.fg("text", formatTokens(cacheWrite))}`;
 }
 
 export function renderExtensionStatus(theme: ThemeFn, value: string): string {

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

@@ -0,0 +1,85 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+    DEFAULT_AUTO_COMPACT,
+    globalSettingsPath,
+    isAutoCompactEnabled,
+    projectSettingsPath,
+} from "./settings.ts";
+
+describe("settings paths", () => {
+    it("globalSettingsPath uses PI_CODING_AGENT_DIR when set", () => {
+        const out = globalSettingsPath({ PI_CODING_AGENT_DIR: "/custom/dir" });
+        expect(out).toBe(path.join("/custom/dir", "settings.json"));
+    });
+
+    it("globalSettingsPath defaults to ~/.pi/agent/settings.json", () => {
+        const out = globalSettingsPath({});
+        expect(out).toBe(path.join(os.homedir(), ".pi", "agent", "settings.json"));
+    });
+
+    it("projectSettingsPath joins .pi/settings.json under cwd", () => {
+        expect(projectSettingsPath("/tmp/proj")).toBe(path.join("/tmp/proj", ".pi", "settings.json"));
+    });
+});
+
+describe("isAutoCompactEnabled", () => {
+    let tmpDir: string;
+    let projectDir: string;
+    let globalDir: string;
+
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "astro-footer-settings-"));
+        projectDir = path.join(tmpDir, "proj");
+        globalDir = path.join(tmpDir, "global");
+        fs.mkdirSync(path.join(projectDir, ".pi"), { recursive: true });
+        fs.mkdirSync(globalDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    function env(): NodeJS.ProcessEnv {
+        return { PI_CODING_AGENT_DIR: globalDir };
+    }
+
+    it("returns the documented default when no settings exist", () => {
+        expect(isAutoCompactEnabled(projectDir, env())).toBe(DEFAULT_AUTO_COMPACT);
+    });
+
+    it("project setting wins over global", () => {
+        fs.writeFileSync(
+            path.join(projectDir, ".pi", "settings.json"),
+            JSON.stringify({ compaction: { enabled: false } }),
+        );
+        fs.writeFileSync(
+            path.join(globalDir, "settings.json"),
+            JSON.stringify({ compaction: { enabled: true } }),
+        );
+        expect(isAutoCompactEnabled(projectDir, env())).toBe(false);
+    });
+
+    it("falls back to global when project absent", () => {
+        fs.writeFileSync(
+            path.join(globalDir, "settings.json"),
+            JSON.stringify({ compaction: { enabled: false } }),
+        );
+        expect(isAutoCompactEnabled(projectDir, env())).toBe(false);
+    });
+
+    it("ignores non-boolean values and uses default", () => {
+        fs.writeFileSync(
+            path.join(globalDir, "settings.json"),
+            JSON.stringify({ compaction: { enabled: "yes" } }),
+        );
+        expect(isAutoCompactEnabled(projectDir, env())).toBe(DEFAULT_AUTO_COMPACT);
+    });
+
+    it("returns the default when settings.json is malformed", () => {
+        fs.writeFileSync(path.join(globalDir, "settings.json"), "{not-json");
+        expect(isAutoCompactEnabled(projectDir, env())).toBe(DEFAULT_AUTO_COMPACT);
+    });
+});

package/extensions/astro-footer/settings.ts

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export const DEFAULT_AUTO_COMPACT = true;
+
+interface CompactionShape {
+    compaction?: { enabled?: unknown };
+}
+
+function readJsonOrNull(filePath: string): CompactionShape | null {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw) as CompactionShape;
+}
+
+export function globalSettingsPath(env: NodeJS.ProcessEnv = process.env): string {
+    const override = env.PI_CODING_AGENT_DIR;
+    const dir = override && override.length > 0 ? override : path.join(os.homedir(), ".pi", "agent");
+    return path.join(dir, "settings.json");
+}
+
+export function projectSettingsPath(cwd: string): string {
+    return path.join(cwd, ".pi", "settings.json");
+}
+
+export function isAutoCompactEnabled(cwd: string, env: NodeJS.ProcessEnv = process.env): boolean {
+    try {
+        const project = readJsonOrNull(projectSettingsPath(cwd));
+        const projectValue = project?.compaction?.enabled;
+        if (typeof projectValue === "boolean") return projectValue;
+    } catch {
+        /* fall through */
+    }
+    try {
+        const global = readJsonOrNull(globalSettingsPath(env));
+        const globalValue = global?.compaction?.enabled;
+        if (typeof globalValue === "boolean") return globalValue;
+    } catch {
+        /* fall through */
+    }
+    return DEFAULT_AUTO_COMPACT;
+}

package/package.json

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