@selesai/code 0.9.14 → 0.10.0

package/dist/extensions/pi-powerline-footer/tests/cd-command.test.ts

@@ -1,144 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, mkdirSync, writeFileSync, mkdtempSync, readFileSync, realpathSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { SessionManager } from "@selesai/code";
-import { getCdArgumentCompletions, resolveCdTarget, runCdCommand } from "../cd-command.ts";
-
-const cdCommandSource = readFileSync(new URL("../cd-command.ts", import.meta.url), "utf-8");
-const indexSource = readFileSync(new URL("../index.ts", import.meta.url), "utf-8");
-
-test("resolveCdTarget supports current, relative, home, and invalid directories", () => {
-  const root = mkdtempSync(join(tmpdir(), "powerline-cd-root-"));
-  const home = mkdtempSync(join(tmpdir(), "powerline-cd-home-"));
-  const child = join(root, "child");
-  const homeProject = join(home, "project");
-  mkdirSync(child);
-  mkdirSync(homeProject);
-  writeFileSync(join(root, "file.txt"), "not a directory");
-
-  assert.equal(resolveCdTarget("", root, home), null);
-  assert.deepEqual(resolveCdTarget("child", root, home), { path: child });
-  assert.deepEqual(resolveCdTarget("~/project", root, home), { path: homeProject });
-  assert.deepEqual(resolveCdTarget("My\\ Folder", root, home), { error: `Directory does not exist: ${join(root, "My Folder")}` });
-  assert.match(resolveCdTarget("missing", root, home)?.error ?? "", /Directory does not exist:/);
-  assert.match(resolveCdTarget("file.txt", root, home)?.error ?? "", /Not a directory:/);
-});
-
-test("cd argument completions suggest directories and quick picks", () => {
-  const root = mkdtempSync(join(tmpdir(), "powerline-cd-complete-root-"));
-  const home = mkdtempSync(join(tmpdir(), "powerline-cd-complete-home-"));
-  mkdirSync(join(root, "child"));
-  mkdirSync(join(root, "My Folder"));
-  writeFileSync(join(root, "file.txt"), "not a directory");
-  mkdirSync(join(home, "project"));
-
-  const rootCompletions = getCdArgumentCompletions("", root, home);
-  assert.ok(rootCompletions.some((item) => item.value === "../" && item.label === "../"));
-  assert.ok(rootCompletions.some((item) => item.value === "~/" && item.label === "~/"));
-  assert.ok(rootCompletions.some((item) => item.value === "child/" && item.label === "child/"));
-  assert.ok(rootCompletions.some((item) => item.value === "My\\ Folder/" && item.label === "My Folder/"));
-  assert.ok(!rootCompletions.some((item) => item.label === "file.txt"));
-
-  if (process.platform !== "win32") {
-    assert.deepEqual(
-      getCdArgumentCompletions("~/p", root, home).map((item) => item.value),
-      ["~/project/"],
-    );
-  }
-});
-
-test("cd command cleans up the forked session when switching is cancelled", async () => {
-  const originalCwd = process.cwd();
-  const root = mkdtempSync(join(tmpdir(), "powerline-cd-command-root-"));
-  const target = join(root, "target");
-  const sessionDir = join(root, "sessions");
-  mkdirSync(target);
-
-  const session = SessionManager.create(root, sessionDir);
-  session.appendMessage({ role: "user", content: "hello", timestamp: Date.now() });
-  session.appendMessage({ role: "assistant", content: "hi", timestamp: Date.now(), usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } } });
-
-  let switchedPath: string | undefined;
-  const notifications: Array<{ message: string; type?: string }> = [];
-  const ctx = {
-    cwd: root,
-    sessionManager: {
-      getSessionFile: () => session.getSessionFile(),
-    },
-    ui: {
-      notify(message: string, type?: string) {
-        notifications.push({ message, type });
-      },
-    },
-    waitForIdle: async () => {},
-    switchSession: async (path: string) => {
-      switchedPath = path;
-      return { cancelled: true };
-    },
-  } as any;
-
-  try {
-    await runCdCommand("target", ctx);
-  } finally {
-    process.chdir(originalCwd);
-  }
-
-  assert.equal(process.cwd(), originalCwd);
-  assert.ok(switchedPath, "switchSession should receive the forked session path");
-  assert.equal(existsSync(switchedPath!), false);
-  assert.deepEqual(notifications.at(-1), { message: "Directory change cancelled", type: "warning" });
-});
-
-test("cd command preserves the target session after a post-apply switch error", async () => {
-  const originalCwd = process.cwd();
-  const root = mkdtempSync(join(tmpdir(), "powerline-cd-post-apply-root-"));
-  const target = join(root, "target");
-  const sessionDir = join(root, "sessions");
-  mkdirSync(target);
-
-  const session = SessionManager.create(root, sessionDir);
-  session.appendMessage({ role: "user", content: "hello", timestamp: Date.now() });
-  session.appendMessage({ role: "assistant", content: "hi", timestamp: Date.now(), usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } } });
-
-  let switchedPath: string | undefined;
-  const ctx = {
-    cwd: root,
-    sessionManager: {
-      getSessionFile: () => session.getSessionFile(),
-    },
-    ui: {
-      notify() {},
-    },
-    waitForIdle: async () => {},
-    switchSession: async (path: string, options: { withSession?: (ctx: any) => Promise<void> }) => {
-      switchedPath = path;
-      await options.withSession?.({
-        cwd: target,
-        ui: {
-          notify() {},
-          setTitle() {},
-        },
-      });
-      throw new Error("post-apply failure");
-    },
-  } as any;
-
-  try {
-    await runCdCommand("target", ctx);
-    assert.equal(realpathSync(process.cwd()), realpathSync(target));
-    assert.ok(switchedPath, "switchSession should receive the forked session path");
-    assert.equal(existsSync(switchedPath!), true);
-  } finally {
-    process.chdir(originalCwd);
-  }
-});
-
-test("cd command uses session replacement instead of private cwd mutation", () => {
-  assert.match(indexSource, /registerCdCommand\(pi, \(\) => currentCtx\?\.cwd \?\? process\.cwd\(\)\)/);
-  assert.match(cdCommandSource, /SessionManager\.forkFrom\(sessionFile, resolved\.path\)/);
-  assert.match(cdCommandSource, /ctx\.switchSession\(nextSessionFile!/);
-  assert.match(cdCommandSource, /process\.chdir\(nextCtx\.cwd\)/);
-  assert.doesNotMatch(cdCommandSource, /ctx\.cwd\s*=/);
-});

package/dist/extensions/pi-powerline-footer/tests/context-usage.test.ts

@@ -1,156 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { CoreContextUsageCache, estimateInitialContextTokens, estimateUnknownContextUsage, readCoreContextUsage, resolveDisplayContextUsage } from "../context-usage.ts";
-
-test("readCoreContextUsage returns Pi context estimates for branch summaries", () => {
-  const usage = readCoreContextUsage({
-    getContextUsage() {
-      return { tokens: 1250, contextWindow: 5000, percent: 25 };
-    },
-  });
-
-  assert.deepEqual(usage, {
-    contextTokens: 1250,
-    contextWindow: 5000,
-    contextPercent: 25,
-  });
-});
-
-test("readCoreContextUsage computes percent when Pi returns only token totals", () => {
-  const usage = readCoreContextUsage({
-    getContextUsage() {
-      return { tokens: 1000, contextWindow: 4000 };
-    },
-  });
-
-  assert.deepEqual(usage, {
-    contextTokens: 1000,
-    contextWindow: 4000,
-    contextPercent: 25,
-  });
-});
-
-test("readCoreContextUsage preserves Pi's post-compaction unknown state", () => {
-  const usage = readCoreContextUsage({
-    getContextUsage() {
-      return { tokens: null, contextWindow: 5000, percent: null };
-    },
-  });
-
-  assert.deepEqual(usage, {
-    contextTokens: null,
-    contextWindow: 5000,
-    contextPercent: null,
-  });
-});
-
-test("readCoreContextUsage ignores unknown or unusable estimates", () => {
-  assert.equal(readCoreContextUsage({}), null);
-  assert.equal(readCoreContextUsage({ getContextUsage: () => undefined }), null);
-  assert.equal(readCoreContextUsage({ getContextUsage: () => ({ tokens: undefined, contextWindow: 5000, percent: null }) }), null);
-  assert.equal(readCoreContextUsage({ getContextUsage: () => ({ tokens: 100, contextWindow: 0, percent: 0 }) }), null);
-});
-
-test("core context usage cache reuses a leaf and supports explicit invalidation", () => {
-  const cache = new CoreContextUsageCache();
-  let leafId = "leaf-1";
-  let tokens = 100;
-  let reads = 0;
-  const ctx = {
-    sessionManager: { getLeafId: () => leafId },
-    getContextUsage() {
-      reads += 1;
-      return { tokens, contextWindow: 1000, percent: tokens / 10 };
-    },
-  };
-
-  assert.equal(cache.get(ctx)?.contextTokens, 100);
-  tokens = 200;
-  assert.equal(cache.get(ctx)?.contextTokens, 100);
-  assert.equal(reads, 1);
-
-  cache.reset();
-  assert.equal(cache.get(ctx)?.contextTokens, 200);
-  leafId = "leaf-2";
-  tokens = 300;
-  assert.equal(cache.get(ctx)?.contextTokens, 300);
-  assert.equal(reads, 3);
-});
-
-test("resolveDisplayContextUsage preserves unknown core usage over assistant fallback usage", () => {
-  assert.deepEqual(resolveDisplayContextUsage({
-    coreContextUsage: { contextTokens: null, contextWindow: 5000, contextPercent: null },
-    unknownCoreFallback: null,
-    fallbackContextTokens: 4000,
-    fallbackContextWindow: 5000,
-  }), {
-    contextTokens: null,
-    contextWindow: 5000,
-    contextPercent: null,
-  });
-});
-
-test("resolveDisplayContextUsage uses the approximate estimate for unknown core usage", () => {
-  const reloadEstimate = { contextTokens: 1000, contextWindow: 5000, contextPercent: 20 };
-  assert.equal(resolveDisplayContextUsage({
-    coreContextUsage: { contextTokens: null, contextWindow: 5000, contextPercent: null },
-    unknownCoreFallback: reloadEstimate,
-    fallbackContextTokens: 4000,
-    fallbackContextWindow: 5000,
-  }), reloadEstimate);
-});
-
-test("resolveDisplayContextUsage computes assistant fallback usage when Pi has no current estimate", () => {
-  assert.deepEqual(resolveDisplayContextUsage({
-    coreContextUsage: null,
-    unknownCoreFallback: null,
-    fallbackContextTokens: 1000,
-    fallbackContextWindow: 4000,
-  }), {
-    contextTokens: 1000,
-    contextWindow: 4000,
-    contextPercent: 25,
-  });
-});
-
-test("estimateUnknownContextUsage estimates the active compacted context", () => {
-  const usage = estimateUnknownContextUsage({
-    getContextUsage: () => ({ tokens: null, contextWindow: 100, percent: null }),
-    getSystemPrompt: () => "12345678",
-    sessionManager: {
-      buildContextEntries: () => [
-        { type: "compaction", summary: "12345678", tokensBefore: 90, timestamp: "2026-08-08T00:00:00.000Z" },
-        { type: "message", message: { role: "user", content: "1234", timestamp: 0 } },
-      ],
-    },
-  });
-
-  assert.deepEqual(usage, {
-    contextTokens: 5,
-    contextWindow: 100,
-    contextPercent: 5,
-  });
-});
-
-test("estimateUnknownContextUsage skips sessions with known core usage", () => {
-  let entryReads = 0;
-  assert.equal(estimateUnknownContextUsage({
-    getContextUsage: () => ({ tokens: 25, contextWindow: 100, percent: 25 }),
-    getSystemPrompt: () => "12345678",
-    sessionManager: {
-      buildContextEntries() {
-        entryReads += 1;
-        return [];
-      },
-    },
-  }), null);
-  assert.equal(entryReads, 0);
-});
-
-test("estimateInitialContextTokens uses Pi's conservative character estimate", () => {
-  assert.equal(estimateInitialContextTokens({}), null);
-  assert.equal(estimateInitialContextTokens({ getSystemPrompt: () => "" }), null);
-  assert.equal(estimateInitialContextTokens({ getSystemPrompt: () => "   " }), null);
-  assert.equal(estimateInitialContextTokens({ getSystemPrompt: () => "1234" }), 1);
-  assert.equal(estimateInitialContextTokens({ getSystemPrompt: () => "12345" }), 2);
-});

package/dist/extensions/pi-powerline-footer/tests/custom-items.test.ts

@@ -1,344 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { collectHiddenExtensionStatusKeys, getNotificationExtensionStatuses, normalizeExtensionStatusValue, parsePowerlineConfig, mergeSegmentOptions, mergeSegmentsWithCustomItems, nextPowerlineSettingWithOptions, nextPowerlineSettingWithPreset, normalizeCompactExtensionStatus } from "../powerline-config.ts";
-import { getSeparator } from "../separators.ts";
-import { PRESETS } from "../presets.ts";
-
-test("fixed custom preset is removed in favor of powerline.layout", () => {
-  assert.equal("custom" in PRESETS, false);
-});
-
-test("parsePowerlineConfig supports object config with custom items", () => {
-  const config = parsePowerlineConfig(
-    {
-      preset: "compact",
-      customItems: [
-        { id: "ci", statusKey: "ci-status", position: "right", prefix: "CI" },
-        { id: "review", position: "secondary", hideWhenMissing: false },
-      ],
-    },
-    ["default", "compact"],
-  );
-
-  assert.equal(config.preset, "compact");
-  assert.equal(config.customItems.length, 2);
-  assert.equal(config.customItems[0].id, "ci");
-  assert.equal(config.customItems[0].statusKey, "ci-status");
-  assert.equal(config.customItems[1].statusKey, "review");
-  assert.equal(config.customItems[1].hideWhenMissing, false);
-  assert.deepEqual(config.disabledSegments, []);
-  assert.deepEqual(config.invalidDisabledSegments, []);
-  assert.equal(config.layout, null);
-  assert.deepEqual(config.invalidLayoutSegments, []);
-  assert.equal(config.separator, null);
-  assert.equal(config.placement, "above");
-  assert.equal(config.invalidPlacement, null);
-  assert.equal(config.welcome, true);
-  assert.equal(config.stashSharpSShortcut, false);
-});
-
-test("parsePowerlineConfig supports disabled segments", () => {
-  const config = parsePowerlineConfig(
-    {
-      preset: "default",
-      customItems: [{ id: "ci" }],
-      disabledSegments: [
-        "queue",
-        "cost",
-        " extension_statuses ",
-        "custom:ci",
-        "cost",
-        "unknown",
-        "custom:missing",
-        123,
-      ],
-    },
-    ["default", "compact"],
-  );
-
-  assert.deepEqual(config.disabledSegments, ["queue", "cost", "extension_statuses", "custom:ci"]);
-  assert.deepEqual(config.invalidDisabledSegments, ["unknown", "custom:missing", "123"]);
-});
-
-test("parsePowerlineConfig supports partial explicit layout rows", () => {
-  const config = parsePowerlineConfig(
-    {
-      preset: "default",
-      customItems: [{ id: "ci" }],
-      layout: {
-        left: ["model", "custom:ci", "model", "unknown", 123],
-        right: ["model", "cost"],
-        secondary: [],
-      },
-    },
-    ["default", "compact"],
-  );
-
-  assert.deepEqual(config.layout, {
-    left: ["model", "custom:ci"],
-    right: ["cost"],
-    secondary: [],
-  });
-  assert.deepEqual(config.invalidLayoutSegments, ["left:unknown", "left:123", "right:model"]);
-});
-
-test("parsePowerlineConfig preserves reporter layout groups", () => {
-  const config = parsePowerlineConfig(
-    {
-      preset: "default",
-      layout: {
-        left: ["model"],
-        right: ["path"],
-        secondary: ["thinking"],
-      },
-    },
-    ["default", "compact"],
-  );
-
-  assert.deepEqual(config.layout, {
-    left: ["model"],
-    right: ["path"],
-    secondary: ["thinking"],
-  });
-  assert.deepEqual(config.invalidLayoutSegments, []);
-  assert.deepEqual(
-    mergeSegmentsWithCustomItems(PRESETS.default, config.customItems, {
-      layout: config.layout,
-      disabledSegments: config.disabledSegments,
-    }),
-    {
-      leftSegments: ["model"],
-      rightSegments: ["path"],
-      secondarySegments: ["thinking"],
-    },
-  );
-});
-
-test("parsePowerlineConfig supports separator overrides", () => {
-  const config = parsePowerlineConfig(
-    { preset: "default", separator: " chevron " },
-    ["default", "compact"],
-  );
-  const invalid = parsePowerlineConfig(
-    { preset: "default", separator: "sparkle" },
-    ["default", "compact"],
-  );
-
-  assert.equal(config.separator, "chevron");
-  assert.equal(invalid.separator, null);
-});
-
-test("configured separators resolve independently of presets", () => {
-  const presetSeparator = getSeparator(PRESETS.default.separator).left;
-  const configuredSeparator = getSeparator("chevron").left;
-
-  assert.notEqual(configuredSeparator, presetSeparator);
-  assert.equal(configuredSeparator, "›");
-});
-
-test("parsePowerlineConfig validates primary powerline placement", () => {
-  const below = parsePowerlineConfig(
-    { preset: "compact", placement: "below" },
-    ["default", "compact"],
-  );
-  const invalid = parsePowerlineConfig(
-    { preset: "compact", placement: "sideways" },
-    ["default", "compact"],
-  );
-
-  assert.equal(below.placement, "below");
-  assert.equal(below.invalidPlacement, null);
-  assert.equal(invalid.placement, "above");
-  assert.equal(invalid.invalidPlacement, "sideways");
-});
-
-
-
-
-test("parsePowerlineConfig supports welcome and legacy sharp-S settings", () => {
-  const config = parsePowerlineConfig(
-    { preset: "compact", welcome: false, stashSharpSShortcut: true },
-    ["default", "compact"],
-  );
-  const shorthand = parsePowerlineConfig("compact", ["default", "compact"]);
-
-  assert.equal(config.welcome, false);
-  assert.equal(config.stashSharpSShortcut, true);
-  assert.equal(shorthand.welcome, true);
-  assert.equal(shorthand.stashSharpSShortcut, false);
-});
-test("parsePowerlineConfig extracts supported segment options", () => {
-  const config = parsePowerlineConfig(
-    {
-      preset: "default",
-      model: { showThinkingLevel: true, display: "qualified" },
-      path: { mode: "full", maxLength: 120 },
-      git: { showBranch: false, showStaged: false, showUnstaged: true, showUntracked: false, polling: "branch", hostIcon: true },
-      time: { format: "12h", showSeconds: true },
-      cost: { subscriptionDisplay: "both", currency: "cny" },
-    },
-    ["default", "compact"],
-  );
-  const invalidCurrency = parsePowerlineConfig(
-    { cost: { currency: "BTC" } },
-    ["default", "compact"],
-  );
-
-  assert.deepEqual(config.segmentOptions, {
-    model: { showThinkingLevel: true, display: "qualified" },
-    path: { mode: "full", maxLength: 120 },
-    git: { showBranch: false, showStaged: false, showUnstaged: true, showUntracked: false, polling: "branch", hostIcon: true },
-    time: { format: "12h", showSeconds: true },
-    cost: { subscriptionDisplay: "both", currency: "CNY" },
-  });
-  assert.deepEqual(invalidCurrency.segmentOptions, { cost: {} });
-});
-
-test("mergeSegmentOptions lets user config override preset segment defaults", () => {
-  assert.deepEqual(
-    mergeSegmentOptions(
-      { path: { mode: "basename", maxLength: 20 }, git: { showBranch: true, showUntracked: true } },
-      { path: { mode: "full" }, git: { showUntracked: false }, cost: { subscriptionDisplay: "reported-cost" } },
-    ),
-    {
-      model: {},
-      path: { mode: "full", maxLength: 20 },
-      git: { showBranch: true, showUntracked: false },
-      time: {},
-      cost: { subscriptionDisplay: "reported-cost" },
-      context: {},
-      cache_read: {},
-    },
-  );
-});
-
-test("mergeSegmentsWithCustomItems appends custom segment ids by position", () => {
-  const merged = mergeSegmentsWithCustomItems(
-    {
-      leftSegments: ["path"],
-      rightSegments: ["git"],
-      secondarySegments: ["extension_statuses"],
-      separator: "powerline",
-    },
-    [
-      { id: "ci", statusKey: "ci", position: "left", hideWhenMissing: true, excludeFromExtensionStatuses: true },
-      { id: "timer", statusKey: "timer", position: "right", hideWhenMissing: true, excludeFromExtensionStatuses: true },
-      { id: "review", statusKey: "review", position: "secondary", hideWhenMissing: true, excludeFromExtensionStatuses: true },
-    ],
-  );
-
-  assert.deepEqual(merged.leftSegments, ["path", "custom:ci"]);
-  assert.deepEqual(merged.rightSegments, ["git", "custom:timer"]);
-  assert.deepEqual(merged.secondarySegments, ["extension_statuses", "custom:review"]);
-});
-
-test("mergeSegmentsWithCustomItems filters disabled segment ids", () => {
-  const merged = mergeSegmentsWithCustomItems(
-    {
-      leftSegments: ["path", "model"],
-      rightSegments: ["git", "cost"],
-      secondarySegments: ["extension_statuses"],
-      separator: "powerline",
-    },
-    [
-      { id: "ci", statusKey: "ci", position: "left", hideWhenMissing: true, excludeFromExtensionStatuses: true },
-      { id: "timer", statusKey: "timer", position: "right", hideWhenMissing: true, excludeFromExtensionStatuses: true },
-      { id: "review", statusKey: "review", position: "secondary", hideWhenMissing: true, excludeFromExtensionStatuses: true },
-    ],
-    { disabledSegments: ["model", "cost", "custom:ci", "custom:review"] },
-  );
-
-  assert.deepEqual(merged.leftSegments, ["path"]);
-  assert.deepEqual(merged.rightSegments, ["git", "custom:timer"]);
-  assert.deepEqual(merged.secondarySegments, ["extension_statuses"]);
-});
-
-test("mergeSegmentsWithCustomItems applies partial layout rows before disabled filtering", () => {
-  const merged = mergeSegmentsWithCustomItems(
-    {
-      leftSegments: ["path", "model"],
-      rightSegments: ["git", "cost", "extension_statuses"],
-      secondarySegments: ["extension_statuses"],
-      separator: "powerline",
-    },
-    [
-      { id: "ci", statusKey: "ci", position: "right", hideWhenMissing: true, excludeFromExtensionStatuses: true },
-      { id: "review", statusKey: "review", position: "secondary", hideWhenMissing: true, excludeFromExtensionStatuses: true },
-    ],
-    {
-      layout: {
-        left: ["model", "custom:ci", "extension_statuses"],
-        secondary: [],
-      },
-      disabledSegments: ["model"],
-    },
-  );
-
-  assert.deepEqual(merged.leftSegments, ["custom:ci", "extension_statuses"]);
-  assert.deepEqual(merged.rightSegments, ["git", "cost"]);
-  assert.deepEqual(merged.secondarySegments, []);
-});
-
-test("nextPowerlineSettingWithPreset preserves object settings", () => {
-  const updated = nextPowerlineSettingWithPreset({ preset: "default", customItems: [{ id: "ci" }] }, "compact");
-  if (typeof updated !== "object" || updated === null || Array.isArray(updated)) {
-    assert.fail("expected an object powerline setting");
-  }
-  if (!("preset" in updated)) {
-    assert.fail("expected preset to be preserved on the updated powerline setting");
-  }
-  if (!("customItems" in updated)) {
-    assert.fail("expected customItems to be preserved on the updated powerline setting");
-  }
-
-  assert.equal(updated.preset, "compact");
-  assert.deepEqual(updated.customItems, [{ id: "ci" }]);
-});
-
-test("nextPowerlineSettingWithOptions preserves object settings", () => {
-  const updated = nextPowerlineSettingWithOptions(
-    { preset: "default", customItems: [{ id: "ci" }] },
-    { placement: "below" },
-    "compact",
-  );
-
-  assert.deepEqual(updated, { preset: "default", customItems: [{ id: "ci" }], placement: "below" });
-});
-
-test("nextPowerlineSettingWithOptions converts string presets to object settings", () => {
-  assert.deepEqual(nextPowerlineSettingWithOptions("compact", { placement: "below" }, "compact"), {
-    preset: "compact",
-    placement: "below",
-  });
-});
-
-test("collectHiddenExtensionStatusKeys includes default custom status keys", () => {
-  const hidden = collectHiddenExtensionStatusKeys([
-    { id: "ci", statusKey: "ci-status", position: "right", hideWhenMissing: true, excludeFromExtensionStatuses: true },
-    { id: "review", statusKey: "review", position: "secondary", hideWhenMissing: true, excludeFromExtensionStatuses: false },
-  ]);
-
-  assert.equal(hidden.has("ci-status"), true);
-  assert.equal(hidden.has("review"), false);
-});
-
-test("normalizeCompactExtensionStatus strips baked-in trailing separators", () => {
-  assert.equal(normalizeCompactExtensionStatus("CI ok · "), "CI ok");
-  assert.equal(normalizeCompactExtensionStatus("CI ok |   "), "CI ok");
-  assert.equal(normalizeCompactExtensionStatus("[notice] queued"), null);
-});
-
-test("normalizeExtensionStatusValue keeps notification-style statuses renderable for custom items", () => {
-  assert.equal(normalizeExtensionStatusValue("[review] queued · "), "[review] queued");
-});
-
-test("getNotificationExtensionStatuses skips promoted hidden status keys", () => {
-  const statuses = new Map<string, string>([
-    ["ci-status", "[ci] queued"],
-    ["review", "[review] running"],
-    ["plain", "plain status"],
-  ]);
-  const hidden = new Set(["ci-status"]);
-
-  assert.deepEqual(getNotificationExtensionStatuses(statuses, hidden), ["[review] running"]);
-});

package/dist/extensions/pi-powerline-footer/tests/editor-composition.test.ts

@@ -1,48 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import type { AutocompleteProvider } from "@earendil-works/pi-tui";
-import { getEditorAutocompleteProvider, passAutocompleteProviderThroughPreviousEditor } from "../editor-composition.ts";
-
-function baseProvider(): AutocompleteProvider {
-  return {
-    async getSuggestions() {
-      return {
-        prefix: "@",
-        items: [{ label: "base", value: "base" }],
-      };
-    },
-    applyCompletion(lines, cursorLine, cursorCol) {
-      return { lines, cursorLine, cursorCol };
-    },
-  };
-}
-
-test("previous editor autocomplete provider wrappers are preserved", async () => {
-  const previousEditor = {
-    autocompleteProvider: undefined as AutocompleteProvider | undefined,
-    setAutocompleteProvider(provider: AutocompleteProvider) {
-      this.autocompleteProvider = {
-        async getSuggestions(lines, cursorLine, cursorCol, context) {
-          const suggestions = await provider.getSuggestions(lines, cursorLine, cursorCol, context);
-          return {
-            ...suggestions,
-            items: [...suggestions.items, { label: "previous-wrapper", value: "previous-wrapper" }],
-          };
-        },
-        applyCompletion: provider.applyCompletion.bind(provider),
-      };
-    },
-  };
-
-  const composed = passAutocompleteProviderThroughPreviousEditor(baseProvider(), previousEditor);
-  const suggestions = await composed.getSuggestions(["@"], 0, 1, { signal: new AbortController().signal });
-
-  assert.equal(composed, previousEditor.autocompleteProvider);
-  assert.deepEqual(suggestions.items.map((item) => item.label), ["base", "previous-wrapper"]);
-});
-
-test("autocomplete provider detection rejects incomplete editor providers", () => {
-  assert.equal(getEditorAutocompleteProvider({ autocompleteProvider: {} }), undefined);
-  assert.equal(getEditorAutocompleteProvider({ autocompleteProvider: { getSuggestions() {} } }), undefined);
-  assert.ok(getEditorAutocompleteProvider({ autocompleteProvider: baseProvider() }));
-});