oh-pi 0.1.69 → 0.1.71

package/dist/i18n.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/i18n.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { t, setLocale, getLocale } from "./i18n.js";
+afterEach(() => setLocale("en"));
+describe("t", () => {
+    it("returns known en key", () => {
+        expect(t("welcome.title")).toContain("oh-pi");
+    });
+    it("interpolates vars", () => {
+        const result = t("welcome.piDetected", { version: "1.0" });
+        expect(result).toContain("1.0");
+    });
+    it("falls back to en when zh key missing", () => {
+        setLocale("zh");
+        const enVal = t("welcome.title");
+        expect(enVal).toBeTruthy();
+        expect(enVal).not.toBe("welcome.title");
+    });
+    it("falls back to key string when key missing in all locales", () => {
+        expect(t("nonexistent.key.xyz")).toBe("nonexistent.key.xyz");
+    });
+    it("setLocale/getLocale round-trip en", () => {
+        setLocale("en");
+        expect(getLocale()).toBe("en");
+    });
+    it("setLocale/getLocale round-trip zh", () => {
+        setLocale("zh");
+        expect(getLocale()).toBe("zh");
+    });
+    it("setLocale/getLocale round-trip fr", () => {
+        setLocale("fr");
+        expect(getLocale()).toBe("fr");
+    });
+    it("returns zh translation after setLocale zh", () => {
+        const enResult = t("welcome.title");
+        setLocale("zh");
+        const zhResult = t("welcome.title");
+        expect(zhResult).toContain("oh-pi");
+        expect(zhResult).not.toBe(enResult);
+    });
+    it("interpolates multiple vars", () => {
+        const result = t("welcome.envInfo", { terminal: "xterm", os: "linux", node: "v20" });
+        expect(result).toContain("xterm");
+        expect(result).toContain("linux");
+    });
+    it("returns string without vars unchanged", () => {
+        expect(typeof t("cancelled")).toBe("string");
+    });
+    it("does not crash with empty vars", () => {
+        expect(t("welcome.title", {})).toContain("oh-pi");
+    });
+    it("fr locale returns fr translation", () => {
+        setLocale("fr");
+        const result = t("welcome.title");
+        expect(result).toContain("oh-pi");
+    });
+});

package/dist/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/registry.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect } from "vitest";
+import { MODEL_CAPABILITIES, PROVIDERS, THEMES, EXTENSIONS, KEYBINDING_SCHEMES } from "./registry.js";
+describe("MODEL_CAPABILITIES", () => {
+    it("has entries", () => {
+        expect(Object.keys(MODEL_CAPABILITIES).length).toBeGreaterThan(0);
+    });
+    it("each entry has required fields", () => {
+        for (const [, cap] of Object.entries(MODEL_CAPABILITIES)) {
+            expect(cap).toHaveProperty("contextWindow");
+            expect(cap).toHaveProperty("maxTokens");
+            expect(cap).toHaveProperty("reasoning");
+            expect(cap).toHaveProperty("input");
+            expect(cap.contextWindow).toBeGreaterThan(0);
+            expect(cap.maxTokens).toBeGreaterThan(0);
+        }
+    });
+});
+describe("PROVIDERS", () => {
+    const expected = ["anthropic", "openai", "google", "groq", "openrouter", "xai", "mistral"];
+    it("has 7 providers", () => {
+        expect(Object.keys(PROVIDERS)).toHaveLength(7);
+    });
+    it("contains all expected providers", () => {
+        for (const name of expected) {
+            expect(PROVIDERS).toHaveProperty(name);
+        }
+    });
+    it("each provider has env/label/models", () => {
+        for (const [, info] of Object.entries(PROVIDERS)) {
+            expect(info.env).toMatch(/_API_KEY$|_KEY$/);
+            expect(info.label).toBeTruthy();
+            expect(Array.isArray(info.models)).toBe(true);
+        }
+    });
+});
+describe("THEMES", () => {
+    it("is array with entries", () => {
+        expect(Array.isArray(THEMES)).toBe(true);
+        expect(THEMES.length).toBeGreaterThan(0);
+    });
+    it("each has name/label/style", () => {
+        for (const theme of THEMES) {
+            expect(theme).toHaveProperty("name");
+            expect(theme).toHaveProperty("label");
+            expect(theme).toHaveProperty("style");
+        }
+    });
+});
+describe("EXTENSIONS", () => {
+    it("is array with entries", () => {
+        expect(Array.isArray(EXTENSIONS)).toBe(true);
+        expect(EXTENSIONS.length).toBeGreaterThan(0);
+    });
+    it("each has name/label/default", () => {
+        for (const ext of EXTENSIONS) {
+            expect(ext).toHaveProperty("name");
+            expect(ext).toHaveProperty("label");
+            expect(ext).toHaveProperty("default");
+        }
+    });
+});
+describe("KEYBINDING_SCHEMES", () => {
+    it("has default/vim/emacs", () => {
+        expect(KEYBINDING_SCHEMES).toHaveProperty("default");
+        expect(KEYBINDING_SCHEMES).toHaveProperty("vim");
+        expect(KEYBINDING_SCHEMES).toHaveProperty("emacs");
+    });
+});

package/dist/tui/confirm-apply.d.ts

@@ -1,5 +1,12 @@
 import type { OhPConfig } from "../types.js";
 import type { EnvInfo } from "../utils/detect.js";
+/**
+ * 统计已有配置中指定目录下的文件数量。
+ * @param env - 环境信息
+ * @param dir - 目录名称前缀
+ * @returns 匹配的文件数
+ */
+export declare function countExisting(env: EnvInfo, dir: string): number;
 /**
  * 展示配置摘要，处理已有配置的备份/覆盖，安装 pi（如需），并应用最终配置。
  * @param config - 用户选择的配置对象

package/dist/tui/confirm-apply.js

@@ -8,7 +8,7 @@ import { applyConfig, installPi, backupConfig } from "../utils/install.js";
  * @param dir - 目录名称前缀
  * @returns 匹配的文件数
  */
-function countExisting(env, dir) {
+export function countExisting(env, dir) {
     return env.existingFiles.filter(f => f.startsWith(dir + "/")).length;
 }
 /**

package/dist/tui/confirm-apply.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/confirm-apply.test.js

@@ -0,0 +1,20 @@
+import { describe, it, expect } from "vitest";
+import { countExisting } from "./confirm-apply.js";
+const mkEnv = (files) => ({ existingFiles: files });
+describe("countExisting", () => {
+    it("counts files matching prefix", () => {
+        expect(countExisting(mkEnv(["extensions/a", "extensions/b", "prompts/c"]), "extensions")).toBe(2);
+    });
+    it("returns 0 when no match", () => {
+        expect(countExisting(mkEnv(["extensions/a"]), "themes")).toBe(0);
+    });
+    it("returns 0 for empty existingFiles", () => {
+        expect(countExisting(mkEnv([]), "extensions")).toBe(0);
+    });
+    it("counts different prefix", () => {
+        expect(countExisting(mkEnv(["extensions/a", "extensions/b", "prompts/c"]), "prompts")).toBe(1);
+    });
+    it("does not match without slash separator", () => {
+        expect(countExisting(mkEnv(["extensionsX"]), "extensions")).toBe(0);
+    });
+});

package/dist/tui/provider-setup.d.ts

@@ -1,5 +1,7 @@
 import type { ProviderConfig } from "../types.js";
 import type { EnvInfo } from "../utils/detect.js";
+/** Block internal/private IPs to prevent SSRF */
+export declare function isUnsafeUrl(urlStr: string): boolean;
 /**
  * Interactively configure API providers, detecting existing keys, allowing multi-select, and supporting custom endpoints.
  * @param env - Current environment info with detected providers

package/dist/tui/provider-setup.js

@@ -12,6 +12,36 @@ const PROVIDER_API_URLS = {
     xai: "https://api.x.ai",
     mistral: "https://api.mistral.ai",
 };
+/** Block internal/private IPs to prevent SSRF */
+export function isUnsafeUrl(urlStr) {
+    try {
+        const u = new URL(urlStr);
+        const host = u.hostname;
+        // Allow localhost for local dev servers (Ollama, vLLM, etc.)
+        if (host === "localhost" || host === "127.0.0.1" || host === "::1")
+            return false;
+        // Block private IP ranges
+        if (/^10\./.test(host))
+            return true;
+        if (/^172\.(1[6-9]|2\d|3[01])\./.test(host))
+            return true;
+        if (/^192\.168\./.test(host))
+            return true;
+        if (/^0\./.test(host) || host === "0.0.0.0")
+            return true;
+        if (host.includes(":") || host.startsWith("["))
+            return true;
+        if (/^169\.254\./.test(host))
+            return true;
+        // Block non-https for remote hosts
+        if (u.protocol !== "https:")
+            return true;
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
 /**
  * 动态获取模型列表，依次尝试 Anthropic、Google、OpenAI 兼容 API 风格。
  * @param provider - 提供商名称
@@ -85,7 +115,7 @@ async function fetchModels(provider, baseUrl, apiKey) {
                     api: "openai-completions",
                     models: data.map((m) => ({
                         id: m.id,
-                        reasoning: m.thinking_enabled ?? m.id.includes("o3") ?? false,
+                        reasoning: m.thinking_enabled ?? m.id.includes("o3"),
                         input: ["text", "image"],
                         contextWindow: m.context_window ?? m.max_tokens ?? 128000,
                         maxTokens: m.max_output ?? 16384,
@@ -158,7 +188,7 @@ export async function setupProviders(env) {
             const url = await p.text({
                 message: t("provider.baseUrl", { label: info.label }),
                 placeholder: "https://proxy.example.com",
-                validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : undefined,
+                validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : isUnsafeUrl(v) ? "URL must use HTTPS for remote hosts (private IPs blocked)" : undefined,
             });
             if (p.isCancel(url)) {
                 p.cancel(t("cancelled"));
@@ -203,7 +233,7 @@ async function setupCustomProvider() {
     const baseUrl = await p.text({
         message: t("provider.baseUrlCustom"),
         placeholder: t("provider.baseUrlCustomPlaceholder"),
-        validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : undefined,
+        validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : isUnsafeUrl(v) ? "URL must use HTTPS for remote hosts (private IPs blocked)" : undefined,
     });
     if (p.isCancel(baseUrl)) {
         p.cancel(t("cancelled"));

package/dist/tui/provider-setup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/provider-setup.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { isUnsafeUrl } from "./provider-setup.js";
+describe("isUnsafeUrl", () => {
+    it("https remote is safe", () => {
+        expect(isUnsafeUrl("https://api.example.com")).toBe(false);
+    });
+    it("http localhost is safe", () => {
+        expect(isUnsafeUrl("http://localhost:11434")).toBe(false);
+    });
+    it("http 127.0.0.1 is safe", () => {
+        expect(isUnsafeUrl("http://127.0.0.1:8080")).toBe(false);
+    });
+    it("http [::1] is blocked (contains colon in hostname)", () => {
+        expect(isUnsafeUrl("http://[::1]:8080")).toBe(true);
+    });
+    it("10.x private is unsafe", () => {
+        expect(isUnsafeUrl("https://10.0.0.1/api")).toBe(true);
+    });
+    it("172.16.x private is unsafe", () => {
+        expect(isUnsafeUrl("https://172.16.0.1/api")).toBe(true);
+    });
+    it("192.168.x private is unsafe", () => {
+        expect(isUnsafeUrl("https://192.168.1.1/api")).toBe(true);
+    });
+    it("http remote is unsafe", () => {
+        expect(isUnsafeUrl("http://api.example.com")).toBe(true);
+    });
+    it("0.0.0.0 is unsafe", () => {
+        expect(isUnsafeUrl("https://0.0.0.0")).toBe(true);
+    });
+    it("169.254.x link-local is unsafe", () => {
+        expect(isUnsafeUrl("https://169.254.1.1")).toBe(true);
+    });
+    it("invalid url is unsafe", () => {
+        expect(isUnsafeUrl("not-a-url")).toBe(true);
+    });
+    it("empty string is unsafe", () => {
+        expect(isUnsafeUrl("")).toBe(true);
+    });
+});

package/dist/tui/welcome.d.ts

@@ -4,3 +4,9 @@ import type { EnvInfo } from "../utils/detect.js";
  * @param {EnvInfo} env - 当前检测到的环境信息
  */
 export declare function welcome(env: EnvInfo): void;
+/**
+ * 按顶层目录分类统计文件数量，返回格式化字符串。
+ * @param {string[]} files - 文件相对路径列表
+ * @returns {string} 分类统计字符串，如 "extensions (3)  prompts (5)"
+ */
+export declare function categorize(files: string[]): string;

package/dist/tui/welcome.js

@@ -28,7 +28,7 @@ export function welcome(env) {
  * @param {string[]} files - 文件相对路径列表
  * @returns {string} 分类统计字符串，如 "extensions (3)  prompts (5)"
  */
-function categorize(files) {
+export function categorize(files) {
     const cats = {};
     for (const f of files) {
         const cat = f.includes("/") ? f.split("/")[0] : f;

package/dist/tui/welcome.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/welcome.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { categorize } from "./welcome.js";
+describe("categorize", () => {
+    it("groups by directory", () => {
+        const result = categorize(["ext/a.ts", "ext/b.ts", "prompts/c.md"]);
+        expect(result).toContain("ext (2)");
+        expect(result).toContain("prompts (1)");
+    });
+    it("empty array returns empty string", () => {
+        expect(categorize([])).toBe("");
+    });
+    it("files without directory use filename", () => {
+        const result = categorize(["a.ts", "b.ts"]);
+        expect(result).toContain("a.ts (1)");
+        expect(result).toContain("b.ts (1)");
+    });
+    it("single file", () => {
+        expect(categorize(["foo/bar.ts"])).toBe("foo (1)");
+    });
+    it("mixed files with and without directory", () => {
+        const result = categorize(["a.ts", "dir/b.ts"]);
+        expect(result).toContain("a.ts (1)");
+        expect(result).toContain("dir (1)");
+    });
+});

package/dist/utils/resources.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/resources.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { resources } from "./resources.js";
+describe("resources", () => {
+    it("agent returns correct path", () => {
+        const p = resources.agent("foo");
+        expect(p).toContain("agents/foo.md");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("extension returns correct path", () => {
+        const p = resources.extension("bar");
+        expect(p).toContain("extensions/bar");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("extensionFile returns correct path", () => {
+        const p = resources.extensionFile("baz");
+        expect(p).toContain("extensions/baz.ts");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("prompt returns correct path", () => {
+        const p = resources.prompt("test");
+        expect(p).toContain("prompts/test.md");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("skill returns correct path", () => {
+        const p = resources.skill("sk");
+        expect(p).toContain("skills/sk");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("skillsDir returns correct path", () => {
+        const p = resources.skillsDir();
+        expect(p).toContain("skills");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("theme returns correct path", () => {
+        const p = resources.theme("dark");
+        expect(p).toContain("themes/dark.json");
+        expect(p.startsWith("/")).toBe(true);
+    });
+});

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "oh-pi",
-  "version": "0.1.69",
+  "version": "0.1.71",
   "description": "One-click setup for pi-coding-agent. Like oh-my-zsh for pi.",
   "type": "module",
   "bin": {
-    "oh-pi": "./dist/bin/oh-pi.js"
+    "oh-pi": "dist/bin/oh-pi.js"
   },
   "main": "./dist/index.js",
   "files": [
@@ -16,6 +16,7 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/bin/oh-pi.js",
+    "test": "vitest run",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -46,7 +47,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
   },
   "engines": {
     "node": ">=20.0.0"

package/pi-package/extensions/ant-colony/concurrency.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from "vitest";
+import { defaultConcurrency, adapt } from "./concurrency.js";
+import type { ConcurrencyConfig, ConcurrencySample } from "./types.js";
+
+const mkSample = (o: Partial<ConcurrencySample> = {}): ConcurrencySample => ({
+  timestamp: Date.now(), concurrency: 2, cpuLoad: 0.3, memFree: 4e9, throughput: 1, ...o,
+});
+
+describe("defaultConcurrency", () => {
+  it("returns valid config", () => {
+    const c = defaultConcurrency();
+    expect(c.current).toBe(2);
+    expect(c.min).toBe(1);
+    expect(c.max).toBeGreaterThanOrEqual(1);
+    expect(c.max).toBeLessThanOrEqual(8);
+    expect(c.history).toEqual([]);
+  });
+});
+
+describe("adapt", () => {
+  it("drops to min when no pending tasks", () => {
+    const cfg: ConcurrencyConfig = { current: 4, min: 1, max: 8, optimal: 3, history: [mkSample(), mkSample()] };
+    expect(adapt(cfg, 0).current).toBe(1);
+  });
+
+  it("cold start gives half max", () => {
+    const cfg: ConcurrencyConfig = { current: 2, min: 1, max: 8, optimal: 3, history: [mkSample()] };
+    expect(adapt(cfg, 10).current).toBe(4);
+  });
+
+  it("reduces when CPU > 85%", () => {
+    const s = mkSample({ cpuLoad: 0.9 });
+    const cfg: ConcurrencyConfig = { current: 4, min: 1, max: 8, optimal: 3, history: [s, s, s] };
+    expect(adapt(cfg, 10).current).toBeLessThan(4);
+  });
+
+  it("reduces when memory low", () => {
+    const s = mkSample({ memFree: 100 * 1024 * 1024 });
+    const cfg: ConcurrencyConfig = { current: 4, min: 1, max: 8, optimal: 3, history: [s, s] };
+    expect(adapt(cfg, 10).current).toBeLessThan(4);
+  });
+
+  it("increases during exploration when throughput rising", () => {
+    const s1 = mkSample({ throughput: 1 });
+    const s2 = mkSample({ throughput: 2 });
+    const cfg: ConcurrencyConfig = { current: 3, min: 1, max: 8, optimal: 3, history: [s1, s2] };
+    expect(adapt(cfg, 10).current).toBeGreaterThanOrEqual(3);
+  });
+
+  it("does not exceed max", () => {
+    const s1 = mkSample({ throughput: 1 });
+    const s2 = mkSample({ throughput: 5 });
+    const cfg: ConcurrencyConfig = { current: 8, min: 1, max: 8, optimal: 3, history: [s1, s2] };
+    expect(adapt(cfg, 100).current).toBeLessThanOrEqual(8);
+  });
+
+  it("does not exceed pending task count", () => {
+    const s1 = mkSample({ throughput: 1 });
+    const s2 = mkSample({ throughput: 5 });
+    const cfg: ConcurrencyConfig = { current: 3, min: 1, max: 8, optimal: 3, history: [s1, s2] };
+    expect(adapt(cfg, 2).current).toBeLessThanOrEqual(2);
+  });
+
+  it("respects rate limit cooldown", () => {
+    const s1 = mkSample({ throughput: 1 });
+    const s2 = mkSample({ throughput: 2 });
+    const cfg: ConcurrencyConfig = { current: 3, min: 1, max: 8, optimal: 3, history: [s1, s2], lastRateLimitAt: Date.now() };
+    expect(adapt(cfg, 10).current).toBeLessThanOrEqual(3);
+  });
+});

package/pi-package/extensions/ant-colony/concurrency.ts

@@ -76,18 +76,27 @@ export function adapt(config: ConcurrencyConfig, pendingTasks: number): Concurre
   const latest = samples[samples.length - 1];
   const prev = samples[samples.length - 2];
 
-  // 硬约束：系统过载立即减少
-  if (latest.cpuLoad > 0.85 || latest.memFree < 500 * 1024 * 1024) {
+  // CPU 滑动窗口：最近 3 次采样平均值
+  const recentCpuSamples = samples.slice(-3);
+  const avgCpu = recentCpuSamples.reduce((s, x) => s + x.cpuLoad, 0) / recentCpuSamples.length;
+
+  // 429 冷却：30s 内不允许增加并发
+  const inRateLimitCooldown = config.lastRateLimitAt != null && Date.now() - config.lastRateLimitAt < 30000;
+
+  // 硬约束：系统过载立即减少（滞回带：>85% 减，60%-85% 保持）
+  if (avgCpu > 0.85 || latest.memFree < 500 * 1024 * 1024) {
     next.current = Math.max(config.min, config.current - 1);
     return next;
   }
 
+  // 滞回带：CPU 在 60%-85% 之间保持不变
+  const canIncrease = avgCpu < 0.6 && !inRateLimitCooldown;
+
   // 探索期：样本不足，逐步提升
   if (samples.length < 10) {
-    if (latest.throughput >= prev.throughput) {
-      // 吞吐量还在涨，继续探索
+    if (latest.throughput >= prev.throughput && canIncrease) {
       next.current = Math.min(config.current + 1, taskCap);
-    } else {
+    } else if (latest.throughput < prev.throughput) {
       // 吞吐量下降，找到拐点
       next.optimal = prev.concurrency;
       next.current = prev.concurrency;
@@ -99,20 +108,17 @@ export function adapt(config: ConcurrencyConfig, pendingTasks: number): Concurre
   const recentThroughput = samples.slice(-5).reduce((s, x) => s + x.throughput, 0) / 5;
   const olderThroughput = samples.slice(-10, -5).reduce((s, x) => s + x.throughput, 0) / 5;
 
-  if (recentThroughput > olderThroughput * 1.1 && latest.cpuLoad < 0.7) {
-    // 吞吐量上升且 CPU 有余量，尝试+1
+  if (recentThroughput > olderThroughput * 1.1 && canIncrease) {
     next.current = Math.min(config.current + 1, taskCap);
     if (recentThroughput > olderThroughput * 1.2) {
-      next.optimal = next.current; // 更新最优值
+      next.optimal = next.current;
     }
   } else if (recentThroughput < olderThroughput * 0.8) {
-    // 吞吐量下降，回退
     next.current = Math.max(config.min, config.optimal);
   }
-  // 否则保持不变
 
   // 429 recovery: restore to optimal when CPU is underutilized (e.g. after backoff)
-  if (latest.cpuLoad < 0.5 && next.current < config.optimal) {
+  if (avgCpu < 0.5 && next.current < config.optimal && !inRateLimitCooldown) {
     next.current = config.optimal;
   }
 

package/pi-package/extensions/ant-colony/deps.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "vitest";
+import { buildImportGraph, dependencyDepth, taskDependsOn } from "./deps.js";
+import type { ImportGraph } from "./deps.js";
+
+describe("buildImportGraph", () => {
+  it("returns empty graph for empty files", () => {
+    const graph = buildImportGraph([], "/tmp");
+    expect(graph.imports.size).toBe(0);
+    expect(graph.importedBy.size).toBe(0);
+  });
+
+  it("returns empty graph for nonexistent files", () => {
+    const graph = buildImportGraph(["nonexistent.ts"], "/tmp");
+    expect(graph.imports.size).toBe(0);
+  });
+});
+
+describe("dependencyDepth", () => {
+  it("returns 0 for file with no dependents", () => {
+    const graph: ImportGraph = { imports: new Map(), importedBy: new Map() };
+    expect(dependencyDepth("a.ts", graph)).toBe(0);
+  });
+
+  it("counts direct dependents", () => {
+    const graph: ImportGraph = {
+      imports: new Map([["b.ts", new Set(["a.ts"])]]),
+      importedBy: new Map([["a.ts", new Set(["b.ts"])]]),
+    };
+    expect(dependencyDepth("a.ts", graph)).toBe(1);
+  });
+
+  it("counts transitive dependents", () => {
+    const graph: ImportGraph = {
+      imports: new Map([["b.ts", new Set(["a.ts"])], ["c.ts", new Set(["b.ts"])]]),
+      importedBy: new Map([["a.ts", new Set(["b.ts"])], ["b.ts", new Set(["c.ts"])]]),
+    };
+    expect(dependencyDepth("a.ts", graph)).toBe(2);
+  });
+});
+
+describe("taskDependsOn", () => {
+  it("returns true when taskA imports taskB file", () => {
+    const graph: ImportGraph = {
+      imports: new Map([["a.ts", new Set(["b.ts"])]]),
+      importedBy: new Map([["b.ts", new Set(["a.ts"])]]),
+    };
+    expect(taskDependsOn(["a.ts"], ["b.ts"], graph)).toBe(true);
+  });
+
+  it("returns false when no dependency", () => {
+    const graph: ImportGraph = {
+      imports: new Map([["a.ts", new Set(["c.ts"])]]),
+      importedBy: new Map(),
+    };
+    expect(taskDependsOn(["a.ts"], ["b.ts"], graph)).toBe(false);
+  });
+
+  it("returns false for empty file lists", () => {
+    const graph: ImportGraph = { imports: new Map(), importedBy: new Map() };
+    expect(taskDependsOn([], [], graph)).toBe(false);
+  });
+});