@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/cli/src/__tests__/project-bootstrap.test.ts

@@ -0,0 +1,71 @@
+import { beforeEach, afterEach, describe, expect, it } from "vitest";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("project bootstrap", () => {
+  const originalHome = process.env.HOME;
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "inkos-bootstrap-"));
+    process.env.HOME = tempDir;
+  });
+
+  afterEach(async () => {
+    process.env.HOME = originalHome;
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it("creates a minimal Studio-first project when none exists", async () => {
+    const { ensureProjectDirectoryInitialized } = await import("../project-bootstrap.js");
+
+    const initialized = await ensureProjectDirectoryInitialized(tempDir, { language: "zh" });
+
+    expect(initialized).toBe(true);
+    const config = JSON.parse(await readFile(join(tempDir, "inkos.json"), "utf-8"));
+    expect(config.name).toMatch(/^inkos-bootstrap-/);
+    expect(config.version).toBe("0.1.0");
+    expect(config.llm.configSource).toBe("studio");
+    expect(config.llm.service).toBe("custom");
+    expect(config.llm.model).toBe("");
+    expect(config.llm.baseUrl).toBe("");
+    await expect(readFile(join(tempDir, ".nvmrc"), "utf-8")).resolves.toBe("22\n");
+    await expect(readFile(join(tempDir, ".node-version"), "utf-8")).resolves.toBe("22\n");
+  });
+
+  it("does not overwrite support files when auto-initializing", async () => {
+    await writeFile(join(tempDir, ".env"), "EXISTING=1\n", "utf-8");
+    await writeFile(join(tempDir, ".gitignore"), "CUSTOM\n", "utf-8");
+
+    const { ensureProjectDirectoryInitialized } = await import("../project-bootstrap.js");
+    await ensureProjectDirectoryInitialized(tempDir, { language: "zh" });
+
+    await expect(readFile(join(tempDir, ".env"), "utf-8")).resolves.toBe("EXISTING=1\n");
+    const gitignore = await readFile(join(tempDir, ".gitignore"), "utf-8");
+    expect(gitignore).toContain("CUSTOM\n");
+    expect(gitignore).toContain(".env\n");
+    expect(gitignore).toContain("node_modules/\n");
+    expect(gitignore).toContain(".DS_Store\n");
+  });
+
+  it("preserves an existing .gitignore when explicitly initializing", async () => {
+    await writeFile(join(tempDir, ".gitignore"), "dist/\n# keep me\n", "utf-8");
+
+    const { initializeProjectDirectory } = await import("../project-bootstrap.js");
+    await initializeProjectDirectory(tempDir, { language: "zh" });
+
+    const gitignore = await readFile(join(tempDir, ".gitignore"), "utf-8");
+    expect(gitignore).toContain("dist/\n# keep me\n");
+    expect(gitignore).toContain(".env\n");
+    expect(gitignore).toContain("node_modules/\n");
+    expect(gitignore).toContain(".DS_Store\n");
+  });
+
+  it("returns false when the directory is already an InkOS project", async () => {
+    await writeFile(join(tempDir, "inkos.json"), "{}\n", "utf-8");
+    const { ensureProjectDirectoryInitialized } = await import("../project-bootstrap.js");
+
+    await expect(ensureProjectDirectoryInitialized(tempDir, { language: "zh" })).resolves.toBe(false);
+  });
+});

package/inkos/packages/cli/src/__tests__/publish-package.test.ts

@@ -0,0 +1,272 @@
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileSync } from "node:child_process";
+import { describe, expect, it } from "vitest";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliDir = resolve(testDir, "..", "..");
+const workspaceRoot = resolve(cliDir, "..", "..");
+const studioDir = resolve(workspaceRoot, "packages", "studio");
+const CLI_PACK_TEST_TIMEOUT_MS = 30_000;
+const STUDIO_PACK_TEST_TIMEOUT_MS = 120_000;
+const sourceCliPackageJsonPromise = readFile(resolve(cliDir, "package.json"), "utf-8").then((raw) =>
+  JSON.parse(raw),
+);
+const sourceStudioPackageJsonPromise = readFile(resolve(studioDir, "package.json"), "utf-8").then((raw) =>
+  JSON.parse(raw),
+);
+
+function tarForceLocalArgs(): string[] {
+  if (process.platform !== "win32") return [];
+  try {
+    const version = execFileSync("tar", ["--version"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    return version.includes("GNU tar") ? ["--force-local"] : [];
+  } catch {
+    return [];
+  }
+}
+
+async function packPackage(packageDir: string, packDir: string) {
+  const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+  execFileSync(npmCmd, ["pack", "--pack-destination", packDir], {
+    cwd: packageDir,
+    env: process.env,
+    encoding: "utf-8",
+    shell: process.platform === "win32",
+  });
+
+  const tgzFiles = (await readdir(packDir)).filter((name) => name.endsWith(".tgz"));
+  if (tgzFiles.length !== 1) {
+    throw new Error(`Expected exactly one tarball in ${packDir}, found ${tgzFiles.length}`);
+  }
+
+  return join(packDir, tgzFiles[0]);
+}
+
+async function extractPackedPackageJson(packageDir: string, packDir: string) {
+  const tarballPath = await packPackage(packageDir, packDir);
+  const tarArgs = [...tarForceLocalArgs(), "-xOf"];
+  return execFileSync("tar", [...tarArgs, tarballPath, "package/package.json"], {
+    cwd: workspaceRoot,
+    encoding: "utf-8",
+  });
+}
+
+describe.sequential("publish packaging", () => {
+  it("rewrites workspace package versions for canary publishing", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "inkos-version-script-"));
+    const tempPackagesDir = join(tempRoot, "packages");
+    const tempCoreDir = join(tempPackagesDir, "core");
+    const tempCliDir = join(tempPackagesDir, "cli");
+
+    try {
+      await mkdir(tempCoreDir, { recursive: true });
+      await mkdir(tempCliDir, { recursive: true });
+
+      await writeFile(
+        join(tempRoot, "package.json"),
+        `${JSON.stringify({ name: "inkos", version: "0.4.6" }, null, 2)}\n`,
+      );
+      await writeFile(
+        join(tempCoreDir, "package.json"),
+        `${JSON.stringify({ name: "@actalk/inkos-core", version: "0.4.6" }, null, 2)}\n`,
+      );
+      await writeFile(
+        join(tempCliDir, "package.json"),
+        `${JSON.stringify(
+          {
+            name: "@actalk/inkos",
+            version: "0.4.6",
+            dependencies: {
+              "@actalk/inkos-core": "workspace:*",
+              commander: "^13.0.0",
+            },
+          },
+          null,
+          2,
+        )}\n`,
+      );
+
+      execFileSync(
+        "node",
+        [resolve(workspaceRoot, "scripts/set-package-versions.mjs"), "0.4.8-canary.7", "--root", tempRoot],
+        {
+          cwd: workspaceRoot,
+          env: process.env,
+          encoding: "utf-8",
+        },
+      );
+
+      const rootPackageJson = JSON.parse(await readFile(join(tempRoot, "package.json"), "utf-8"));
+      const corePackageJson = JSON.parse(await readFile(join(tempCoreDir, "package.json"), "utf-8"));
+      const cliPackageJson = JSON.parse(await readFile(join(tempCliDir, "package.json"), "utf-8"));
+
+      expect(rootPackageJson.version).toBe("0.4.8-canary.7");
+      expect(corePackageJson.version).toBe("0.4.8-canary.7");
+      expect(cliPackageJson.version).toBe("0.4.8-canary.7");
+      expect(cliPackageJson.dependencies["@actalk/inkos-core"]).toBe("0.4.8-canary.7");
+    } finally {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps source CLI dependencies linked through the workspace protocol", async () => {
+    const cliPackageJson = await sourceCliPackageJsonPromise;
+
+    expect(cliPackageJson.dependencies["@actalk/inkos-core"]).toBe("workspace:*");
+    expect(cliPackageJson.dependencies["@actalk/inkos-studio"]).toBe("workspace:*");
+  });
+
+  it("verifies publishable manifests before npm publish runs", async () => {
+    const cliPackageJson = await sourceCliPackageJsonPromise;
+    const corePackageJson = JSON.parse(
+      await readFile(resolve(workspaceRoot, "packages/core/package.json"), "utf-8"),
+    );
+
+    expect(cliPackageJson.scripts.prepublishOnly).toBe(
+      "node ../../scripts/verify-no-workspace-protocol.mjs .",
+    );
+    expect(corePackageJson.scripts.prepublishOnly).toBe(
+      "node ../../scripts/verify-no-workspace-protocol.mjs .",
+    );
+  });
+
+  it("allows source workspace protocol manifests when they normalize cleanly for publish", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "inkos-publish-verify-pass-"));
+    const tempPackagesDir = join(tempRoot, "packages");
+    const tempCoreDir = join(tempPackagesDir, "core");
+    const tempCliDir = join(tempPackagesDir, "cli");
+
+    try {
+      await mkdir(tempCoreDir, { recursive: true });
+      await mkdir(tempCliDir, { recursive: true });
+
+      await writeFile(
+        join(tempRoot, "package.json"),
+        `${JSON.stringify({ name: "inkos", version: "0.5.1" }, null, 2)}\n`,
+      );
+      await writeFile(
+        join(tempCoreDir, "package.json"),
+        `${JSON.stringify({ name: "@actalk/inkos-core", version: "0.5.1" }, null, 2)}\n`,
+      );
+      await writeFile(
+        join(tempCliDir, "package.json"),
+        `${JSON.stringify(
+          {
+            name: "@actalk/inkos",
+            version: "0.5.1",
+            dependencies: {
+              "@actalk/inkos-core": "workspace:*",
+              commander: "^13.0.0",
+            },
+          },
+          null,
+          2,
+        )}\n`,
+      );
+
+      expect(() =>
+        execFileSync(
+          "node",
+          [resolve(workspaceRoot, "scripts/verify-no-workspace-protocol.mjs"), "packages/core", "packages/cli"],
+          {
+            cwd: tempRoot,
+            env: process.env,
+            encoding: "utf-8",
+            stdio: "pipe",
+          },
+        )).not.toThrow();
+    } finally {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects workspace protocol manifests that normalize to the wrong internal version", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "inkos-publish-verify-fail-"));
+    const tempPackagesDir = join(tempRoot, "packages");
+    const tempCoreDir = join(tempPackagesDir, "core");
+    const tempCliDir = join(tempPackagesDir, "cli");
+
+    try {
+      await mkdir(tempCoreDir, { recursive: true });
+      await mkdir(tempCliDir, { recursive: true });
+
+      await writeFile(
+        join(tempRoot, "package.json"),
+        `${JSON.stringify({ name: "inkos", version: "0.5.1" }, null, 2)}\n`,
+      );
+      await writeFile(
+        join(tempCoreDir, "package.json"),
+        `${JSON.stringify({ name: "@actalk/inkos-core", version: "0.5.1" }, null, 2)}\n`,
+      );
+      await writeFile(
+        join(tempCliDir, "package.json"),
+        `${JSON.stringify(
+          {
+            name: "@actalk/inkos",
+            version: "0.5.1",
+            dependencies: {
+              "@actalk/inkos-core": "workspace:0.5.0",
+            },
+          },
+          null,
+          2,
+        )}\n`,
+      );
+
+      expect(() =>
+        execFileSync(
+          "node",
+          [resolve(workspaceRoot, "scripts/verify-no-workspace-protocol.mjs"), "packages/cli"],
+          {
+            cwd: tempRoot,
+            env: process.env,
+            encoding: "utf-8",
+            stdio: "pipe",
+          },
+        )).toThrow(/normalizes to 0\.5\.0, expected 0\.5\.1/);
+    } finally {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("replaces workspace dependencies before npm pack", { timeout: CLI_PACK_TEST_TIMEOUT_MS }, async () => {
+    const packDir = await mkdtemp(join(tmpdir(), "inkos-cli-pack-"));
+
+    try {
+      const packedPackageJson = JSON.parse(await extractPackedPackageJson(cliDir, packDir));
+      const corePackageJson = JSON.parse(
+        await readFile(resolve(workspaceRoot, "packages/core/package.json"), "utf-8"),
+      );
+      const studioPackageJson = await sourceStudioPackageJsonPromise;
+
+      expect(packedPackageJson.dependencies["@actalk/inkos-core"]).toBe(corePackageJson.version);
+      expect(packedPackageJson.dependencies["@actalk/inkos-studio"]).toBe(studioPackageJson.version);
+    } finally {
+      await rm(packDir, { recursive: true, force: true });
+    }
+  });
+
+  it("packs the studio runtime entry alongside the built frontend", { timeout: STUDIO_PACK_TEST_TIMEOUT_MS }, async () => {
+    const packDir = await mkdtemp(join(tmpdir(), "inkos-studio-pack-"));
+
+    try {
+      const tarballPath = await packPackage(studioDir, packDir);
+      const tarArgs = [...tarForceLocalArgs(), "-tf"];
+      const archiveListing = execFileSync("tar", [...tarArgs, tarballPath], {
+        cwd: workspaceRoot,
+        encoding: "utf-8",
+      });
+
+      expect(archiveListing).toContain("package/dist/index.html");
+      expect(archiveListing).toContain("package/dist/api/index.js");
+    } finally {
+      await rm(packDir, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -0,0 +1,82 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const reviseDraftMock = vi.fn();
+const resyncChapterArtifactsMock = vi.fn();
+const buildPipelineConfigMock = vi.fn();
+const loadBookConfigMock = vi.fn();
+const logMock = vi.fn();
+const logErrorMock = vi.fn();
+
+vi.mock("@actalk/inkos-core", () => ({
+  DEFAULT_REVISE_MODE: "spot-fix",
+  PipelineRunner: class {
+    reviseDraft = reviseDraftMock;
+    resyncChapterArtifacts = resyncChapterArtifactsMock;
+  },
+  StateManager: class {
+    async loadBookConfig() {
+      return loadBookConfigMock();
+    }
+  },
+}));
+
+vi.mock("../utils.js", () => ({
+  loadConfig: vi.fn(async () => ({ llm: {} })),
+  buildPipelineConfig: buildPipelineConfigMock,
+  findProjectRoot: vi.fn(() => "/project"),
+  resolveBookId: vi.fn(async (bookId?: string) => bookId ?? "auto-book"),
+  getLegacyMigrationHint: vi.fn(async () => undefined),
+  resolveContext: vi.fn(),
+  log: logMock,
+  logError: logErrorMock,
+}));
+
+vi.mock("../localization.js", () => ({
+  formatWriteNextResultLines: vi.fn(() => ["ok"]),
+  resolveCliLanguage: vi.fn(() => "zh"),
+}));
+
+describe("revision-related CLI commands", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    reviseDraftMock.mockResolvedValue({
+      chapterNumber: 3,
+      wordCount: 1200,
+      fixedIssues: [],
+      applied: true,
+      status: "ready-for-review",
+    });
+    resyncChapterArtifactsMock.mockResolvedValue({
+      chapterNumber: 3,
+      title: "Synced Chapter",
+      wordCount: 1200,
+      revised: false,
+      status: "ready-for-review",
+      auditResult: { passed: true, issues: [], summary: "synced" },
+    });
+    buildPipelineConfigMock.mockReturnValue({});
+    loadBookConfigMock.mockResolvedValue({ language: "zh" });
+  });
+
+  it("passes one-off brief into revise command pipeline config", async () => {
+    const { reviseCommand } = await import("../commands/revise.js");
+
+    await reviseCommand.parseAsync(["node", "revise", "demo-book", "3", "--mode", "rewrite", "--brief", "把注意力拉回师债主线。"], { from: "node" });
+
+    expect(buildPipelineConfigMock).toHaveBeenCalledWith(expect.anything(), "/project", {
+      externalContext: "把注意力拉回师债主线。",
+    });
+    expect(reviseDraftMock).toHaveBeenCalledWith("demo-book", 3, "rewrite");
+  });
+
+  it("exposes write sync and passes brief into pipeline config", async () => {
+    const { writeCommand } = await import("../commands/write.js");
+
+    await writeCommand.parseAsync(["node", "write", "sync", "demo-book", "3", "--brief", "以师债线为准同步状态。"], { from: "node" });
+
+    expect(buildPipelineConfigMock).toHaveBeenCalledWith(expect.anything(), "/project", {
+      externalContext: "以师债线为准同步状态。",
+    });
+    expect(resyncChapterArtifactsMock).toHaveBeenCalledWith("demo-book", 3);
+  });
+});

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

@@ -0,0 +1,89 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  ensureNodeRuntimePinFiles,
+  evaluateSqliteMemorySupport,
+  formatSqliteMemorySupportWarning,
+  inspectNodeRuntimePinFiles,
+  parseNodeMajor,
+} from "../runtime-requirements.js";
+
+let tempRoot: string;
+
+describe("runtime requirements", () => {
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(join(tmpdir(), "inkos-runtime-requirements-"));
+  });
+
+  afterEach(async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("parses Node major versions", () => {
+    expect(parseNodeMajor("v20.17.0")).toBe(20);
+    expect(parseNodeMajor("v22.19.0")).toBe(22);
+  });
+
+  it("marks sqlite memory acceleration unavailable below Node 22", () => {
+    const result = evaluateSqliteMemorySupport({
+      nodeVersion: "v20.17.0",
+      hasNodeSqlite: false,
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.detail).toContain("Node 22+");
+    expect(result.detail).toContain("v20.17.0");
+  });
+
+  it("marks sqlite memory acceleration available on supported runtimes", () => {
+    const result = evaluateSqliteMemorySupport({
+      nodeVersion: "v22.19.0",
+      hasNodeSqlite: true,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.detail).toContain("v22.19.0");
+  });
+
+  it("formats an early warning for unsupported sqlite memory runtimes", () => {
+    const warning = formatSqliteMemorySupportWarning({
+      nodeVersion: "v20.17.0",
+      hasNodeSqlite: false,
+    });
+
+    expect(warning).toContain("v20.17.0");
+    expect(warning).toContain("Node 22+");
+    expect(warning).toContain("memory.db live sync");
+  });
+
+  it("does not format a warning on supported runtimes", () => {
+    const warning = formatSqliteMemorySupportWarning({
+      nodeVersion: "v22.19.0",
+      hasNodeSqlite: true,
+    });
+
+    expect(warning).toBeNull();
+  });
+
+  it("reports missing node runtime pin files", async () => {
+    const status = await inspectNodeRuntimePinFiles(tempRoot);
+
+    expect(status.ok).toBe(false);
+    expect(status.detail).toContain(".nvmrc");
+    expect(status.detail).toContain(".node-version");
+  });
+
+  it("writes node runtime pin files for old projects", async () => {
+    const repair = await ensureNodeRuntimePinFiles(tempRoot);
+
+    expect(repair.updated).toBe(true);
+    expect(repair.written).toEqual([".nvmrc", ".node-version"]);
+    await expect(readFile(join(tempRoot, ".nvmrc"), "utf-8")).resolves.toBe("22\n");
+    await expect(readFile(join(tempRoot, ".node-version"), "utf-8")).resolves.toBe("22\n");
+
+    const status = await inspectNodeRuntimePinFiles(tempRoot);
+    expect(status.ok).toBe(true);
+  });
+});

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

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { createProgram } from "../program.js";
+import { extractResponsesImageBase64, resolveCoverApiKey } from "../commands/short-fiction.js";
+
+describe("short command", () => {
+  it("registers public short run command", () => {
+    const program = createProgram();
+    const short = program.commands.find((command) => command.name() === "short");
+    expect(short).toBeDefined();
+    expect(short?.commands.some((command) => command.name() === "run")).toBe(true);
+  });
+
+  it("exposes cover generation options on short run", () => {
+    const program = createProgram();
+    const short = program.commands.find((command) => command.name() === "short");
+    const run = short?.commands.find((command) => command.name() === "run");
+    const optionNames = new Set(run?.options.map((option) => option.long));
+
+    expect(optionNames).toContain("--cover-base-url");
+    expect(optionNames).toContain("--cover-endpoint");
+    expect(optionNames).toContain("--cover-model");
+    expect(optionNames).toContain("--cover-size");
+    expect(optionNames).toContain("--cover-api-key-env");
+    expect(optionNames).toContain("--no-cover");
+  });
+
+  it("extracts base64 image output from a Responses image_generation_call", () => {
+    const payload = {
+      output: [
+        { type: "message", content: [{ type: "output_text", text: "ok" }] },
+        { type: "image_generation_call", result: "iVBORw0KGgo=" },
+      ],
+    };
+
+    expect(extractResponsesImageBase64(payload)).toBe("iVBORw0KGgo=");
+  });
+
+  it("requires an explicit cover API key", () => {
+    const oldValue = process.env.INKOS_TEST_MISSING_COVER_KEY;
+    delete process.env.INKOS_TEST_MISSING_COVER_KEY;
+    try {
+      expect(() => resolveCoverApiKey("INKOS_TEST_MISSING_COVER_KEY")).toThrow(/API key/i);
+    } finally {
+      if (oldValue === undefined) delete process.env.INKOS_TEST_MISSING_COVER_KEY;
+      else process.env.INKOS_TEST_MISSING_COVER_KEY = oldValue;
+    }
+  });
+});