@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/cli/src/__tests__/studio-runtime.test.ts

@@ -0,0 +1,142 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const accessMock = vi.fn();
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliPackageRoot = resolve(testDir, "..", "..");
+
+vi.mock("node:fs/promises", () => ({
+  access: accessMock,
+}));
+
+describe("studio runtime resolution", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  const tsSourceEntry = join("/repo", "packages", "studio", "src", "api", "index.ts");
+  const tsxLoader = join("/repo", "packages", "studio", "node_modules", "tsx", "dist", "loader.mjs");
+  const projectBuiltEntry = join(
+    "/repo",
+    "test-project",
+    "node_modules",
+    "@actalk",
+    "inkos-studio",
+    "dist",
+    "api",
+    "index.js",
+  );
+  const cliBuiltEntry = join(
+    cliPackageRoot,
+    "node_modules",
+    "@actalk",
+    "inkos-studio",
+    "dist",
+    "api",
+    "index.js",
+  );
+
+  it("prefers the repository-local tsx loader for monorepo sources", async () => {
+    accessMock.mockImplementation(async (path: string) => {
+      if (path === tsSourceEntry || path === tsxLoader) {
+        return;
+      }
+      throw new Error(`missing: ${path}`);
+    });
+
+    const { resolveStudioLaunch } = await import("../commands/studio.js");
+    const launch = await resolveStudioLaunch("/repo/test-project");
+
+    expect(launch).toEqual({
+      studioEntry: tsSourceEntry,
+      command: "node",
+      args: ["--import", tsxLoader, tsSourceEntry, "/repo/test-project"],
+    });
+  });
+
+  it("uses a file URL for the tsx loader on Windows absolute paths", async () => {
+    const { toNodeImportSpecifier } = await import("../commands/studio.js");
+    expect(toNodeImportSpecifier("D:\\repo\\packages\\studio\\node_modules\\tsx\\dist\\loader.mjs"))
+      .toBe("file:///D:/repo/packages/studio/node_modules/tsx/dist/loader.mjs");
+  });
+
+  it("finds monorepo packages/studio sources from a project directory", async () => {
+    accessMock.mockImplementation(async (path: string) => {
+      if (path === tsSourceEntry) {
+        return;
+      }
+      throw new Error(`missing: ${path}`);
+    });
+
+    const { resolveStudioLaunch } = await import("../commands/studio.js");
+    const launch = await resolveStudioLaunch("/repo/test-project");
+
+    expect(launch).toEqual({
+      studioEntry: tsSourceEntry,
+      command: "npx",
+      args: ["tsx", tsSourceEntry, "/repo/test-project"],
+    });
+  });
+
+  it("uses node for built JavaScript entries", async () => {
+    accessMock.mockImplementation(async (path: string) => {
+      if (path === projectBuiltEntry) {
+        return;
+      }
+      throw new Error(`missing: ${path}`);
+    });
+
+    const { resolveStudioLaunch } = await import("../commands/studio.js");
+    const launch = await resolveStudioLaunch("/repo/test-project");
+
+    expect(launch).toEqual({
+      studioEntry: projectBuiltEntry,
+      command: "node",
+      args: [projectBuiltEntry, "/repo/test-project"],
+    });
+  });
+
+  it("falls back to the CLI installation's bundled studio runtime", async () => {
+    accessMock.mockImplementation(async (path: string) => {
+      if (path === cliBuiltEntry) {
+        return;
+      }
+      throw new Error(`missing: ${path}`);
+    });
+
+    const { resolveStudioLaunch } = await import("../commands/studio.js");
+    const launch = await resolveStudioLaunch("/repo/test-project");
+
+    expect(launch).toEqual({
+      studioEntry: cliBuiltEntry,
+      command: "node",
+      args: [cliBuiltEntry, "/repo/test-project"],
+    });
+  });
+
+  it("returns a browser launch spec for macOS", async () => {
+    const { resolveBrowserLaunch } = await import("../commands/studio.js");
+    expect(resolveBrowserLaunch("darwin", "http://localhost:4567")).toEqual({
+      command: "open",
+      args: ["http://localhost:4567"],
+    });
+  });
+
+  it("returns a browser launch spec for Windows", async () => {
+    const { resolveBrowserLaunch } = await import("../commands/studio.js");
+    expect(resolveBrowserLaunch("win32", "http://localhost:4567")).toEqual({
+      command: "cmd",
+      args: ["/c", "start", "", "http://localhost:4567"],
+    });
+  });
+
+  it("returns a browser launch spec for Linux", async () => {
+    const { resolveBrowserLaunch } = await import("../commands/studio.js");
+    expect(resolveBrowserLaunch("linux", "http://localhost:4567")).toEqual({
+      command: "xdg-open",
+      args: ["http://localhost:4567"],
+    });
+  });
+});

package/inkos/packages/cli/src/__tests__/studio.test.ts

@@ -0,0 +1,87 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { join } from "node:path";
+
+const accessMock = vi.fn();
+const spawnMock = vi.fn(() => ({
+  on: vi.fn(),
+}));
+const logMock = vi.fn();
+const logErrorMock = vi.fn();
+
+vi.mock("node:fs/promises", () => ({
+  access: accessMock,
+  mkdir: vi.fn(),
+  readFile: vi.fn(async () => ""),
+  writeFile: vi.fn(),
+}));
+
+vi.mock("node:child_process", () => ({
+  spawn: spawnMock,
+}));
+
+vi.mock("../utils.js", () => ({
+  findProjectRoot: vi.fn(() => "/project"),
+  log: logMock,
+  logError: logErrorMock,
+}));
+
+describe("studio command", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  it("launches TypeScript sources through tsx in monorepo mode", async () => {
+    const tsEntry = join("/project", "packages", "studio", "src", "api", "index.ts");
+    accessMock.mockImplementation(async (path: string) => {
+      if (path === tsEntry) {
+        return;
+      }
+      throw new Error(`missing: ${path}`);
+    });
+
+    const { createStudioCommand } = await import("../commands/studio.js");
+    await createStudioCommand().parseAsync(["node", "studio", "--port", "9001"]);
+
+    expect(spawnMock).toHaveBeenCalledWith(
+      "npx",
+      ["tsx", tsEntry, "/project"],
+      expect.objectContaining({
+        cwd: "/project",
+        stdio: "inherit",
+        env: expect.objectContaining({ INKOS_STUDIO_PORT: "9001" }),
+      }),
+    );
+  });
+
+  it("launches built JavaScript entries through node", async () => {
+    const jsEntry = join(
+      "/project",
+      "node_modules",
+      "@actalk",
+      "inkos-studio",
+      "dist",
+      "api",
+      "index.js",
+    );
+    accessMock.mockImplementation(async (path: string) => {
+      if (path === jsEntry) {
+        return;
+      }
+      throw new Error(`missing: ${path}`);
+    });
+
+    const { createStudioCommand } = await import("../commands/studio.js");
+    await createStudioCommand().parseAsync(["node", "studio", "--port", "4567"]);
+
+    expect(spawnMock).toHaveBeenCalledWith(
+      "node",
+      [jsEntry, "/project"],
+      expect.objectContaining({
+        cwd: "/project",
+        stdio: "inherit",
+        env: expect.objectContaining({ INKOS_STUDIO_PORT: "4567" }),
+      }),
+    );
+  });
+});

package/inkos/packages/cli/src/__tests__/tui-activity-state.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { describeActivityState } from "../tui/activity-state.js";
+import { getTuiCopy } from "../tui/i18n.js";
+import { WARM_ACCENT } from "../tui/theme.js";
+
+describe("tui activity state", () => {
+  it("maps chat-like intents to thinking", () => {
+    const copy = getTuiCopy("en");
+    expect(describeActivityState("chat", copy)).toMatchObject({ label: "thinking", accent: WARM_ACCENT });
+    expect(describeActivityState("explain_status", copy)).toMatchObject({ label: "checking", accent: WARM_ACCENT });
+  });
+
+  it("maps writing and review intents to task-specific labels", () => {
+    const zhCopy = getTuiCopy("zh-CN");
+    expect(describeActivityState("write_next", zhCopy)).toMatchObject({ label: "写作中", accent: WARM_ACCENT });
+    expect(describeActivityState("revise_chapter", zhCopy)).toMatchObject({ label: "审阅中", accent: WARM_ACCENT });
+    expect(describeActivityState("rewrite_chapter", zhCopy)).toMatchObject({ label: "审阅中", accent: WARM_ACCENT });
+    expect(describeActivityState("chat", zhCopy).intervalMs).toBeGreaterThanOrEqual(180);
+  });
+});

package/inkos/packages/cli/src/__tests__/tui-agent-session.test.ts

@@ -0,0 +1,213 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createProjectSession, loadProjectSession } from "../tui/session-store.js";
+
+const {
+  runAgentSessionMock,
+  loadConfigMock,
+  buildPipelineConfigMock,
+} = vi.hoisted(() => ({
+  runAgentSessionMock: vi.fn(),
+  loadConfigMock: vi.fn(),
+  buildPipelineConfigMock: vi.fn(),
+}));
+
+vi.mock("@actalk/inkos-core", async () => {
+  const actual = await vi.importActual<typeof import("@actalk/inkos-core")>("@actalk/inkos-core");
+  class PipelineRunnerMock {
+    constructor(_config: unknown) {}
+    async initBook(_book: unknown, _options?: unknown) {}
+    async writeNextChapter(_bookId: string) {
+      return {
+        chapterNumber: 1,
+        title: "雨夜",
+        wordCount: 1200,
+        status: "ready-for-review",
+      };
+    }
+  }
+  return {
+    ...actual,
+    createLLMClient: vi.fn(() => ({
+      _piModel: {
+        id: "gpt-5.4",
+        name: "gpt-5.4",
+        api: "openai-completions",
+        provider: "openai",
+        baseUrl: "https://right.codes/codex/v1",
+        reasoning: false,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 128000,
+        maxTokens: 8192,
+      },
+      _apiKey: "secret",
+    })),
+    PipelineRunner: PipelineRunnerMock as any,
+    runAgentSession: runAgentSessionMock,
+  };
+});
+
+vi.mock("../utils.js", () => ({
+  loadConfig: loadConfigMock,
+  buildPipelineConfig: buildPipelineConfigMock,
+}));
+
+describe("tui agent session bridge", () => {
+  let projectRoot: string;
+
+  beforeEach(async () => {
+    projectRoot = await mkdtemp(join(tmpdir(), "inkos-tui-agent-"));
+    vi.clearAllMocks();
+    loadConfigMock.mockResolvedValue({
+      llm: {
+        provider: "openai",
+        model: "gpt-5.4",
+        baseUrl: "https://right.codes/codex/v1",
+        apiFormat: "chat",
+        stream: false,
+      },
+      language: "zh",
+    });
+    buildPipelineConfigMock.mockReturnValue({});
+  });
+
+  afterEach(async () => {
+    await rm(projectRoot, { recursive: true, force: true });
+  });
+
+  it("runs agent chat and persists raw assistant output into the tui session", async () => {
+    runAgentSessionMock.mockResolvedValue({
+      responseText: "这是 agent 直接返回的回复。",
+      messages: [
+        { role: "user", content: "帮我整理这一章" },
+        { role: "assistant", content: "这是 agent 直接返回的回复。", thinking: "internal" },
+      ],
+    });
+
+    const { processTuiAgentInput } = await import("../tui/agent-input.js");
+    const session = {
+      ...createProjectSession(projectRoot),
+      activeBookId: "harbor",
+      messages: [
+        { role: "user" as const, content: "旧问题", timestamp: 1 },
+        { role: "assistant" as const, content: "旧回答", timestamp: 2 },
+      ],
+    };
+
+    const result = await processTuiAgentInput({
+      projectRoot,
+      input: "帮我整理这一章",
+      session,
+      activeBookId: "harbor",
+    });
+
+    expect(runAgentSessionMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sessionId: session.sessionId,
+        bookId: "harbor",
+        projectRoot,
+      }),
+      "帮我整理这一章",
+      [
+        { role: "user", content: "旧问题" },
+        { role: "assistant", content: "旧回答" },
+      ],
+    );
+    expect(result.responseText).toBe("这是 agent 直接返回的回复。");
+    expect(result.session.messages.at(-1)).toEqual(expect.objectContaining({
+      role: "assistant",
+      content: "这是 agent 直接返回的回复。",
+      thinking: "internal",
+    }));
+
+    const persisted = await loadProjectSession(projectRoot);
+    expect(persisted.messages.at(-1)).toEqual(expect.objectContaining({
+      role: "assistant",
+      content: "这是 agent 直接返回的回复。",
+    }));
+  });
+
+  it("stores the created book from architect tool results as the active TUI book", async () => {
+    runAgentSessionMock.mockResolvedValue({
+      responseText: "《夜港》已创建成功。",
+      messages: [
+        {
+          role: "toolResult",
+          details: { kind: "book_created", bookId: "night-harbor", title: "夜港" },
+        },
+        { role: "assistant", content: "《夜港》已创建成功。" },
+      ],
+    });
+
+    const { processTuiAgentInput } = await import("../tui/agent-input.js");
+    const session = createProjectSession(projectRoot);
+
+    const result = await processTuiAgentInput({
+      projectRoot,
+      input: "创建《夜港》",
+      session,
+    });
+
+    expect(result.session.activeBookId).toBe("night-harbor");
+    const persisted = await loadProjectSession(projectRoot);
+    expect(persisted.activeBookId).toBe("night-harbor");
+  });
+
+  it("routes explicit create-book instructions directly to shared book creation", async () => {
+    const initBookSpy = vi.spyOn(
+      (await import("@actalk/inkos-core")).PipelineRunner.prototype as any,
+      "initBook",
+    );
+    const { processTuiAgentInput } = await import("../tui/agent-input.js");
+    const session = createProjectSession(projectRoot);
+
+    const result = await processTuiAgentInput({
+      projectRoot,
+      input: "创建一本10章中文都市悬疑短篇，标题《雾灯小巷》，目标平台番茄，每章约1200字。信息足够，请直接建书。",
+      session,
+    });
+
+    expect(runAgentSessionMock).not.toHaveBeenCalled();
+    expect(initBookSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: "雾灯小巷",
+        title: "雾灯小巷",
+        genre: "urban",
+        platform: "tomato",
+        targetChapters: 10,
+        chapterWordCount: 1200,
+      }),
+      expect.objectContaining({
+        externalContext: expect.stringContaining("雾灯小巷"),
+      }),
+    );
+    expect(result.session.activeBookId).toBe("雾灯小巷");
+    expect(result.responseText).toContain("已创建");
+    const persisted = await loadProjectSession(projectRoot);
+    expect(persisted.activeBookId).toBe("雾灯小巷");
+  });
+
+  it("routes write-next instructions directly to the writer when a book is active", async () => {
+    const { processTuiAgentInput } = await import("../tui/agent-input.js");
+    const session = {
+      ...createProjectSession(projectRoot),
+      activeBookId: "night-harbor",
+    };
+
+    const result = await processTuiAgentInput({
+      projectRoot,
+      input: "写第1章",
+      session,
+    });
+
+    expect(runAgentSessionMock).not.toHaveBeenCalled();
+    expect(result.responseText).toContain("第 1 章");
+    expect(result.responseText).toContain("雨夜");
+    const persisted = await loadProjectSession(projectRoot);
+    expect(persisted.activeBookId).toBe("night-harbor");
+    expect(persisted.activeChapterNumber).toBe(1);
+  });
+});

package/inkos/packages/cli/src/__tests__/tui-chat-depth.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { resolveChatDepthProfile } from "../tui/chat-depth.js";
+
+describe("tui chat depth", () => {
+  it("maps light/normal/deep to stable chat options", () => {
+    expect(resolveChatDepthProfile("light")).toEqual({
+      depth: "light",
+      temperature: 0.3,
+      maxTokens: 160,
+      label: "light",
+    });
+    const normal = resolveChatDepthProfile("normal");
+    expect(normal).toEqual({
+      depth: "normal",
+      temperature: 0.4,
+      label: "normal",
+    });
+    // normal depth must NOT include maxTokens — let the model decide
+    expect(normal.maxTokens).toBeUndefined();
+    expect(resolveChatDepthProfile("deep")).toEqual({
+      depth: "deep",
+      temperature: 0.45,
+      maxTokens: 420,
+      label: "deep",
+    });
+  });
+});

package/inkos/packages/cli/src/__tests__/tui-chat-draft.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import type { InteractionSession } from "@actalk/inkos-core";
+import {
+  appendStreamingAssistantChunk,
+  createOptimisticUserMessageSession,
+} from "../tui/chat-draft.js";
+
+function createSession(): InteractionSession {
+  return {
+    sessionId: "session-1",
+    projectRoot: "/tmp/inkos-demo",
+    activeBookId: "harbor",
+    automationMode: "semi",
+    messages: [],
+    events: [],
+    draftRounds: [],
+  };
+}
+
+describe("tui chat draft", () => {
+  it("optimistically appends the user message before the model returns", () => {
+    const next = createOptimisticUserMessageSession(createSession(), "continue current book", 100);
+    expect(next.messages).toEqual([
+      {
+        role: "user",
+        content: "continue current book",
+        timestamp: 100,
+      },
+    ]);
+  });
+
+  it("creates and extends a streaming assistant draft message", () => {
+    const afterUser = createOptimisticUserMessageSession(createSession(), "hi", 100);
+    const afterFirstChunk = appendStreamingAssistantChunk(afterUser, "hello", 101);
+    expect(afterFirstChunk.messages.at(-1)).toEqual({
+      role: "assistant",
+      content: "hello",
+      timestamp: 101,
+    });
+
+    const afterSecondChunk = appendStreamingAssistantChunk(afterFirstChunk, " world", 101);
+    expect(afterSecondChunk.messages.at(-1)?.content).toBe("hello world");
+  });
+});

package/inkos/packages/cli/src/__tests__/tui-command.test.ts

@@ -0,0 +1,86 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { realpathSync } from "node:fs";
+import { createProgram } from "../program.js";
+
+describe("tui command", () => {
+  const originalArgv = process.argv;
+  const originalCwd = process.cwd();
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "inkos-default-studio-"));
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.argv = originalArgv;
+    process.chdir(originalCwd);
+    vi.restoreAllMocks();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it("launches Studio when no subcommand is provided", async () => {
+    const launchStudio = vi.fn(async () => {});
+    const program = createProgram({ launchStudio });
+
+    await program.parseAsync([], { from: "user" });
+
+    expect(launchStudio).toHaveBeenCalledTimes(1);
+    expect(launchStudio).toHaveBeenCalledWith(process.cwd(), "4567");
+  });
+
+  it("auto-initializes a minimal project before launching Studio by default", async () => {
+    const launchStudio = vi.fn(async () => {});
+    const program = createProgram({ launchStudio });
+
+    await program.parseAsync([], { from: "user" });
+
+    const config = JSON.parse(await readFile(join(tempDir, "inkos.json"), "utf-8"));
+    expect(config.name).toMatch(/^inkos-default-studio-/);
+    expect(config.llm.configSource).toBe("studio");
+    expect(config.llm.model).toBe("");
+    expect(config.llm.baseUrl).toBe("");
+    expect(launchStudio).toHaveBeenCalledTimes(1);
+    const [calledRoot, calledPort] = launchStudio.mock.calls[0] as unknown as [string, string];
+    expect(realpathSync(calledRoot)).toBe(realpathSync(tempDir));
+    expect(calledPort).toBe("4567");
+  });
+
+  it("does not overwrite an existing .env during automatic Studio init", async () => {
+    await writeFile(join(tempDir, ".env"), "EXISTING_ENV=1\n", "utf-8");
+    const launchStudio = vi.fn(async () => {});
+    const program = createProgram({ launchStudio });
+
+    await program.parseAsync([], { from: "user" });
+
+    await expect(readFile(join(tempDir, ".env"), "utf-8")).resolves.toBe("EXISTING_ENV=1\n");
+  });
+
+  it("launches the TUI when the explicit tui command is used", async () => {
+    const launchTui = vi.fn(async () => {});
+    const launchStudio = vi.fn(async () => {});
+    const program = createProgram({ launchTui, launchStudio });
+
+    await program.parseAsync(["tui"], { from: "user" });
+
+    expect(launchTui).toHaveBeenCalledTimes(1);
+    expect(launchStudio).not.toHaveBeenCalled();
+  });
+
+  it("auto-initializes a minimal project before launching the explicit studio command", async () => {
+    const launchStudio = vi.fn(async () => {});
+    const program = createProgram({ launchStudio });
+
+    await program.parseAsync(["studio"], { from: "user" });
+
+    const config = JSON.parse(await readFile(join(tempDir, "inkos.json"), "utf-8"));
+    expect(config.llm.configSource).toBe("studio");
+    expect(launchStudio).toHaveBeenCalledTimes(1);
+    const [calledRoot, calledPort] = launchStudio.mock.calls[0] as unknown as [string, string];
+    expect(realpathSync(calledRoot)).toBe(realpathSync(tempDir));
+    expect(calledPort).toBe("4567");
+  });
+});

package/inkos/packages/cli/src/__tests__/tui-composer-caret.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { resolveComposerCaretState } from "../tui/composer-caret.js";
+
+describe("tui composer caret", () => {
+  it("keeps the empty composer caret visible without animation", () => {
+    expect(resolveComposerCaretState({
+      inputValue: "",
+      isSubmitting: false,
+      blinkTick: 0,
+    })).toEqual({
+      visible: true,
+      shouldAnimate: false,
+    });
+  });
+
+  it("keeps the typed composer caret visible without animation", () => {
+    expect(resolveComposerCaretState({
+      inputValue: "continue",
+      isSubmitting: false,
+      blinkTick: 0,
+    })).toEqual({
+      visible: true,
+      shouldAnimate: false,
+    });
+
+    expect(resolveComposerCaretState({
+      inputValue: "continue",
+      isSubmitting: false,
+      blinkTick: 1,
+    })).toEqual({
+      visible: true,
+      shouldAnimate: false,
+    });
+  });
+
+  it("hides the caret while submitting", () => {
+    expect(resolveComposerCaretState({
+      inputValue: "continue",
+      isSubmitting: true,
+      blinkTick: 0,
+    })).toEqual({
+      visible: false,
+      shouldAnimate: false,
+    });
+  });
+});