@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/core/src/__tests__/length-normalizer.test.ts

@@ -0,0 +1,331 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { BaseAgent } from "../agents/base.js";
+import { LengthNormalizerAgent } from "../agents/length-normalizer.js";
+import { LengthSpecSchema } from "../models/length-governance.js";
+import { countChapterLength } from "../utils/length-metrics.js";
+
+const ZERO_USAGE = {
+  promptTokens: 0,
+  completionTokens: 0,
+  totalTokens: 0,
+} as const;
+
+const AGENT_CONTEXT = {
+  client: {
+    provider: "openai",
+    apiFormat: "chat",
+    stream: false,
+    defaults: {
+      temperature: 0.7,
+      maxTokens: 4096,
+      thinkingBudget: 0,
+      extra: {},
+    },
+  } as const,
+  model: "test-model",
+  projectRoot: "/tmp/inkos-length-normalizer-test",
+};
+
+function createAgent(): LengthNormalizerAgent {
+  return new LengthNormalizerAgent(AGENT_CONTEXT as never);
+}
+
+describe("LengthNormalizerAgent", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("compresses a long draft while preserving required markers", async () => {
+    const agent = createAgent();
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: "压缩后的正文。".repeat(8) + "[[KEEP_ME]]",
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 220,
+      softMin: 190,
+      softMax: 250,
+      hardMin: 160,
+      hardMax: 280,
+      countingMode: "zh_chars",
+      normalizeMode: "compress",
+    });
+    const draft = "开头。" + "多余句子。".repeat(80) + "[[KEEP_ME]]";
+
+    const result = await agent.normalizeChapter({
+      chapterContent: draft,
+      lengthSpec,
+      chapterIntent: "Preserve [[KEEP_ME]] and remove redundancy.",
+      reducedControlBlock: "Avoid [[FORBIDDEN]] and keep the scene on target.",
+    });
+
+    expect(chatSpy).toHaveBeenCalledTimes(1);
+    expect(result.applied).toBe(true);
+    expect(result.mode).toBe("compress");
+    expect(result.normalizedContent).toContain("[[KEEP_ME]]");
+    expect(result.normalizedContent).not.toContain("[[FORBIDDEN]]");
+    expect(result.finalCount).toBe(countChapterLength(result.normalizedContent, "zh_chars"));
+    expect(result.finalCount).toBeLessThan(countChapterLength(draft, "zh_chars"));
+  });
+
+  it("expands a short draft without inserting forbidden markers", async () => {
+    const agent = createAgent();
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: "扩写后的正文，补足细节和过渡，但不引入禁词。",
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 220,
+      softMin: 190,
+      softMax: 250,
+      hardMin: 160,
+      hardMax: 280,
+      countingMode: "zh_chars",
+      normalizeMode: "expand",
+    });
+    const draft = "开头太短。";
+
+    const result = await agent.normalizeChapter({
+      chapterContent: draft,
+      lengthSpec,
+      chapterIntent: "Keep the chapter focused on the mentor conflict.",
+      reducedControlBlock: "Forbidden marker: [[FORBIDDEN]].",
+    });
+
+    expect(chatSpy).toHaveBeenCalledTimes(1);
+    expect(result.applied).toBe(true);
+    expect(result.mode).toBe("expand");
+    expect(result.normalizedContent).not.toContain("[[FORBIDDEN]]");
+    expect(result.finalCount).toBe(countChapterLength(result.normalizedContent, "zh_chars"));
+    expect(result.finalCount).toBeGreaterThan(countChapterLength(draft, "zh_chars"));
+  });
+
+  it("never retries normalization in the same pass", async () => {
+    const agent = createAgent();
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: "仍然过长的正文。".repeat(60),
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 220,
+      softMin: 190,
+      softMax: 250,
+      hardMin: 160,
+      hardMax: 280,
+      countingMode: "zh_chars",
+      normalizeMode: "compress",
+    });
+    const draft = "开头。" + "冗余句子。".repeat(100);
+
+    const result = await agent.normalizeChapter({
+      chapterContent: draft,
+      lengthSpec,
+      chapterIntent: "Preserve the scene marker [[KEEP_ME]].",
+      reducedControlBlock: "Do not invent new subplots.",
+    });
+
+    expect(chatSpy).toHaveBeenCalledTimes(1);
+    expect(result.applied).toBe(true);
+    expect(result.mode).toBe("compress");
+    expect(result.warning).toContain("outside");
+  });
+
+  it("does not override provider output budget for large compression outputs", async () => {
+    const agent = createAgent();
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: "压缩后的完整正文。".repeat(200),
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 3500,
+      softMin: 3023,
+      softMax: 3977,
+      hardMin: 2800,
+      hardMax: 4200,
+      countingMode: "zh_chars",
+      normalizeMode: "compress",
+    });
+
+    await agent.normalizeChapter({
+      chapterContent: "原始正文。".repeat(1200),
+      lengthSpec,
+    });
+
+    const options = chatSpy.mock.calls[0]?.[1] as { maxTokens?: number } | undefined;
+    expect(options?.maxTokens).toBeUndefined();
+  });
+
+  it("falls back to the original chapter when normalized output is truncated mid-sentence", async () => {
+    const agent = createAgent();
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: "李队把传真和登记表叠在一起，收进文件夹，眼神已经不是单",
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 3500,
+      softMin: 3023,
+      softMax: 3977,
+      hardMin: 2800,
+      hardMax: 4200,
+      countingMode: "zh_chars",
+      normalizeMode: "compress",
+    });
+    const draft = "原始正文有完整句号。".repeat(400);
+
+    const result = await agent.normalizeChapter({
+      chapterContent: draft,
+      lengthSpec,
+    });
+
+    expect(chatSpy).toHaveBeenCalledTimes(1);
+    expect(result.normalizedContent).toBe(draft);
+    expect(result.warning).toContain("truncated");
+  });
+
+  it("keeps a complete in-range rewrite even when it ends without punctuation", async () => {
+    const agent = createAgent();
+    const rewrite = "完整正文".repeat(900);
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: rewrite,
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 3500,
+      softMin: 3023,
+      softMax: 3977,
+      hardMin: 2800,
+      hardMax: 4200,
+      countingMode: "zh_chars",
+      normalizeMode: "compress",
+    });
+    const draft = "原始正文有完整句号。".repeat(500);
+
+    const result = await agent.normalizeChapter({
+      chapterContent: draft,
+      lengthSpec,
+    });
+
+    expect(chatSpy).toHaveBeenCalledTimes(1);
+    expect(result.normalizedContent).toBe(rewrite);
+    expect(result.warning).toBeUndefined();
+  });
+
+  it("strips explanatory wrappers from malformed normalizer output", async () => {
+    const agent = createAgent();
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: [
+        "我先压缩一下正文。",
+        "",
+        "```markdown",
+        "压缩后的正文。[[KEEP_ME]]",
+        "```",
+      ].join("\n"),
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 220,
+      softMin: 190,
+      softMax: 250,
+      hardMin: 160,
+      hardMax: 280,
+      countingMode: "zh_chars",
+      normalizeMode: "compress",
+    });
+    const draft = "开头。" + "冗余句子。".repeat(50) + "[[KEEP_ME]]";
+
+    const result = await agent.normalizeChapter({
+      chapterContent: draft,
+      lengthSpec,
+      chapterIntent: "Preserve [[KEEP_ME]] only.",
+      reducedControlBlock: "No extra commentary.",
+    });
+
+    expect(chatSpy).toHaveBeenCalledTimes(1);
+    expect(result.normalizedContent).toBe("压缩后的正文。[[KEEP_ME]]");
+    expect(result.normalizedContent).not.toContain("我先压缩一下正文");
+    expect(result.normalizedContent).not.toContain("```");
+  });
+
+  it("falls back to the original chapter when the response contains only wrappers", async () => {
+    const agent = createAgent();
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: "我先压缩一下正文。",
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 220,
+      softMin: 190,
+      softMax: 250,
+      hardMin: 160,
+      hardMax: 280,
+      countingMode: "zh_chars",
+      normalizeMode: "compress",
+    });
+    const draft = "开头。" + "冗余句子。".repeat(40) + "[[KEEP_ME]]";
+
+    const result = await agent.normalizeChapter({
+      chapterContent: draft,
+      lengthSpec,
+      chapterIntent: "Preserve [[KEEP_ME]] only.",
+      reducedControlBlock: "No extra commentary.",
+    });
+
+    expect(chatSpy).toHaveBeenCalledTimes(1);
+    expect(result.normalizedContent).toBe(draft);
+    expect(result.finalCount).toBe(countChapterLength(draft, "zh_chars"));
+  });
+
+  it("preserves legitimate Chinese prose that starts with '我先'", async () => {
+    const agent = createAgent();
+    const prose = "我先回去了，明天再说。\n风从窗缝里灌进来。";
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: prose,
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 220,
+      softMin: 190,
+      softMax: 250,
+      hardMin: 160,
+      hardMax: 280,
+      countingMode: "zh_chars",
+      normalizeMode: "compress",
+    });
+    const draft = "原文。".repeat(80);
+
+    const result = await agent.normalizeChapter({
+      chapterContent: draft,
+      lengthSpec,
+    });
+
+    expect(chatSpy).toHaveBeenCalledTimes(1);
+    expect(result.normalizedContent).toBe(prose);
+  });
+
+  it("preserves legitimate English prose that starts with 'I will'", async () => {
+    const agent = createAgent();
+    const prose = "I will wait here until dawn.\nThe shutters rattled in the wind.";
+    const chatSpy = vi.spyOn(BaseAgent.prototype as never, "chat").mockResolvedValue({
+      content: prose,
+      usage: ZERO_USAGE,
+    });
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 220,
+      softMin: 190,
+      softMax: 250,
+      hardMin: 160,
+      hardMax: 280,
+      countingMode: "en_words",
+      normalizeMode: "compress",
+    });
+    const draft = "Original text. ".repeat(80);
+
+    const result = await agent.normalizeChapter({
+      chapterContent: draft,
+      lengthSpec,
+    });
+
+    expect(chatSpy).toHaveBeenCalledTimes(1);
+    expect(result.normalizedContent).toBe(prose);
+  });
+});

package/inkos/packages/core/src/__tests__/list-models.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { listModelsForService, resolveServiceModelsBaseUrl } from "../llm/service-presets.js";
+
+describe("listModelsForService (B8)", () => {
+  const originalEnv = process.env.INKOS_LLM_MODEL;
+  const originalFetch = global.fetch;
+
+  beforeEach(() => {
+    delete process.env.INKOS_LLM_MODEL;
+  });
+
+  afterEach(() => {
+    if (originalEnv) process.env.INKOS_LLM_MODEL = originalEnv;
+    else delete process.env.INKOS_LLM_MODEL;
+    global.fetch = originalFetch;
+  });
+
+  it("anthropic service 无 apikey 时返回 provider 内置 enabled 子集", async () => {
+    const models = await listModelsForService("anthropic");
+    expect(models.length).toBeGreaterThan(0);
+    expect(models.some((m) => m.id === "claude-sonnet-4-6")).toBe(true);
+    const sonnet = models.find((m) => m.id === "claude-sonnet-4-6");
+    expect(sonnet?.maxOutput).toBe(64_000);
+    expect(sonnet?.contextWindow).toBe(1_000_000);
+  });
+
+  it("google service 的文本模型列表不包含 image preview 模型", async () => {
+    const models = await listModelsForService("google");
+    expect(models.some((m) => m.id === "gemini-2.5-flash")).toBe(true);
+    expect(models.some((m) => m.id.includes("image"))).toBe(false);
+  });
+
+  it("custom service 走 live probe + bank 补元数据", async () => {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ data: [{ id: "gpt-4o" }, { id: "my-proxy-model" }] }),
+    } as any) as typeof fetch;
+    const models = await listModelsForService("custom", "sk-test", "https://myproxy.example/v1");
+    // gpt-4o 命中 openai provider，拿到元数据
+    const gpt = models.find((m) => m.id === "gpt-4o");
+    expect(gpt).toBeDefined();
+    expect(gpt?.maxOutput).toBe(4096);
+    // 自定义 id 没元数据也保留
+    expect(models.some((m) => m.id === "my-proxy-model")).toBe(true);
+  });
+
+  it("ollama 无 apiKey 时也探测本地 /models 并保留本地动态模型", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ data: [{ id: "qwen3.6:35b-a3b" }] }),
+    } as any);
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const models = await listModelsForService("ollama");
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "http://localhost:11434/v1/models",
+      expect.any(Object),
+    );
+    expect(models.some((m) => m.id === "qwen3.6:35b-a3b")).toBe(true);
+  });
+
+  it("R4：env 补丁已删除 — INKOS_LLM_MODEL 不再污染跨 service 菜单", async () => {
+    process.env.INKOS_LLM_MODEL = "my-secret-model";
+    const models = await listModelsForService("anthropic");
+    // my-secret-model 不在 anthropic bank → 不应该出现
+    expect(models.some((m) => m.id === "my-secret-model")).toBe(false);
+  });
+
+  it("live 挂了降级到 provider 内置 models（没有 fetch 错误 crash）", async () => {
+    global.fetch = vi.fn().mockRejectedValue(new Error("ECONNREFUSED")) as typeof fetch;
+    const models = await listModelsForService("anthropic", "sk-test");
+    expect(models.length).toBeGreaterThan(0);
+    expect(models.some((m) => m.id === "claude-sonnet-4-6")).toBe(true);
+  });
+
+  it("bailian 不用 OpenAI 兼容 /models 污染 Anthropic 通道模型列表", async () => {
+    const fetchMock = vi.fn().mockImplementation(async (input: string | URL | Request) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+      if (url === "https://dashscope.aliyuncs.com/compatible-mode/v1/models") {
+        return {
+          ok: true,
+          json: async () => ({ data: [{ id: "kimi-k2.6" }, { id: "deepseek-v3.2" }] }),
+        };
+      }
+      return {
+        ok: false,
+        json: async () => ({ data: [] }),
+      };
+    });
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const models = await listModelsForService("bailian", "sk-test");
+
+    expect(resolveServiceModelsBaseUrl("bailian")).toBe("https://dashscope.aliyuncs.com/apps/anthropic");
+    expect(fetchMock).not.toHaveBeenCalledWith(
+      "https://dashscope.aliyuncs.com/compatible-mode/v1/models",
+      expect.any(Object),
+    );
+    expect(models.some((m) => m.id === "qwen-turbo")).toBe(true);
+    expect(models.some((m) => m.id === "kimi-k2.6")).toBe(false);
+    expect(models.some((m) => m.id === "deepseek-v3.2")).toBe(false);
+  });
+
+  it("未知 service 返回空数组", async () => {
+    const models = await listModelsForService("nonexistent-xyz");
+    expect(models).toEqual([]);
+  });
+});

package/inkos/packages/core/src/__tests__/llm-env.test.ts

@@ -0,0 +1,31 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { loadLLMEnvLayers } from "../utils/llm-env.js";
+
+describe("loadLLMEnvLayers", () => {
+  let root = "";
+  const previousGoogleKey = process.env.GOOGLE_API_KEY;
+
+  afterEach(async () => {
+    if (previousGoogleKey === undefined) delete process.env.GOOGLE_API_KEY;
+    else process.env.GOOGLE_API_KEY = previousGoogleKey;
+
+    if (root) {
+      await rm(root, { recursive: true, force: true });
+      root = "";
+    }
+  });
+
+  it("exposes project .env variables through process.env for apiKeyEnv consumers", async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-llm-env-"));
+    delete process.env.GOOGLE_API_KEY;
+    await writeFile(join(root, ".env"), "GOOGLE_API_KEY=sk-from-project-env\n", "utf-8");
+
+    const layers = await loadLLMEnvLayers(root);
+
+    expect(layers.project.GOOGLE_API_KEY).toBe("sk-from-project-env");
+    expect(process.env.GOOGLE_API_KEY).toBe("sk-from-project-env");
+  });
+});

package/inkos/packages/core/src/__tests__/logger.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  createLogger,
+  createStderrSink,
+  createJsonLineSink,
+  nullSink,
+  type LogEntry,
+} from "../utils/logger.js";
+import { createStreamMonitor } from "../llm/provider.js";
+
+describe("createStderrSink", () => {
+  const originalWrite = process.stderr.write;
+  const captured: string[] = [];
+
+  beforeEach(() => {
+    captured.length = 0;
+    process.stderr.write = ((chunk: unknown) => {
+      captured.push(String(chunk));
+      return true;
+    }) as typeof process.stderr.write;
+  });
+
+  afterEach(() => {
+    process.stderr.write = originalWrite;
+  });
+
+  it("filters entries below minLevel", () => {
+    const sink = createStderrSink({ minLevel: "warn", enableColors: false });
+    const logger = createLogger({ tag: "test", sinks: [sink] });
+
+    logger.info("should be filtered");
+    expect(captured).toHaveLength(0);
+
+    logger.warn("should pass");
+    expect(captured).toHaveLength(1);
+    expect(captured[0]).toContain("should pass");
+  });
+
+  it("includes ANSI escape codes when enableColors=true", () => {
+    const sink = createStderrSink({ minLevel: "info", enableColors: true });
+    const logger = createLogger({ tag: "color-test", sinks: [sink] });
+
+    logger.info("colored message");
+    expect(captured[0]).toContain("\x1b[36m"); // cyan for info
+    expect(captured[0]).toContain("\x1b[0m");  // reset
+  });
+
+  it("omits ANSI escape codes when enableColors=false", () => {
+    const sink = createStderrSink({ minLevel: "info", enableColors: false });
+    const logger = createLogger({ tag: "no-color", sinks: [sink] });
+
+    logger.info("plain message");
+    expect(captured[0]).not.toContain("\x1b[");
+    expect(captured[0]).toContain("plain message");
+    expect(captured[0]).toContain("[no-color]");
+  });
+});
+
+describe("createJsonLineSink", () => {
+  it("outputs parseable JSON, one entry per line", () => {
+    const chunks: string[] = [];
+    const writable = {
+      write(data: string) {
+        chunks.push(data);
+        return true;
+      },
+    } as unknown as NodeJS.WritableStream;
+
+    const sink = createJsonLineSink(writable);
+    const logger = createLogger({ tag: "json-test", sinks: [sink] });
+
+    logger.info("first message");
+    logger.warn("second message", { key: "value" });
+
+    expect(chunks).toHaveLength(2);
+
+    const entry1 = JSON.parse(chunks[0]!) as LogEntry;
+    expect(entry1.level).toBe("info");
+    expect(entry1.tag).toBe("json-test");
+    expect(entry1.message).toBe("first message");
+    expect(entry1.timestamp).toBeTruthy();
+
+    const entry2 = JSON.parse(chunks[1]!) as LogEntry;
+    expect(entry2.level).toBe("warn");
+    expect(entry2.ctx).toEqual({ key: "value" });
+  });
+});
+
+describe("nullSink", () => {
+  it("does not throw", () => {
+    const logger = createLogger({ tag: "null-test", sinks: [nullSink] });
+    expect(() => {
+      logger.debug("ignored");
+      logger.info("ignored");
+      logger.warn("ignored");
+      logger.error("ignored");
+    }).not.toThrow();
+  });
+});
+
+describe("Logger.child()", () => {
+  it("replaces tag and merges context", () => {
+    const entries: LogEntry[] = [];
+    const sink = {
+      write(entry: LogEntry) {
+        entries.push(entry);
+      },
+    };
+
+    const parent = createLogger({
+      tag: "parent",
+      sinks: [sink],
+      baseCtx: { parentKey: "pv" },
+    });
+
+    const child = parent.child("child", { childKey: "cv" });
+    child.info("from child");
+
+    expect(entries).toHaveLength(1);
+    expect(entries[0]!.tag).toBe("child");
+    expect(entries[0]!.ctx).toEqual({ parentKey: "pv", childKey: "cv" });
+  });
+});
+
+describe("createStreamMonitor", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("calls onProgress at interval with correct counts", () => {
+    const calls: Array<{ totalChars: number; chineseChars: number; status: string }> = [];
+    const monitor = createStreamMonitor((progress) => {
+      calls.push({
+        totalChars: progress.totalChars,
+        chineseChars: progress.chineseChars,
+        status: progress.status,
+      });
+    }, 1000);
+
+    monitor.onChunk("hello");
+    monitor.onChunk("世界你好");
+
+    // Advance past one interval
+    vi.advanceTimersByTime(1000);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.totalChars).toBe(9); // 5 + 4
+    expect(calls[0]!.chineseChars).toBe(4);
+    expect(calls[0]!.status).toBe("streaming");
+
+    // More chunks
+    monitor.onChunk("abc");
+    vi.advanceTimersByTime(1000);
+    expect(calls).toHaveLength(2);
+    expect(calls[1]!.totalChars).toBe(12);
+
+    monitor.stop();
+    // stop() emits a final "done" event
+    expect(calls).toHaveLength(3);
+    expect(calls[2]!.status).toBe("done");
+    expect(calls[2]!.totalChars).toBe(12);
+  });
+
+  it("works without onProgress (undefined)", () => {
+    const monitor = createStreamMonitor(undefined);
+    expect(() => {
+      monitor.onChunk("test data");
+      monitor.onChunk("更多数据");
+      monitor.stop();
+    }).not.toThrow();
+  });
+});