@zwbigi/ink-xy 0.1.2 → 0.1.4

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

@@ -0,0 +1,135 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+export const SQLITE_MEMORY_MIN_NODE_MAJOR = 22;
+export const SQLITE_MEMORY_PIN_VERSION = String(SQLITE_MEMORY_MIN_NODE_MAJOR);
+export const SQLITE_MEMORY_PIN_FILES = [".nvmrc", ".node-version"] as const;
+
+export interface SqliteMemorySupportResult {
+  readonly ok: boolean;
+  readonly detail: string;
+}
+
+export interface NodeRuntimePinStatus {
+  readonly ok: boolean;
+  readonly detail: string;
+  readonly missing: ReadonlyArray<string>;
+}
+
+export interface NodeRuntimePinRepairResult {
+  readonly updated: boolean;
+  readonly written: ReadonlyArray<string>;
+}
+
+export function formatSqliteMemorySupportWarning(options?: {
+  readonly nodeVersion?: string;
+  readonly hasNodeSqlite?: boolean;
+}): string | null {
+  const nodeVersion = options?.nodeVersion ?? process.version;
+  const result = evaluateSqliteMemorySupport({
+    nodeVersion,
+    hasNodeSqlite: options?.hasNodeSqlite,
+  });
+  if (result.ok) return null;
+
+  return `Node ${nodeVersion} does not support SQLite memory index; memory.db live sync will fall back to Markdown. Use Node 22+ or run 'inkos doctor'.`;
+}
+
+export async function inspectNodeRuntimePinFiles(root: string): Promise<NodeRuntimePinStatus> {
+  const missing: string[] = [];
+
+  for (const file of SQLITE_MEMORY_PIN_FILES) {
+    try {
+      const content = await readFile(join(root, file), "utf-8");
+      if (content.trim() !== SQLITE_MEMORY_PIN_VERSION) {
+        missing.push(file);
+      }
+    } catch {
+      missing.push(file);
+    }
+  }
+
+  if (missing.length === 0) {
+    return {
+      ok: true,
+      detail: `Pinned to Node ${SQLITE_MEMORY_PIN_VERSION} via ${SQLITE_MEMORY_PIN_FILES.join(", ")}.`,
+      missing,
+    };
+  }
+
+  return {
+    ok: false,
+    detail: `Missing or outdated: ${missing.join(", ")}. Run 'inkos doctor --repair-node-runtime'.`,
+    missing,
+  };
+}
+
+export async function ensureNodeRuntimePinFiles(root: string): Promise<NodeRuntimePinRepairResult> {
+  const written: string[] = [];
+
+  for (const file of SQLITE_MEMORY_PIN_FILES) {
+    const path = join(root, file);
+    let content = "";
+    try {
+      content = await readFile(path, "utf-8");
+    } catch {
+      content = "";
+    }
+
+    if (content.trim() === SQLITE_MEMORY_PIN_VERSION) {
+      continue;
+    }
+
+    await writeFile(path, `${SQLITE_MEMORY_PIN_VERSION}\n`, "utf-8");
+    written.push(file);
+  }
+
+  return {
+    updated: written.length > 0,
+    written,
+  };
+}
+
+export function parseNodeMajor(version: string): number {
+  return parseInt(version.replace(/^v/i, "").split(".")[0] ?? "0", 10);
+}
+
+function hasNodeSqliteBuiltin(): boolean {
+  try {
+    require("node:sqlite");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function evaluateSqliteMemorySupport(options?: {
+  readonly nodeVersion?: string;
+  readonly hasNodeSqlite?: boolean;
+}): SqliteMemorySupportResult {
+  const nodeVersion = options?.nodeVersion ?? process.version;
+  const major = parseNodeMajor(nodeVersion);
+
+  if (major < SQLITE_MEMORY_MIN_NODE_MAJOR) {
+    return {
+      ok: false,
+      detail: `Unavailable on ${nodeVersion}. Long-book memory.db acceleration requires Node ${SQLITE_MEMORY_MIN_NODE_MAJOR}+.`,
+    };
+  }
+
+  const hasNodeSqlite = options?.hasNodeSqlite ?? hasNodeSqliteBuiltin();
+  if (!hasNodeSqlite) {
+    return {
+      ok: false,
+      detail: `${nodeVersion} detected, but node:sqlite is unavailable on this runtime. memory.db acceleration will stay disabled.`,
+    };
+  }
+
+  return {
+    ok: true,
+    detail: `Available on ${nodeVersion}.`,
+  };
+}

package/inkos/packages/cli/src/tui/__tests__/markdown.test.ts

@@ -0,0 +1,64 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { renderMarkdown } from "../markdown.js";
+
+describe("renderMarkdown", () => {
+  const origTermProgram = process.env.TERM_PROGRAM;
+  afterEach(() => {
+    if (origTermProgram === undefined) delete process.env.TERM_PROGRAM;
+    else process.env.TERM_PROGRAM = origTermProgram;
+  });
+  it("converts **text** to ANSI bold", () => {
+    const result = renderMarkdown("这是 **加粗** 文本");
+    // Should contain ANSI bold on/off around 加粗
+    expect(result).toContain("\x1b[1m加粗\x1b[22m");
+    // Should NOT contain raw ** markers
+    expect(result).not.toContain("**");
+  });
+
+  it("converts * bullets to · bullets", () => {
+    const result = renderMarkdown("* 第一项\n* 第二项");
+    expect(result).toContain("· 第一项");
+    expect(result).toContain("· 第二项");
+    // No raw * bullets remaining
+    expect(result).not.toMatch(/^\s*\* /m);
+  });
+
+  it("renders bold inside list items", () => {
+    const result = renderMarkdown("* **昨日**: 总统套房\n* **今日**: 桥洞");
+    expect(result).toContain("\x1b[1m昨日\x1b[22m");
+    expect(result).toContain("\x1b[1m今日\x1b[22m");
+    expect(result).toContain("·");
+    expect(result).not.toContain("**");
+  });
+
+  it("does not leak bold across lines", () => {
+    const result = renderMarkdown("打磨**冲突场景**，还是梳理**心理转变弧线**。");
+    // Each bold region should be self-contained
+    const boldRegions = [...result.matchAll(/\x1b\[1m(.*?)\x1b\[22m/g)];
+    expect(boldRegions).toHaveLength(2);
+    expect(boldRegions[0][1]).toBe("冲突场景");
+    expect(boldRegions[1][1]).toBe("心理转变弧线");
+  });
+
+  it("renders tables with box-drawing characters", () => {
+    const result = renderMarkdown(
+      "| 属性 | 值 |\n|------|----|\n| 住所 | 桥洞 |",
+    );
+    expect(result).toContain("┌");
+    expect(result).toContain("│");
+    expect(result).toContain("└");
+  });
+
+  it("does not contain full-reset codes that override parent Ink color", () => {
+    // \x1b[0m resets ALL terminal attributes including color set by Ink's <Text>.
+    // renderMarkdown must not emit it, so the parent <Text color={...}> stays in effect.
+    const result = renderMarkdown("这是 **加粗** 文本");
+    expect(result).not.toContain("\x1b[0m");
+  });
+
+  it("falls back to raw text on parse error", () => {
+    // renderMarkdown should never throw; it returns raw text on failure
+    const result = renderMarkdown("plain text");
+    expect(result).toContain("plain text");
+  });
+});

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

@@ -0,0 +1,41 @@
+import type { InteractionIntentType } from "@actalk/inkos-core";
+import type { TuiCopy } from "./i18n.js";
+
+export interface ActivityState {
+  readonly label: string;
+  readonly frames: readonly string[];
+  readonly accent: string;
+  readonly intervalMs: number;
+}
+
+import { WARM_ACCENT } from "./theme.js";
+
+const DOTS = ["·  ", "·· ", "···", " ··", "  ·"] as const;
+const WAVE = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴"] as const;
+const PULSE = ["◜", "◠", "◝", "◞", "◡", "◟"] as const;
+
+export function describeActivityState(
+  intent: InteractionIntentType | "unknown",
+  copy: Pick<TuiCopy, "activity">,
+): ActivityState {
+  switch (intent) {
+    case "write_next":
+    case "continue_book":
+      return { label: copy.activity.writing, frames: WAVE, accent: WARM_ACCENT, intervalMs: 180 };
+    case "revise_chapter":
+    case "rewrite_chapter":
+      return { label: copy.activity.reviewing, frames: WAVE, accent: WARM_ACCENT, intervalMs: 180 };
+    case "update_focus":
+    case "update_author_intent":
+    case "edit_truth":
+      return { label: copy.activity.updating, frames: PULSE, accent: WARM_ACCENT, intervalMs: 220 };
+    case "list_books":
+    case "select_book":
+    case "switch_mode":
+    case "explain_status":
+      return { label: copy.activity.checking, frames: DOTS, accent: WARM_ACCENT, intervalMs: 220 };
+    case "chat":
+    default:
+      return { label: copy.activity.thinking, frames: DOTS, accent: WARM_ACCENT, intervalMs: 220 };
+  }
+}

package/inkos/packages/cli/src/tui/agent-input.ts

@@ -0,0 +1,264 @@
+import {
+  appendInteractionMessage,
+  clearPendingDecision,
+  createLLMClient,
+  runAgentSession,
+  type InteractionSession,
+} from "@actalk/inkos-core";
+import { persistProjectSession } from "./session-store.js";
+import { buildPipelineConfig, loadConfig } from "../utils.js";
+
+export async function processTuiAgentInput(params: {
+  readonly projectRoot: string;
+  readonly input: string;
+  readonly session: InteractionSession;
+  readonly activeBookId?: string;
+  readonly onTextDelta?: (text: string) => void;
+}) {
+  const config = await loadConfig({ requireApiKey: false, projectRoot: params.projectRoot });
+  const client = createLLMClient(config.llm);
+  const pipeline = new (await import("@actalk/inkos-core")).PipelineRunner(
+    buildPipelineConfig(config, params.projectRoot, { quiet: true }),
+  );
+  const userTimestamp = Date.now();
+  const resolvedBookId = params.activeBookId ?? params.session.activeBookId ?? null;
+  const initialMessages = params.session.messages
+    .filter((message) => message.role === "user" || message.role === "assistant")
+    .map((message) => ({ role: message.role, content: message.content }));
+
+  let nextSession = appendInteractionMessage(clearPendingDecision({
+    ...params.session,
+    ...(resolvedBookId ? { activeBookId: resolvedBookId } : {}),
+    currentExecution: {
+      status: "planning",
+      ...(resolvedBookId ? { bookId: resolvedBookId } : {}),
+      ...(params.session.activeChapterNumber ? { chapterNumber: params.session.activeChapterNumber } : {}),
+      stageLabel: "agent",
+    },
+  }), {
+    role: "user",
+    content: params.input,
+    timestamp: userTimestamp,
+  });
+
+  if (!resolvedBookId && isCreateBookInstruction(params.input)) {
+    const book = parseBookCreationRequest(params.input);
+    if (book) {
+      await pipeline.initBook(book, {
+        externalContext: params.input,
+        authorIntent: params.input,
+      });
+      const responseText = `已创建《${book.title}》，接下来可以直接输入“写第1章”。`;
+      nextSession = appendInteractionMessage({
+        ...nextSession,
+        activeBookId: book.id,
+        currentExecution: {
+          status: "completed",
+          bookId: book.id,
+          stageLabel: "architect",
+        },
+      }, {
+        role: "assistant",
+        content: responseText,
+        timestamp: userTimestamp + 1,
+      });
+      await persistProjectSession(params.projectRoot, nextSession);
+      return {
+        responseText,
+        session: nextSession,
+      };
+    }
+  }
+
+  if (resolvedBookId && isWriteNextInstruction(params.input)) {
+    const writeResult = await pipeline.writeNextChapter(resolvedBookId);
+    const chapterNumber = getResultNumber(writeResult, "chapterNumber");
+    const title = getResultString(writeResult, "title");
+    const wordCount = getResultNumber(writeResult, "wordCount");
+    const status = getResultString(writeResult, "status");
+    const responseText = [
+      `已为 ${resolvedBookId} 完成`,
+      chapterNumber ? `第 ${chapterNumber} 章` : "下一章",
+      title ? `《${title}》` : "",
+      wordCount ? `，字数 ${wordCount}` : "",
+      status ? `，状态 ${status}` : "",
+      "。",
+    ].join("");
+    nextSession = appendInteractionMessage({
+      ...nextSession,
+      activeBookId: resolvedBookId,
+      currentExecution: {
+        status: "completed",
+        bookId: resolvedBookId,
+        ...(chapterNumber ? { chapterNumber } : {}),
+        stageLabel: "writer",
+      },
+      ...(chapterNumber ? { activeChapterNumber: chapterNumber } : {}),
+    }, {
+      role: "assistant",
+      content: responseText,
+      timestamp: userTimestamp + 1,
+    });
+    await persistProjectSession(params.projectRoot, nextSession);
+    return {
+      responseText,
+      session: nextSession,
+    };
+  }
+
+  const result = await runAgentSession(
+    {
+      sessionId: params.session.sessionId,
+      bookId: resolvedBookId,
+      language: config.language ?? "zh",
+      pipeline,
+      projectRoot: params.projectRoot,
+      model: client._piModel
+        ? client._piModel
+        : { provider: config.llm.provider ?? "openai", modelId: config.llm.model },
+      apiKey: client._apiKey,
+      onEvent: (event: any) => {
+        if (event.type === "message_update" && event.assistantMessageEvent?.type === "text_delta") {
+          params.onTextDelta?.(event.assistantMessageEvent.delta);
+        }
+      },
+    },
+    params.input,
+    initialMessages,
+  );
+  const createdBookId = extractCreatedBookId(result.messages);
+  const activeBookId = createdBookId ?? resolvedBookId;
+
+  if (result.responseText?.trim()) {
+    const lastAssistant = result.messages.filter((message: any) => message.role === "assistant").pop() as { thinking?: string } | undefined;
+    nextSession = appendInteractionMessage({
+      ...nextSession,
+      ...(activeBookId ? { activeBookId } : {}),
+      currentExecution: {
+        status: "completed",
+        ...(activeBookId ? { bookId: activeBookId } : {}),
+        ...(params.session.activeChapterNumber ? { chapterNumber: params.session.activeChapterNumber } : {}),
+        stageLabel: "agent",
+      },
+    }, {
+      role: "assistant",
+      content: result.responseText,
+      ...(lastAssistant?.thinking ? { thinking: lastAssistant.thinking } : {}),
+      timestamp: userTimestamp + 1,
+    });
+  } else {
+    nextSession = {
+      ...nextSession,
+      ...(activeBookId ? { activeBookId } : {}),
+      currentExecution: {
+        status: "completed",
+        ...(activeBookId ? { bookId: activeBookId } : {}),
+        ...(params.session.activeChapterNumber ? { chapterNumber: params.session.activeChapterNumber } : {}),
+        stageLabel: "agent",
+      },
+    };
+  }
+
+  await persistProjectSession(params.projectRoot, nextSession);
+  return {
+    responseText: result.responseText,
+    session: nextSession,
+  };
+}
+
+function isWriteNextInstruction(instruction: string): boolean {
+  const trimmed = instruction.trim();
+  return /^(continue|继续|继续写|写下一章|write next|下一章|再来一章)$/i.test(trimmed)
+    || /^写第\s*\d+\s*章$/i.test(trimmed)
+    || /(继续写|写下一章|下一章|再来一章|write\s+next)/i.test(trimmed);
+}
+
+function isCreateBookInstruction(instruction: string): boolean {
+  return /(建书|新建书|创建|开书|create\s+(?:a\s+)?book)/i.test(instruction)
+    && /(?:标题|书名|title)\s*[《"“]/i.test(instruction);
+}
+
+function parseBookCreationRequest(instruction: string): {
+  id: string;
+  title: string;
+  genre: string;
+  platform: "tomato" | "feilu" | "qidian" | "other";
+  language: "zh" | "en";
+  status: "outlining";
+  targetChapters: number;
+  chapterWordCount: number;
+  createdAt: string;
+  updatedAt: string;
+} | undefined {
+  const title = extractTitle(instruction);
+  if (!title) return undefined;
+  const now = new Date().toISOString();
+  return {
+    id: deriveBookId(title),
+    title,
+    genre: inferGenre(instruction),
+    platform: inferPlatform(instruction),
+    language: /[\u4e00-\u9fff]/.test(instruction) ? "zh" : "en",
+    status: "outlining",
+    targetChapters: extractNumber(instruction, /(\d+)\s*章/) ?? 200,
+    chapterWordCount: extractNumber(instruction, /(?:每章|章节|章)\D{0,8}(\d{3,5})\s*字/) ?? 3000,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+function extractTitle(instruction: string): string | undefined {
+  const match = instruction.match(/(?:标题|书名|title)\s*[《"“]([^》"”]+)[》"”]/i);
+  const title = match?.[1]?.trim();
+  return title && title.length > 0 ? title : undefined;
+}
+
+function extractNumber(instruction: string, pattern: RegExp): number | undefined {
+  const value = Number.parseInt(instruction.match(pattern)?.[1] ?? "", 10);
+  return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+function inferPlatform(instruction: string): "tomato" | "feilu" | "qidian" | "other" {
+  if (/番茄|tomato/i.test(instruction)) return "tomato";
+  if (/飞卢|feilu/i.test(instruction)) return "feilu";
+  if (/起点|qidian/i.test(instruction)) return "qidian";
+  return "other";
+}
+
+function inferGenre(instruction: string): string {
+  if (/都市/.test(instruction)) return "urban";
+  if (/悬疑|推理|mystery/i.test(instruction)) return "mystery";
+  if (/玄幻|xuanhuan/i.test(instruction)) return "xuanhuan";
+  if (/科幻|sci[-\s]?fi/i.test(instruction)) return "sci-fi";
+  if (/言情|甜宠|romance/i.test(instruction)) return "romance";
+  return "other";
+}
+
+function deriveBookId(title: string): string {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fff]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 30) || `book-${Date.now().toString(36)}`;
+}
+
+function extractCreatedBookId(messages: ReadonlyArray<unknown>): string | undefined {
+  for (const message of messages) {
+    const details = (message as { details?: { kind?: string; bookId?: string } }).details;
+    if (details?.kind === "book_created" && details.bookId) {
+      return details.bookId;
+    }
+  }
+  return undefined;
+}
+
+function getResultString(value: unknown, key: string): string | undefined {
+  const raw = (value as Record<string, unknown>)[key];
+  return typeof raw === "string" && raw.length > 0 ? raw : undefined;
+}
+
+function getResultNumber(value: unknown, key: string): number | undefined {
+  const raw = (value as Record<string, unknown>)[key];
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : undefined;
+}

package/inkos/packages/cli/src/tui/ansi.ts

@@ -0,0 +1,72 @@
+/* ── ANSI terminal helpers ── zero dependencies ── */
+
+export const reset = "\x1b[0m";
+export const bold = "\x1b[1m";
+export const dim = "\x1b[2m";
+export const italic = "\x1b[3m";
+
+export const red = "\x1b[31m";
+export const green = "\x1b[32m";
+export const yellow = "\x1b[33m";
+export const blue = "\x1b[34m";
+export const magenta = "\x1b[35m";
+export const cyan = "\x1b[36m";
+export const white = "\x1b[37m";
+export const gray = "\x1b[90m";
+export const brightRed = "\x1b[91m";
+export const brightGreen = "\x1b[92m";
+export const brightYellow = "\x1b[93m";
+export const brightBlue = "\x1b[94m";
+export const brightMagenta = "\x1b[95m";
+export const brightCyan = "\x1b[96m";
+export const brightWhite = "\x1b[97m";
+
+export const bgCyan = "\x1b[46m";
+export const bgBlue = "\x1b[44m";
+export const bgMagenta = "\x1b[45m";
+export const bgGreen = "\x1b[42m";
+export const bgYellow = "\x1b[43m";
+export const bgRed = "\x1b[41m";
+export const bgGray = "\x1b[100m";
+
+export const clearScreen = "\x1b[2J\x1b[H";
+export const showCursor = "\x1b[?25h";
+export const hideCursor = "\x1b[?25l";
+export const clearLine = "\x1b[2K\r";
+export const saveCursor = "\x1b[s";
+export const restoreCursor = "\x1b[u";
+
+export function c(text: string, ...codes: string[]): string {
+  return `${codes.join("")}${text}${reset}`;
+}
+
+export function termWidth(): number {
+  return process.stdout.columns ?? 80;
+}
+
+export function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+export function hr(char = "─"): string {
+  return char.repeat(Math.min(termWidth(), 60));
+}
+
+export function box(lines: string[], width = 56): string {
+  const top = `╭${"─".repeat(width - 2)}╮`;
+  const bot = `╰${"─".repeat(width - 2)}╯`;
+  const rows = lines.map((line) => {
+    const visible = stripAnsi(line);
+    const pad = Math.max(0, width - 2 - visible.length);
+    return `│${line}${" ".repeat(pad)}│`;
+  });
+  return [top, ...rows, bot].join("\n");
+}
+
+export function badge(text: string, bg: string, fg: string = brightWhite): string {
+  return `${bg}${fg}${bold} ${text} ${reset}`;
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}