@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/core/src/__tests__/pipeline-agent.test.ts

@@ -0,0 +1,354 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AGENT_TOOLS, executeAgentTool } from "../pipeline/agent.js";
+import { PipelineRunner, StateManager, type PipelineConfig } from "../index.js";
+import { PlannerAgent } from "../agents/planner.js";
+
+describe("agent pipeline tools", () => {
+  let root: string;
+  let state: StateManager;
+  let pipeline: PipelineRunner;
+  let config: PipelineConfig;
+  let bookId: string;
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-agent-tools-"));
+    state = new StateManager(root);
+    bookId = "agent-book";
+
+    config = {
+      client: {
+        provider: "openai",
+        apiFormat: "chat",
+        stream: false,
+        defaults: {
+          temperature: 0.7,
+          maxTokens: 4096,
+          thinkingBudget: 0,
+          extra: {},
+        },
+      },
+      model: "test-model",
+      projectRoot: root,
+      inputGovernanceMode: "v2",
+    };
+
+    pipeline = new PipelineRunner(config);
+
+    await state.saveBookConfig(bookId, {
+      id: bookId,
+      title: "Agent Book",
+      platform: "tomato",
+      genre: "other",
+      status: "active",
+      targetChapters: 20,
+      chapterWordCount: 3000,
+      createdAt: "2026-03-22T00:00:00.000Z",
+      updatedAt: "2026-03-22T00:00:00.000Z",
+    });
+
+    const storyDir = join(state.bookDir(bookId), "story");
+    await mkdir(join(storyDir, "runtime"), { recursive: true });
+    await mkdir(join(state.bookDir(bookId), "chapters"), { recursive: true });
+    await writeFile(join(state.bookDir(bookId), "chapters", "index.json"), "[]", "utf-8");
+
+    vi.spyOn(PlannerAgent.prototype, "planChapter").mockImplementation(async (input) => {
+      const chapterNumber = input.chapterNumber;
+      // Try to read the local override from current_focus.md, mirroring the real planner logic
+      let goal = input.externalContext ?? "test goal";
+      try {
+        const { readFile: readFs } = await import("node:fs/promises");
+        const focusContent = await readFs(join(input.bookDir, "story", "current_focus.md"), "utf-8");
+        const overrideMatch = focusContent.match(/## Local Override\s*\n+([^\n#]+)/);
+        if (overrideMatch?.[1]?.trim()) {
+          goal = overrideMatch[1].trim();
+        }
+      } catch { /* ignore missing file */ }
+      const memo = {
+        chapter: chapterNumber,
+        goal,
+        isGoldenOpening: false,
+        body: "",
+        threadRefs: [] as string[],
+      };
+      const intentMarkdown = [
+        "# Chapter Intent",
+        "",
+        "## Goal",
+        goal,
+      ].join("\n");
+      const { mkdir: mkdirFs, writeFile: writeFileFs } = await import("node:fs/promises");
+      const runtimeDir = join(input.bookDir, "story", "runtime");
+      await mkdirFs(runtimeDir, { recursive: true });
+      const runtimePath = join(runtimeDir, `chapter-${String(chapterNumber).padStart(4, "0")}.intent.md`);
+      await writeFileFs(runtimePath, intentMarkdown, "utf-8");
+      return {
+        intent: {
+          chapter: chapterNumber,
+          goal,
+          mustKeep: [],
+          mustAvoid: [],
+          styleEmphasis: [],
+        },
+        memo,
+        intentMarkdown,
+        plannerInputs: [runtimePath],
+        runtimePath,
+      };
+    });
+
+    await Promise.all([
+      writeFile(join(storyDir, "author_intent.md"), "# Author Intent\n\nKeep the story centered on the mentor conflict.\n", "utf-8"),
+      writeFile(join(storyDir, "current_focus.md"), "# Current Focus\n\nBring focus back to the mentor conflict.\n", "utf-8"),
+      writeFile(join(storyDir, "story_bible.md"), "# Story Bible\n\n- The jade seal cannot be destroyed.\n", "utf-8"),
+      writeFile(join(storyDir, "volume_outline.md"), "# Volume Outline\n\n## Chapter 1\nTrack the merchant guild trail.\n", "utf-8"),
+      writeFile(join(storyDir, "book_rules.md"), "---\nprohibitions:\n  - Do not reveal the mastermind\n---\n\n# Book Rules\n", "utf-8"),
+      writeFile(join(storyDir, "current_state.md"), "# Current State\n\n- Lin Yue still hides the broken oath token.\n", "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "# Pending Hooks\n\n- Why the mentor vanished after the trial.\n", "utf-8"),
+    ]);
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("registers the input governance tools", () => {
+    const toolNames = AGENT_TOOLS.map((tool) => tool.name);
+
+    expect(toolNames).toContain("plan_chapter");
+    expect(toolNames).toContain("compose_chapter");
+    expect(toolNames).toContain("update_author_intent");
+    expect(toolNames).toContain("update_current_focus");
+  });
+
+  it("plans and composes chapters through the agent tool surface", async () => {
+    const planResult = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "plan_chapter",
+      { bookId, guidance: "Ignore the guild chase and focus on the mentor conflict." },
+    ));
+
+    expect(planResult.intentPath).toBe("story/runtime/chapter-0001.intent.md");
+
+    const composeResult = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "compose_chapter",
+      { bookId, guidance: "Ignore the guild chase and focus on the mentor conflict." },
+    ));
+
+    expect(composeResult.contextPath).toBe("story/runtime/chapter-0001.context.json");
+    expect(composeResult.ruleStackPath).toBe("story/runtime/chapter-0001.rule-stack.yaml");
+    expect(composeResult.tracePath).toBe("story/runtime/chapter-0001.trace.json");
+  });
+
+  it("updates author_intent.md and current_focus.md through dedicated tools", async () => {
+    await executeAgentTool(pipeline, state, config, "update_author_intent", {
+      bookId,
+      content: "# Author Intent\n\nMake this a colder revenge story.\n",
+    });
+    await executeAgentTool(pipeline, state, config, "update_current_focus", {
+      bookId,
+      content: "# Current Focus\n\nSpend the next two chapters on mentor fallout.\n",
+    });
+
+    await expect(readFile(join(state.bookDir(bookId), "story", "author_intent.md"), "utf-8"))
+      .resolves.toContain("colder revenge story");
+    await expect(readFile(join(state.bookDir(bookId), "story", "current_focus.md"), "utf-8"))
+      .resolves.toContain("mentor fallout");
+  });
+
+  it("normalizes human-facing platform aliases before create_book persists config", async () => {
+    const initBook = vi.spyOn(PipelineRunner.prototype, "initBook").mockResolvedValue(undefined);
+
+    const result = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "create_book",
+      {
+        title: "测试书",
+        genre: "urban",
+        platform: "番茄小说",
+        brief: "一本文娱爽文。",
+      },
+    ));
+
+    expect(result).toMatchObject({ bookId: "测试书", title: "测试书", status: "created" });
+    expect(initBook).toHaveBeenCalledWith(expect.objectContaining({
+      id: "测试书",
+      platform: "tomato",
+    }));
+  });
+
+  it("keeps update_current_focus usable for explicit local overrides through the tool surface", async () => {
+    await executeAgentTool(pipeline, state, config, "update_current_focus", {
+      bookId,
+      content: [
+        "# Current Focus",
+        "",
+        "## Active Focus",
+        "",
+        "Keep the merchant guild trail visible in the background.",
+        "",
+        "## Local Override",
+        "",
+        "Stay inside the mentor debt confrontation first and delay the guild chase by one chapter.",
+        "",
+      ].join("\n"),
+    });
+
+    const planResult = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "plan_chapter",
+      { bookId },
+    ));
+
+    const runtimePath = join(state.bookDir(bookId), planResult.intentPath);
+    const intentMarkdown = await readFile(runtimePath, "utf-8");
+    expect(intentMarkdown).toContain([
+      "## Goal",
+      "Stay inside the mentor debt confrontation first and delay the guild chase by one chapter.",
+    ].join("\n"));
+  });
+
+  it("blocks write_full_pipeline when runtime progress is ahead of the chapter index", async () => {
+    const chaptersDir = join(state.bookDir(bookId), "chapters");
+    // Create durable chapter files for 1-3 but only index chapter 1.
+    // This produces durableChapter=3, nextNum=4 while lastIndexedChapter=1,
+    // triggering the sequential write guard.
+    await state.saveChapterIndex(bookId, [{
+      number: 1,
+      title: "Existing Chapter",
+      status: "approved",
+      wordCount: 120,
+      createdAt: "2026-03-22T00:00:00.000Z",
+      updatedAt: "2026-03-22T00:00:00.000Z",
+      auditIssues: [],
+      lengthWarnings: [],
+    }]);
+    await Promise.all([
+      writeFile(join(chaptersDir, "0001_Existing.md"), "# Chapter 1\n", "utf-8"),
+      writeFile(join(chaptersDir, "0002_Second.md"), "# Chapter 2\n", "utf-8"),
+      writeFile(join(chaptersDir, "0003_Third.md"), "# Chapter 3\n", "utf-8"),
+    ]);
+
+    const writeNextChapter = vi.spyOn(pipeline, "writeNextChapter").mockResolvedValue({
+      bookId,
+      chapterNumber: 4,
+      title: "Should Not Run",
+      wordCount: 100,
+      filePath: "books/agent-book/chapters/0004_Should_Not_Run.md",
+      auditResult: { passed: true, issues: [], summary: "ok" },
+      revised: false,
+      status: "ready-for-review",
+    } as Awaited<ReturnType<typeof pipeline.writeNextChapter>>);
+
+    const result = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "write_full_pipeline",
+      { bookId, count: 1 },
+    ));
+
+    expect(result.error).toContain("write_full_pipeline");
+    expect(writeNextChapter).not.toHaveBeenCalled();
+  });
+
+  it("blocks write_truth_file from hacking chapter progress inside current_state.md", async () => {
+    const result = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "write_truth_file",
+      {
+        bookId,
+        fileName: "current_state.md",
+        content: "# Current State\n\n| Current Chapter | 999 |\n",
+      },
+    ));
+
+    expect(result.error).toContain("章节进度");
+  });
+
+  // Phase hotfix 3: write_truth_file must accept both Chinese and English
+  // role-dir paths so English-layout books are writable, not just readable.
+  it("accepts roles/主要角色/<name>.md (zh locale)", async () => {
+    const result = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "write_truth_file",
+      {
+        bookId,
+        fileName: "roles/主要角色/林辞.md",
+        content: "# 林辞\n核心标签：沉默",
+      },
+    ));
+    expect(result.error).toBeUndefined();
+    const written = await readFile(
+      join(state.bookDir(bookId), "story", "roles/主要角色/林辞.md"),
+      "utf-8",
+    );
+    expect(written).toContain("核心标签");
+  });
+
+  it("accepts roles/major/<name>.md (en locale)", async () => {
+    const result = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "write_truth_file",
+      {
+        bookId,
+        fileName: "roles/major/Mara.md",
+        content: "# Mara\nCore tag: stoic",
+      },
+    ));
+    expect(result.error).toBeUndefined();
+    const written = await readFile(
+      join(state.bookDir(bookId), "story", "roles/major/Mara.md"),
+      "utf-8",
+    );
+    expect(written).toContain("Core tag");
+  });
+
+  it("accepts roles/minor/<name>.md (en locale)", async () => {
+    const result = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "write_truth_file",
+      {
+        bookId,
+        fileName: "roles/minor/Kit.md",
+        content: "# Kit\nMinor ally",
+      },
+    ));
+    expect(result.error).toBeUndefined();
+  });
+
+  it("rejects unknown role tier dirs (path-traversal safety preserved)", async () => {
+    const result = JSON.parse(await executeAgentTool(
+      pipeline,
+      state,
+      config,
+      "write_truth_file",
+      {
+        bookId,
+        fileName: "roles/其他/X.md",
+        content: "# X",
+      },
+    ));
+    expect(result.error).toBeDefined();
+  });
+});

package/inkos/packages/core/src/__tests__/pipeline-runner-memory-sync.test.ts

@@ -0,0 +1,317 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { BookConfig } from "../models/book.js";
+
+const ZERO_USAGE = {
+  promptTokens: 0,
+  completionTokens: 0,
+  totalTokens: 0,
+} as const;
+
+function createStateCard(params: {
+  readonly chapter: number;
+  readonly location: string;
+  readonly protagonistState: string;
+  readonly goal: string;
+  readonly conflict: string;
+}): string {
+  return [
+    "# Current State",
+    "",
+    "| Field | Value |",
+    "| --- | --- |",
+    `| Current Chapter | ${params.chapter} |`,
+    `| Current Location | ${params.location} |`,
+    `| Protagonist State | ${params.protagonistState} |`,
+    `| Current Goal | ${params.goal} |`,
+    "| Current Constraint | The city gates are watched. |",
+    "| Current Alliances | Mentor allies are scattered. |",
+    `| Current Conflict | ${params.conflict} |`,
+    "",
+  ].join("\n");
+}
+
+interface FakeStore {
+  facts: Array<{
+    id: number;
+    subject: string;
+    predicate: string;
+    object: string;
+    validFromChapter: number;
+    validUntilChapter: number | null;
+    sourceChapter: number;
+  }>;
+  summaries: Array<{
+    chapter: number;
+    title: string;
+    characters: string;
+    events: string;
+    stateChanges: string;
+    hookActivity: string;
+    mood: string;
+    chapterType: string;
+  }>;
+  hooks: Array<{
+    hookId: string;
+    startChapter: number;
+    type: string;
+    status: string;
+    lastAdvancedChapter: number;
+    expectedPayoff: string;
+    notes: string;
+  }>;
+  nextFactId: number;
+}
+
+class FakeMemoryDB {
+  static stores = new Map<string, FakeStore>();
+
+  private readonly store: FakeStore;
+
+  constructor(private readonly bookDir: string) {
+    const existing = FakeMemoryDB.stores.get(bookDir);
+    if (existing) {
+      this.store = existing;
+      return;
+    }
+
+    const created: FakeStore = {
+      facts: [],
+      summaries: [],
+      hooks: [],
+      nextFactId: 1,
+    };
+    FakeMemoryDB.stores.set(bookDir, created);
+    this.store = created;
+  }
+
+  close(): void {}
+
+  replaceSummaries(summaries: FakeStore["summaries"]): void {
+    this.store.summaries = summaries.map((summary) => ({ ...summary }));
+  }
+
+  replaceHooks(hooks: FakeStore["hooks"]): void {
+    this.store.hooks = hooks.map((hook) => ({ ...hook }));
+  }
+
+  resetFacts(): void {
+    this.store.facts = [];
+    this.store.nextFactId = 1;
+  }
+
+  addFact(fact: Omit<FakeStore["facts"][number], "id">): number {
+    const id = this.store.nextFactId++;
+    this.store.facts.push({ id, ...fact });
+    return id;
+  }
+
+  invalidateFact(id: number, untilChapter: number): void {
+    const index = this.store.facts.findIndex((fact) => fact.id === id);
+    if (index >= 0) {
+      this.store.facts[index] = {
+        ...this.store.facts[index]!,
+        validUntilChapter: untilChapter,
+      };
+    }
+  }
+}
+
+describe("PipelineRunner structured-state memory sync", () => {
+  let root = "";
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    vi.resetModules();
+    vi.doUnmock("../state/memory-db.js");
+    FakeMemoryDB.stores.clear();
+    if (root) {
+      await rm(root, { recursive: true, force: true });
+      root = "";
+    }
+  });
+
+  it("uses structured runtime state for narrative memory during writeNextChapter even when markdown projections drift after persistence", async () => {
+    vi.doMock("../state/memory-db.js", () => ({
+      MemoryDB: FakeMemoryDB,
+    }));
+
+    const { PipelineRunner } = await import("../pipeline/runner.js");
+    const { StateManager } = await import("../state/manager.js");
+    const { WriterAgent } = await import("../agents/writer.js");
+    const { ContinuityAuditor } = await import("../agents/continuity.js");
+    const { StateValidatorAgent } = await import("../agents/state-validator.js");
+
+    root = await mkdtemp(join(tmpdir(), "inkos-runner-memory-sync-"));
+    const state = new StateManager(root);
+    const bookId = "memory-sync-book";
+    const now = "2026-03-25T00:00:00.000Z";
+    const book: BookConfig = {
+      id: bookId,
+      title: "Memory Sync Book",
+      platform: "tomato",
+      genre: "xuanhuan",
+      status: "active",
+      language: "en",
+      targetChapters: 10,
+      chapterWordCount: 10,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    await state.saveBookConfig(bookId, book);
+    const bookDir = state.bookDir(bookId);
+    const storyDir = join(bookDir, "story");
+    await mkdir(storyDir, { recursive: true });
+    await mkdir(join(bookDir, "chapters"), { recursive: true });
+    await Promise.all([
+      writeFile(join(storyDir, "current_state.md"), createStateCard({
+        chapter: 0,
+        location: "Shrine outskirts",
+        protagonistState: "Lin Yue begins with the oath token hidden.",
+        goal: "Reach the trial city.",
+        conflict: "The trial deadline is closing in.",
+      }), "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "# Pending Hooks\n", "utf-8"),
+      writeFile(join(storyDir, "chapter_summaries.md"), "# Chapter Summaries\n", "utf-8"),
+    ]);
+
+    const runner = new PipelineRunner({
+      client: {
+        provider: "openai",
+        apiFormat: "chat",
+        stream: false,
+        defaults: {
+          temperature: 0.7,
+          maxTokens: 4096,
+          thinkingBudget: 0,
+
+        },
+      } as ConstructorParameters<typeof PipelineRunner>[0]["client"],
+      model: "test-model",
+      projectRoot: root,
+      inputGovernanceMode: "legacy",
+    });
+
+    const originalSaveChapter = WriterAgent.prototype.saveChapter;
+    vi.spyOn(WriterAgent.prototype, "writeChapter").mockResolvedValue({
+      chapterNumber: 1,
+      title: "Structured Chapter",
+      content: "Lin Yue follows the debt into the watchtower archive.",
+      wordCount: 9,
+      preWriteCheck: "check",
+      postSettlement: "settled",
+      updatedState: "unused legacy state",
+      updatedLedger: "unused legacy ledger",
+      updatedHooks: "unused legacy hooks",
+      chapterSummary: "| 1 | unused summary |",
+      updatedSubplots: "",
+      updatedEmotionalArcs: "",
+      updatedCharacterMatrix: "",
+      postWriteErrors: [],
+      postWriteWarnings: [],
+      tokenUsage: ZERO_USAGE,
+      runtimeStateDelta: {
+        chapter: 1,
+        currentStatePatch: {
+          currentGoal: "Trace the debt through the watchtower archive.",
+          currentConflict: "Guild pressure keeps colliding with the debt trail.",
+        },
+        hookOps: {
+          upsert: [
+            {
+              hookId: "structured-hook",
+              startChapter: 1,
+              type: "relationship",
+              status: "open",
+              lastAdvancedChapter: 1,
+              expectedPayoff: "Reveal why the mentor vanished.",
+              notes: "Structured hook should win.",
+            },
+          ],
+          mention: [],
+          resolve: [],
+          defer: [],
+        },
+        newHookCandidates: [],
+        chapterSummary: {
+          chapter: 1,
+          title: "Structured Summary",
+          characters: "Lin Yue",
+          events: "Lin Yue follows the debt into the watchtower archive.",
+          stateChanges: "The debt trail sharpens.",
+          hookActivity: "structured-hook advanced",
+          mood: "tense",
+          chapterType: "investigation",
+        },
+        subplotOps: [],
+        emotionalArcOps: [],
+        characterMatrixOps: [],
+        notes: [],
+      },
+    });
+    vi.spyOn(ContinuityAuditor.prototype, "auditChapter").mockResolvedValue({
+      passed: true,
+      issues: [],
+      summary: "clean",
+      overallScore: 90,
+      tokenUsage: ZERO_USAGE,
+    });
+    vi.spyOn(StateValidatorAgent.prototype, "validate").mockResolvedValue({
+      warnings: [],
+      passed: true,
+    });
+    vi.spyOn(WriterAgent.prototype, "saveChapter").mockImplementation(async function (
+      this: InstanceType<typeof WriterAgent>,
+      bookDirArg,
+      output,
+      numericalSystem,
+      language,
+    ) {
+      await originalSaveChapter.call(this, bookDirArg, output, numericalSystem, language);
+      await Promise.all([
+        writeFile(
+          join(bookDirArg, "story", "pending_hooks.md"),
+          [
+            "| hook_id | start_chapter | type | status | last_advanced | expected_payoff | notes |",
+            "| --- | --- | --- | --- | --- | --- | --- |",
+            "| markdown-drift-hook | 1 | mystery | open | 1 | 5 | Drifted markdown hook |",
+            "",
+          ].join("\n"),
+          "utf-8",
+        ),
+        writeFile(
+          join(bookDirArg, "story", "chapter_summaries.md"),
+          [
+            "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
+            "| --- | --- | --- | --- | --- | --- | --- | --- |",
+            "| 1 | Markdown Drift Summary | Lin Yue | Drifted markdown event | Drifted markdown state | markdown-drift-hook advanced | flat | fallback |",
+            "",
+          ].join("\n"),
+          "utf-8",
+        ),
+      ]);
+    });
+
+    await runner.writeNextChapter(bookId);
+
+    const narrativeStore = FakeMemoryDB.stores.get(bookDir);
+    expect(await readFile(join(storyDir, "pending_hooks.md"), "utf-8")).toContain("markdown-drift-hook");
+    expect(await readFile(join(storyDir, "chapter_summaries.md"), "utf-8")).toContain("Markdown Drift Summary");
+    expect(narrativeStore?.hooks).toEqual([
+      expect.objectContaining({
+        hookId: "structured-hook",
+        notes: "Structured hook should win.",
+      }),
+    ]);
+    expect(narrativeStore?.summaries).toEqual([
+      expect.objectContaining({
+        chapter: 1,
+        title: "Structured Summary",
+        events: "Lin Yue follows the debt into the watchtower archive.",
+      }),
+    ]);
+  });
+});