@selesai/code 0.6.3 → 0.8.0

package/dist/extensions/pi-powerline-footer/tests/queue-store.test.ts

@@ -0,0 +1,195 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { PowerlineQueueStore, currentQueueContext, formatIdeaIssuePrompt, formatQueueDeliveryText, parseCompactQueuedPrompt, parseSigilIdeaCapture, parseTargetPrefix, targetForIdea } from "../queue/store.ts";
+
+function withStore(fn: (store: PowerlineQueueStore, dir: string) => void): void {
+  const dir = mkdtempSync(join(tmpdir(), "powerline-queue-"));
+  try {
+    fn(new PowerlineQueueStore(join(dir, "inbox.jsonl"), join(dir, "projects.json")), dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+test("queue store adds active project ideas and summarizes them", () => withStore((store) => {
+  const cwd = "/tmp/project-a";
+  store.add({
+    text: "remember deploy note",
+    source: { cwd, sessionId: "s1" },
+    target: { kind: "project", cwd },
+    intent: "idea",
+    now: 100,
+  });
+  store.add({
+    text: "run after compact",
+    source: { cwd, sessionId: "s1" },
+    target: { kind: "current-session" },
+    intent: "post-compact",
+    now: 101,
+  });
+
+  assert.equal(store.list().length, 2);
+  assert.deepEqual(store.summarize(currentQueueContext(cwd, "s1"), true), {
+    queueCount: 1,
+    ideaCount: 1,
+    blockedCount: 0,
+    compacting: true,
+    leadingText: "run after compact",
+    leadingIntent: "post-compact",
+    leadingStatus: "queued",
+  });
+}));
+
+test("queue store filters inactive project items", () => withStore((store) => {
+  store.add({
+    text: "other project",
+    source: { cwd: "/tmp/project-a" },
+    target: { kind: "project", cwd: "/tmp/project-a" },
+    intent: "idea",
+  });
+
+  assert.equal(store.activeItems(currentQueueContext("/tmp/project-b")).length, 0);
+  assert.equal(store.activeItems(currentQueueContext("/tmp/project-a")).length, 1);
+}));
+
+test("queue store exposes the leading item intent for idea-only summaries", () => withStore((store) => {
+  store.add({
+    text: "saved follow-up idea",
+    source: { cwd: "/tmp/project" },
+    target: { kind: "project", cwd: "/tmp/project" },
+    intent: "idea",
+    now: 100,
+  });
+
+  assert.deepEqual(store.summarize(currentQueueContext("/tmp/project"), false), {
+    queueCount: 0,
+    ideaCount: 1,
+    blockedCount: 0,
+    compacting: false,
+    leadingText: "saved follow-up idea",
+    leadingIntent: "idea",
+    leadingStatus: "queued",
+  });
+}));
+
+test("current-session targets stay scoped to the source session when known", () => withStore((store) => {
+  store.add({
+    text: "session only",
+    source: { cwd: "/tmp/project", sessionId: "s1" },
+    target: { kind: "current-session" },
+    intent: "post-compact",
+  });
+
+  assert.equal(store.activeItems(currentQueueContext("/tmp/project", "s1")).length, 1);
+  assert.equal(store.activeItems(currentQueueContext("/tmp/project", "s2")).length, 0);
+}));
+
+test("queue store aliases resolve idea targets", () => withStore((store) => {
+  store.setAlias("pika", "/tmp/pika");
+
+  assert.deepEqual(targetForIdea("pika", store, "/tmp/current"), {
+    kind: "project",
+    cwd: resolve("/tmp/pika"),
+    alias: "pika",
+  });
+  assert.deepEqual(targetForIdea("global", store, "/tmp/current"), { kind: "global" });
+  assert.deepEqual(targetForIdea("current", store, "/tmp/current"), { kind: "current-session" });
+  assert.throws(() => targetForIdea("missing", store, "/tmp/current"), /Unknown project alias/);
+}));
+
+test("parseTargetPrefix separates optional @target", () => {
+  assert.deepEqual(parseTargetPrefix("@pika check logs"), { target: "pika", text: "check logs" });
+  assert.deepEqual(parseTargetPrefix("plain idea"), { target: null, text: "plain idea" });
+});
+
+test("parseSigilIdeaCapture turns leading sigil text into target-aware ideas", () => {
+  assert.deepEqual(parseSigilIdeaCapture("# check logs", "#"), { target: null, text: "check logs" });
+  assert.deepEqual(parseSigilIdeaCapture("# @global check logs", "#"), { target: "global", text: "check logs" });
+  assert.deepEqual(parseSigilIdeaCapture("# @pika check logs\nthen inspect events", "#"), {
+    target: "pika",
+    text: "check logs\nthen inspect events",
+  });
+  assert.deepEqual(parseSigilIdeaCapture("note # check logs", "#"), null);
+  assert.deepEqual(parseSigilIdeaCapture("## markdown heading", "#"), null);
+  assert.deepEqual(parseSigilIdeaCapture("#   ", "#"), null);
+  assert.deepEqual(parseSigilIdeaCapture("# check logs", false), null);
+  assert.deepEqual(parseSigilIdeaCapture("// check logs", "//"), { target: null, text: "check logs" });
+});
+
+test("formatQueueDeliveryText adds provenance only for ideas", () => {
+  const idea = {
+    id: "a1b2c3d4",
+    text: "check logs",
+    createdAt: 1000,
+    updatedAt: 1000,
+    source: { cwd: "/tmp/project" },
+    target: { kind: "current-session" as const },
+    intent: "idea" as const,
+    status: "queued" as const,
+  };
+  const prompt = { ...idea, intent: "follow-up" as const };
+
+  assert.equal(
+    formatQueueDeliveryText(idea),
+    "[powerline idea a1b2c3d4, captured 1970-01-01T00:00:01.000Z from /tmp/project]\ncheck logs",
+  );
+  assert.equal(formatQueueDeliveryText(prompt), "check logs");
+});
+
+test("formatIdeaIssuePrompt requires dedupe and clear owned repo before filing", () => {
+  const prompt = formatIdeaIssuePrompt({
+    id: "a1b2c3d4",
+    text: "add typed issue handoff",
+    createdAt: 1000,
+    updatedAt: 1000,
+    source: { cwd: "/tmp/project" },
+    target: { kind: "project", cwd: "/tmp/project", alias: "powerline" },
+    intent: "idea",
+    status: "queued",
+  });
+
+  assert.match(prompt, /spawn one low-budget issue-filing lane/);
+  assert.match(prompt, /target repository is unclear or is not owned\/controlled by the user, ask before filing/);
+  assert.match(prompt, /dedupe against existing open issues first/);
+  assert.match(prompt, /If a matching open issue already exists, report it and do not create another issue/);
+  assert.match(prompt, /create one self-contained GitHub issue/);
+  assert.match(prompt, /project @powerline \/tmp\/project/);
+});
+
+test("parseCompactQueuedPrompt treats /compact suffix as queued prompt text", () => {
+  assert.equal(parseCompactQueuedPrompt("/compact great lets proceed"), "great lets proceed");
+  assert.equal(parseCompactQueuedPrompt("  /compact   great lets proceed  "), "great lets proceed");
+  assert.equal(parseCompactQueuedPrompt("/compact\tgreat lets proceed"), "great lets proceed");
+  assert.equal(parseCompactQueuedPrompt("/compact"), null);
+  assert.equal(parseCompactQueuedPrompt("/compact   "), null);
+  assert.equal(parseCompactQueuedPrompt("/compactness great lets proceed"), null);
+});
+
+test("queue store clears items from active summary", () => withStore((store) => {
+  const item = store.add({
+    text: "queued prompt",
+    source: { cwd: "/tmp/project" },
+    target: { kind: "current-session" },
+    intent: "post-compact",
+  });
+
+  assert.equal(store.summarize(currentQueueContext("/tmp/project"), false).queueCount, 1);
+  store.clear(item.id);
+  assert.equal(store.summarize(currentQueueContext("/tmp/project"), false).queueCount, 0);
+}));
+
+test("queue store times out instead of stealing an existing lock", () => withStore((store, dir) => {
+  const lockPath = join(dir, "inbox.jsonl.lock");
+  mkdirSync(lockPath);
+
+  assert.throws(() => store.add({
+    text: "blocked write",
+    source: { cwd: "/tmp/project" },
+    target: { kind: "project", cwd: "/tmp/project" },
+    intent: "idea",
+  }), /Timed out waiting for Powerline queue store lock/);
+  assert.equal(existsSync(lockPath), true);
+}));

package/dist/extensions/pi-powerline-footer/tests/quit-cursor.test.ts

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { shouldShowStartupWelcome, isStaleExtensionContextError } from "../lifecycle.ts";
+
+test("startup welcome only shows on startup when enabled", () => {
+  assert.equal(shouldShowStartupWelcome("startup", true), true);
+  assert.equal(shouldShowStartupWelcome("reload", true), false);
+  assert.equal(shouldShowStartupWelcome("startup", false), false);
+});
+
+test("stale extension context errors are recognized", () => {
+  assert.equal(isStaleExtensionContextError(new Error("This extension instance is stale")), true);
+  assert.equal(isStaleExtensionContextError(new Error("other")), false);
+});

package/dist/extensions/pi-powerline-footer/tests/remaining-regressions.test.ts

@@ -0,0 +1,167 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { NERD_ICONS } from "../icons.ts";
+import { isStaleExtensionContextError, shouldShowStartupWelcome } from "../lifecycle.ts";
+import { __resetCurrencyRatesForTest, __setCurrencyRatesForTest } from "../currency-rates.ts";
+import { renderSegment } from "../segments.ts";
+import type { SegmentContext } from "../types.ts";
+
+const source = readFileSync(new URL("../index.ts", import.meta.url), "utf-8");
+const originalNerdFonts = process.env.POWERLINE_NERD_FONTS;
+process.env.POWERLINE_NERD_FONTS = "0";
+
+test.after(() => {
+  if (originalNerdFonts === undefined) {
+    delete process.env.POWERLINE_NERD_FONTS;
+  } else {
+    process.env.POWERLINE_NERD_FONTS = originalNerdFonts;
+  }
+});
+
+function plainThemeText(_color: string, text: string): string {
+  return text;
+}
+
+function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function createSegmentContext(overrides: Partial<SegmentContext> = {}): SegmentContext {
+  return {
+    model: { id: "claude-sonnet-4", name: "Claude Sonnet 4" },
+    thinkingLevel: "off",
+    sessionId: undefined,
+    cwd: "/tmp/project",
+    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, subagentCost: 0 },
+    contextTokens: 0,
+    contextPercent: 0,
+    contextWindow: 0,
+    contextApproximate: false,
+    autoCompactEnabled: true,
+    customCompactionEnabled: false,
+    usingSubscription: false,
+    sessionStartTime: Date.now(),
+    shellModeActive: false,
+    shellRunning: false,
+    shellName: null,
+    shellCwd: null,
+    git: { branch: null, staged: 0, unstaged: 0, untracked: 0 },
+    extensionStatuses: new Map(),
+    hiddenExtensionStatusKeys: new Set(),
+    customItemsById: new Map(),
+    options: {},
+    theme: { fg: plainThemeText },
+    colors: {},
+    ...overrides,
+  };
+}
+
+test("model segment can show provider-qualified ids", () => {
+  const normal = renderSegment("model", createSegmentContext());
+  const qualified = renderSegment("model", createSegmentContext({
+    model: { id: "claude-sonnet-4", name: "Claude Sonnet 4", provider: "anthropic" },
+    options: { model: { display: "qualified" } },
+  }));
+  const alreadyQualified = renderSegment("model", createSegmentContext({
+    model: { id: "openai/gpt-4.1", name: "GPT 4.1", provider: "openai" },
+    options: { model: { display: "qualified" } },
+  }));
+
+  assert.equal(stripAnsi(normal.content), "Sonnet 4");
+  assert.equal(stripAnsi(qualified.content), "anthropic/claude-sonnet-4");
+  assert.equal(stripAnsi(alreadyQualified.content), "openai/gpt-4.1");
+});
+
+test("cost segment supports subscription display modes and converted currencies", () => {
+  __setCurrencyRatesForTest({ CNY: 7.2 });
+
+  const subscription = renderSegment("cost", createSegmentContext({
+    usingSubscription: true,
+    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0.42, subagentCost: 0 },
+  }));
+  const reportedCost = renderSegment("cost", createSegmentContext({
+    usingSubscription: true,
+    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0.42, subagentCost: 0 },
+    options: { cost: { subscriptionDisplay: "reported-cost" } },
+  }));
+  const both = renderSegment("cost", createSegmentContext({
+    usingSubscription: true,
+    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0.42, subagentCost: 0 },
+    options: { cost: { subscriptionDisplay: "both" } },
+  }));
+  const zeroReported = renderSegment("cost", createSegmentContext({
+    usingSubscription: true,
+    options: { cost: { subscriptionDisplay: "reported-cost" } },
+  }));
+  const zeroBoth = renderSegment("cost", createSegmentContext({
+    usingSubscription: true,
+    options: { cost: { subscriptionDisplay: "both" } },
+  }));
+  const withSubagentCost = renderSegment("cost", createSegmentContext({
+    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0.42, subagentCost: 0.58 },
+  }));
+  const convertedCurrency = renderSegment("cost", createSegmentContext({
+    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 1, subagentCost: 0.25 },
+    options: { cost: { currency: "CNY" } },
+  }));
+
+  __resetCurrencyRatesForTest();
+
+  assert.deepEqual(subscription, { content: "(sub)", visible: true });
+  assert.deepEqual(reportedCost, { content: "$0.42", visible: true });
+  assert.deepEqual(both, { content: "$0.42 (sub)", visible: true });
+  assert.deepEqual(zeroReported, { content: "(sub)", visible: true });
+  assert.deepEqual(zeroBoth, { content: "(sub)", visible: true });
+  assert.deepEqual(withSubagentCost, { content: "$1.00", visible: true });
+  assert.deepEqual(convertedCurrency, { content: "¥9.00", visible: true });
+});
+
+test("context segment shows used tokens, maximum, and percentage", () => {
+  const context = renderSegment("context_pct", createSegmentContext({
+    contextTokens: 4_500,
+    contextPercent: 1.7,
+    contextWindow: 272_000,
+  }));
+
+  assert.equal(stripAnsi(context.content), "4.5k/272k (1.7%)");
+  assert.equal(context.visible, true);
+});
+
+test("Nerd Font context icon uses stable database glyph", () => {
+  assert.equal(NERD_ICONS.context, "\uF1C0");
+});
+
+test("startup welcome predicate respects powerline.welcome false", () => {
+  assert.equal(shouldShowStartupWelcome("startup", true), true);
+  assert.equal(shouldShowStartupWelcome("startup", false), false);
+  assert.equal(shouldShowStartupWelcome("resume", true), false);
+  // Guide display modes take precedence; the welcome overlay only shows when the
+  // guide is off and shouldShowStartupWelcome passes.
+  assert.match(source, /setupCustomEditor\(ctx\);/);
+  assert.match(source, /if \(guideDisplayMode === "full"\)/);
+  assert.match(source, /else if \(shouldShowStartupWelcome\(event\.reason, config\.welcome\)\)/);
+});
+
+test("stale ctx guard handles old and new Pi messages on agent_end", () => {
+  assert.equal(isStaleExtensionContextError(new Error("This extension instance is stale after session replacement or reload.")), true);
+  assert.equal(isStaleExtensionContextError(new Error("This extension ctx is stale after session replacement or reload.")), true);
+  assert.equal(isStaleExtensionContextError(new Error("ctx.hasUI failed for another reason")), false);
+  assert.match(source, /let hasUI = false;\r?\n\s+try \{\r?\n\s+hasUI = Boolean\(ctx\.hasUI\);/);
+  assert.match(source, /if \(!isStaleExtensionContextError\(error\)\) throw error;\r?\n\s+currentCtx = null;\r?\n\s+return;/);
+});
+
+test("post-compaction queue delivery does not read ctx.cwd from the delayed callback", () => {
+  assert.match(source, /const queueContext = getQueueContext\(ctx\);\r?\n\s+const scheduledGeneration = sessionGeneration;\r?\n\s+queueDeliveryTimer = setTimeout/);
+  assert.match(source, /if \(scheduledGeneration !== sessionGeneration\) return;\r?\n\s+try \{\r?\n\s+const item = queueStore\.queuedDeliveryItems\(queueContext, "post-compact"\)\[0\];/);
+  assert.match(source, /catch \(error\) \{\r?\n\s+if \(!isStaleExtensionContextError\(error\)\) throw error;\r?\n\s+currentCtx = null;/);
+  assert.match(source, /if \(isStaleExtensionContextError\(error\)\) \{\r?\n\s+if \(!sent\) queueStore\.update\(item\.id, \{ status: "queued", error: undefined \}\);/);
+});
+
+test("unknown context estimates are event-scoped and cleared before compaction", () => {
+  assert.match(source, /approximateContextUsage = event\.reason === "reload" \? estimateUnknownContextUsage\(ctx\) : null;/);
+  assert.match(source, /unknownCoreFallback: approximateContextUsage,/);
+  assert.match(source, /contextApproximate = coreContextUsage\?\.contextTokens === null && approximateContextUsage !== null;/);
+  assert.match(source, /pi\.on\("session_before_compact", async \(_event, ctx\) => \{\r?\n\s+powerlineCompacting = true;\r?\n\s+currentCtx = ctx;\r?\n\s+isStreaming = false;\r?\n\s+liveAssistantUsage = null;\r?\n\s+approximateContextUsage = null;\r?\n\s+coreContextUsageCache\.reset\(\);/);
+  assert.match(source, /pi\.on\("session_compact", async \(event, ctx\) => \{\r?\n\s+powerlineCompacting = false;\r?\n\s+currentCtx = ctx;\r?\n\s+isStreaming = false;\r?\n\s+liveAssistantUsage = null;\r?\n\s+approximateContextUsage = estimateUnknownContextUsage\(ctx\);\r?\n\s+coreContextUsageCache\.reset\(\);/);
+});

package/dist/extensions/pi-powerline-footer/tests/stash-shortcut.test.ts

@@ -1,32 +1,37 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
+import { matchesStashShortcutInput } from "../shortcuts.ts";
 
 const source = readFileSync(new URL("../index.ts", import.meta.url), "utf-8");
 
-test("stash shortcut supports macOS Option+S character input", () => {
-  assert.match(source, /isKeyRelease, matchesKey, type AutocompleteProvider/);
-  assert.match(source, /pi\.registerShortcut\("alt\+s"/);
-  assert.match(source, /function isStashShortcutInput\(data: string\): boolean/);
-  assert.match(source, /if \(isKeyRelease\(data\)\) return false;/);
-  assert.match(source, /data === "ß"/);
-  assert.match(source, /data === "\\x1bs"/);
-  assert.match(source, /data === "\\x1bS"/);
-  assert.match(source, /27;3;115/);
-  assert.match(source, /matchesKey\(data, "alt\+s"\)/);
+test("stash shortcut matches Alt+S encodings without consuming literal sharp-S by default", () => {
+  assert.equal(matchesStashShortcutInput("ß"), false);
+  assert.equal(matchesStashShortcutInput("ß", { includePrintableSharpS: true }), true);
+
+  for (const data of [
+    "\x1bs",
+    "\x1bS",
+    "\x1b[115;3u",
+    "\x1b[83;3u",
+    "\x1b[27;3;115~",
+    "\x1b[27;3;83~",
+  ]) {
+    assert.equal(matchesStashShortcutInput(data), true, data);
+  }
+
+  assert.equal(matchesStashShortcutInput("s"), false);
+  assert.equal(matchesStashShortcutInput("\x1b[115;5u"), false);
+});
+
+test("stash shortcut stays in terminal/editor fallback routing", () => {
+  assert.doesNotMatch(source, /pi\.registerShortcut\("alt\+s"/);
+  assert.match(source, /matchesStashShortcutInput\(data, \{ includePrintableSharpS: config\.stashSharpSShortcut \}\)/);
   assert.match(source, /ctx\.ui\.onTerminalInput\(\(data: string\) =>/);
   assert.match(source, /if \(isStashShortcutInput\(data\)\)/);
-  assert.match(source, /return \{ consume: true \};/);
   assert.match(source, /function stashOrRestoreEditorText\(ctx: any\): void/);
-  assert.match(source, /if \(isStashShortcutInput\(data\)\)/);
-  assert.match(source, /stashOrRestoreEditorText\(ctx\);/);
   assert.match(source, /function isPromptHistoryShortcutInput\(data: string\): boolean/);
-  assert.match(source, /if \(isKeyRelease\(data\)\) return null;/);
   assert.match(source, /matchesConfiguredShortcut\(data, resolvedShortcuts\.stashHistory\)/);
   assert.doesNotMatch(source, /data === "\\x1b\\b"/);
   assert.doesNotMatch(source, /data === "\\x1b\\x7f"/);
-  assert.match(source, /104\(\?:/);
-  assert.match(source, /27;7;104/);
-  assert.match(source, /return \{ kind: "stashHistory" \};/);
-  assert.match(source, /void openStashHistory\(ctx\);/);
 });

package/dist/extensions/pi-powerline-footer/tests/thinking-segment.test.ts

@@ -1,6 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { renderSegment } from "../segments.ts";
+import { rainbow } from "../theme.ts";
 import type { ColorScheme, SegmentContext, ThemeLike } from "../types.ts";
 
 function hexAnsi(hex: `#${string}`): string {
@@ -16,9 +17,11 @@ function createSegmentContext(thinkingLevel: string, colors: ColorScheme): Segme
     model: undefined,
     thinkingLevel,
     sessionId: undefined,
-    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
+    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, subagentCost: 0 },
+    contextTokens: 0,
     contextPercent: 0,
     contextWindow: 0,
+    contextApproximate: false,
     autoCompactEnabled: true,
     customCompactionEnabled: false,
     usingSubscription: false,
@@ -59,3 +62,15 @@ test("thinking segment uses per-level colors for off through medium", () => {
   assert.equal(low.content, `${hexAnsi("#333333")}think:low\x1b[0m`);
   assert.equal(medium.content, `${hexAnsi("#444444")}think:med\x1b[0m`);
 });
+
+test("thinking segment uses rainbow styling for high through max", () => {
+  const colors: ColorScheme = { thinking: "#111111" };
+
+  for (const level of ["high", "xhigh", "max"]) {
+    const rendered = renderSegment("thinking", createSegmentContext(level, colors));
+    assert.deepEqual(rendered, {
+      content: rainbow(`think:${level}`),
+      visible: true,
+    });
+  }
+});