@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/cli/src/commands/fanfic.ts

@@ -0,0 +1,183 @@
+import { Command } from "commander";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, resolve, basename } from "node:path";
+import { deriveBookIdFromTitle, normalizePlatformOrOther, PipelineRunner, type BookConfig, type FanficMode } from "@actalk/inkos-core";
+import { loadConfig, buildPipelineConfig, findProjectRoot, resolveBookId, log, logError } from "../utils.js";
+
+export const fanficCommand = new Command("fanfic")
+  .description("Fan fiction writing tools (同人创作)");
+
+fanficCommand
+  .command("init")
+  .description("Create a fanfic book from external source material")
+  .requiredOption("--title <title>", "Book title")
+  .requiredOption("--from <path>", "Source file or directory (novel text, wiki, character docs)")
+  .option("--mode <mode>", "Fanfic mode: canon|au|ooc|cp", "canon")
+  .option("--genre <genre>", "Genre", "other")
+  .option("--platform <platform>", "Target platform", "other")
+  .option("--target-chapters <n>", "Target chapter count", "100")
+  .option("--chapter-words <n>", "Words per chapter", "3000")
+  .option("--lang <language>", "Writing language: zh or en. Defaults from genre.")
+  .option("--json", "Output JSON")
+  .action(async (opts) => {
+    try {
+      const config = await loadConfig();
+      const root = findProjectRoot();
+
+      const mode = opts.mode as FanficMode;
+      if (!["canon", "au", "ooc", "cp"].includes(mode)) {
+        throw new Error(`无效的同人模式："${mode}"。可选：canon, au, ooc, cp`);
+      }
+
+      // Read source material
+      const sourcePath = resolve(opts.from);
+      const sourceText = await readSourceMaterial(sourcePath);
+      const sourceName = basename(sourcePath);
+
+      if (!sourceText || sourceText.length < 100) {
+        throw new Error(`源素材文件内容过短（${sourceText.length} 字符）。请提供至少 100 字符的原作素材。`);
+      }
+
+      const bookId = deriveBookIdFromTitle(opts.title) || `book-${Date.now().toString(36)}`;
+
+      const now = new Date().toISOString();
+      const book: BookConfig = {
+        id: bookId,
+        title: opts.title,
+        platform: normalizePlatformOrOther(opts.platform),
+        genre: opts.genre,
+        status: "outlining",
+        targetChapters: parseInt(opts.targetChapters, 10),
+        chapterWordCount: parseInt(opts.chapterWords, 10),
+        language: opts.lang ?? config.language,
+        createdAt: now,
+        updatedAt: now,
+        fanficMode: mode,
+      };
+
+      if (!opts.json) log(`Creating fanfic "${book.title}" (${mode} mode, ${book.genre})...`);
+      if (!opts.json) log(`  Source: ${sourceName} (${sourceText.length} chars)`);
+
+      const pipeline = new PipelineRunner(buildPipelineConfig(config, root));
+      await pipeline.initFanficBook(book, sourceText, sourceName, mode);
+
+      if (opts.json) {
+        log(JSON.stringify({
+          bookId,
+          title: book.title,
+          genre: book.genre,
+          fanficMode: mode,
+          source: sourceName,
+          location: `books/${bookId}/`,
+          nextStep: `inkos write next ${bookId}`,
+        }, null, 2));
+      } else {
+        log(`Fanfic created: ${bookId}`);
+        log(`  Mode: ${mode}`);
+        log(`  Location: books/${bookId}/`);
+        log(`  fanfic_canon.md + foundation generated.`);
+        log("");
+        log(`Next: inkos write next ${bookId}`);
+      }
+    } catch (e) {
+      if (opts.json) {
+        log(JSON.stringify({ error: String(e) }));
+      } else {
+        logError(`Failed to create fanfic: ${e}`);
+      }
+      process.exit(1);
+    }
+  });
+
+fanficCommand
+  .command("show")
+  .description("Display parsed fanfic canon")
+  .argument("[book-id]", "Book ID (auto-detected if only one book)")
+  .option("--json", "Output JSON")
+  .action(async (bookIdArg: string | undefined, opts) => {
+    try {
+      await loadConfig();
+      const root = findProjectRoot();
+      const bookId = await resolveBookId(bookIdArg, root);
+      const { StateManager } = await import("@actalk/inkos-core");
+      const state = new StateManager(root);
+      const bookDir = state.bookDir(bookId);
+
+      let canon: string;
+      try {
+        canon = await readFile(join(bookDir, "story/fanfic_canon.md"), "utf-8");
+      } catch {
+        throw new Error(`该书没有同人正典文件。用 inkos fanfic init 创建同人书。`);
+      }
+
+      if (opts.json) {
+        log(JSON.stringify({ bookId, fanficCanon: canon }, null, 2));
+      } else {
+        log(`Fanfic Canon for "${bookId}":\n`);
+        log(canon);
+      }
+    } catch (e) {
+      if (opts.json) {
+        log(JSON.stringify({ error: String(e) }));
+      } else {
+        logError(String(e));
+      }
+      process.exit(1);
+    }
+  });
+
+fanficCommand
+  .command("refresh")
+  .description("Re-import source material and regenerate fanfic canon")
+  .argument("[book-id]", "Book ID (auto-detected if only one book)")
+  .requiredOption("--from <path>", "Source file or directory")
+  .option("--json", "Output JSON")
+  .action(async (bookIdArg: string | undefined, opts) => {
+    try {
+      const config = await loadConfig();
+      const root = findProjectRoot();
+      const bookId = await resolveBookId(bookIdArg, root);
+      const { StateManager } = await import("@actalk/inkos-core");
+      const state = new StateManager(root);
+      const book = await state.loadBookConfig(bookId);
+
+      const mode = (book.fanficMode ?? "canon") as FanficMode;
+      const sourcePath = resolve(opts.from);
+      const sourceText = await readSourceMaterial(sourcePath);
+      const sourceName = basename(sourcePath);
+
+      if (!opts.json) log(`Refreshing fanfic canon for "${bookId}" from ${sourceName}...`);
+
+      const pipeline = new PipelineRunner(buildPipelineConfig(config, root));
+      await pipeline.importFanficCanon(bookId, sourceText, sourceName, mode);
+
+      if (opts.json) {
+        log(JSON.stringify({ bookId, source: sourceName, refreshedAt: new Date().toISOString() }));
+      } else {
+        log(`Canon refreshed from "${sourceName}".`);
+      }
+    } catch (e) {
+      if (opts.json) {
+        log(JSON.stringify({ error: String(e) }));
+      } else {
+        logError(`Failed to refresh canon: ${e}`);
+      }
+      process.exit(1);
+    }
+  });
+
+async function readSourceMaterial(sourcePath: string): Promise<string> {
+  const s = await stat(sourcePath);
+  if (s.isDirectory()) {
+    const files = await readdir(sourcePath);
+    const textFiles = files.filter((f) => f.endsWith(".txt") || f.endsWith(".md"));
+    if (textFiles.length === 0) {
+      throw new Error(`目录 ${sourcePath} 中没有 .txt 或 .md 文件。`);
+    }
+    const contents = await Promise.all(
+      textFiles.sort().map((f) => readFile(join(sourcePath, f), "utf-8")),
+    );
+    return contents.join("\n\n---\n\n");
+  }
+  return readFile(sourcePath, "utf-8");
+}

package/inkos/packages/cli/src/commands/genre.ts

@@ -0,0 +1,160 @@
+import { Command } from "commander";
+import { writeFile, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { listAvailableGenres, readGenreProfile, getBuiltinGenresDir } from "@actalk/inkos-core";
+import { findProjectRoot, log, logError } from "../utils.js";
+
+export const genreCommand = new Command("genre")
+  .description("Manage genre profiles");
+
+genreCommand
+  .command("list")
+  .description("List all available genre profiles (built-in + project)")
+  .action(async () => {
+    try {
+      const root = findProjectRoot();
+      const genres = await listAvailableGenres(root);
+
+      if (genres.length === 0) {
+        log("No genre profiles found.");
+        return;
+      }
+
+      log("Available genres:\n");
+      for (const g of genres) {
+        const tag = g.source === "project" ? "[project]" : "[builtin]";
+        log(`  ${g.id.padEnd(12)} ${g.name.padEnd(8)} ${tag}`);
+      }
+      log(`\nTotal: ${genres.length} genre(s)`);
+    } catch (e) {
+      logError(`Failed to list genres: ${e}`);
+      process.exit(1);
+    }
+  });
+
+genreCommand
+  .command("show")
+  .description("Display a genre profile")
+  .argument("<id>", "Genre ID (e.g. xuanhuan, urban, horror)")
+  .action(async (id: string) => {
+    try {
+      const root = findProjectRoot();
+      const genres = await listAvailableGenres(root);
+      const exactMatch = genres.some(g => g.id === id);
+      if (!exactMatch) {
+        logError(`Genre "${id}" not found. Available: ${genres.map(g => g.id).join(", ")}`);
+        process.exit(1);
+      }
+      const { profile, body } = await readGenreProfile(root, id);
+
+      log(`Genre: ${profile.name} (${profile.id})\n`);
+      log(`  Chapter types:      ${profile.chapterTypes.join(", ")}`);
+      log(`  Fatigue words:      ${profile.fatigueWords.join(", ")}`);
+      log(`  Numerical system:   ${profile.numericalSystem}`);
+      log(`  Power scaling:      ${profile.powerScaling}`);
+      log(`  Era research:       ${profile.eraResearch}`);
+      log(`  Pacing rule:        ${profile.pacingRule}`);
+      log(`  Satisfaction types: ${profile.satisfactionTypes.join(", ")}`);
+      log(`  Audit dimensions:   ${profile.auditDimensions.join(", ")}`);
+
+      if (body) {
+        log(`\n--- Body ---\n${body}`);
+      }
+    } catch (e) {
+      logError(`Failed to show genre: ${e}`);
+      process.exit(1);
+    }
+  });
+
+genreCommand
+  .command("create")
+  .description("Scaffold a new genre profile in the project genres/ directory")
+  .argument("<id>", "Genre ID (e.g. scifi, wuxia, romance)")
+  .option("--name <name>", "Genre display name", "")
+  .option("--numerical", "Enable numerical system", false)
+  .option("--power", "Enable power scaling", false)
+  .option("--era", "Enable era research", false)
+  .action(async (id: string, opts) => {
+    try {
+      const root = findProjectRoot();
+      const genresDir = join(root, "genres");
+      const filePath = join(genresDir, `${id}.md`);
+
+      // Check if already exists
+      try {
+        await readFile(filePath, "utf-8");
+        logError(`Genre profile already exists: ${filePath}`);
+        process.exit(1);
+      } catch { /* file doesn't exist, good */ }
+
+      await mkdir(genresDir, { recursive: true });
+
+      const name = opts.name || id;
+      const template = `---
+name: ${name}
+id: ${id}
+chapterTypes: ["推进章", "布局章", "过渡章", "回收章"]
+fatigueWords: ["震惊", "不可思议", "难以置信"]
+numericalSystem: ${opts.numerical}
+powerScaling: ${opts.power}
+eraResearch: ${opts.era}
+pacingRule: "每2-3章有一个明确的进展或反馈"
+satisfactionTypes: ["目标达成", "困难克服", "真相揭示"]
+auditDimensions: [1,2,3,6,7,8,9,10,13,14,15,16,17,18,19]
+---
+
+## 题材禁忌
+
+- (根据题材添加禁忌)
+
+## 叙事指导
+
+(根据题材描述叙事重心和风格要求)
+`;
+
+      await writeFile(filePath, template, "utf-8");
+      log(`Created genre profile: ${filePath}`);
+      log(`Edit the file to customize chapter types, fatigue words, rules, etc.`);
+    } catch (e) {
+      logError(`Failed to create genre: ${e}`);
+      process.exit(1);
+    }
+  });
+
+genreCommand
+  .command("copy")
+  .description("Copy a built-in genre profile to project for customization")
+  .argument("<id>", "Genre ID to copy (e.g. xuanhuan)")
+  .action(async (id: string) => {
+    try {
+      const root = findProjectRoot();
+      const builtinDir = getBuiltinGenresDir();
+      const srcPath = join(builtinDir, `${id}.md`);
+      const genresDir = join(root, "genres");
+      const destPath = join(genresDir, `${id}.md`);
+
+      // Check if project override already exists
+      try {
+        await readFile(destPath, "utf-8");
+        logError(`Project genre profile already exists: ${destPath}`);
+        process.exit(1);
+      } catch { /* doesn't exist, good */ }
+
+      let content: string;
+      try {
+        content = await readFile(srcPath, "utf-8");
+      } catch {
+        logError(`Built-in genre "${id}" not found. Use 'inkos genre list' to see available genres.`);
+        process.exit(1);
+        return;
+      }
+
+      await mkdir(genresDir, { recursive: true });
+      await writeFile(destPath, content, "utf-8");
+      log(`Copied to: ${destPath}`);
+      log(`This project-level copy will override the built-in profile.`);
+    } catch (e) {
+      logError(`Failed to copy genre: ${e}`);
+      process.exit(1);
+    }
+  });

package/inkos/packages/cli/src/commands/import.ts

@@ -0,0 +1,158 @@
+import { Command } from "commander";
+import { PipelineRunner, StateManager, splitChapters } from "@actalk/inkos-core";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { loadConfig, buildPipelineConfig, findProjectRoot, resolveBookId, log, logError } from "../utils.js";
+import {
+  formatImportCanonComplete,
+  formatImportCanonStart,
+  formatImportChaptersComplete,
+  formatImportChaptersDiscovery,
+  formatImportChaptersResume,
+  resolveCliLanguage,
+} from "../localization.js";
+
+export const importCommand = new Command("import")
+  .description("Import external data into a book");
+
+importCommand
+  .command("canon")
+  .description("Import parent book's canon for spinoff writing")
+  .argument("[target-book-id]", "Target book ID (auto-detected if only one book)")
+  .requiredOption("--from <parent-book-id>", "Parent book ID to import canon from")
+  .option("--json", "Output JSON")
+  .action(async (targetBookIdArg: string | undefined, opts) => {
+    try {
+      const root = findProjectRoot();
+      const targetBookId = await resolveBookId(targetBookIdArg, root);
+      const config = await loadConfig();
+      const state = new StateManager(root);
+      const targetBook = await state.loadBookConfig(targetBookId);
+      const language = resolveCliLanguage(targetBook.language);
+
+      const pipeline = new PipelineRunner(buildPipelineConfig(config, root));
+
+      if (!opts.json) log(formatImportCanonStart(language, opts.from, targetBookId));
+
+      await pipeline.importCanon(targetBookId, opts.from);
+
+      if (opts.json) {
+        log(JSON.stringify({
+          targetBookId,
+          parentBookId: opts.from,
+          output: "story/parent_canon.md",
+        }, null, 2));
+      } else {
+        for (const line of formatImportCanonComplete(language)) {
+          log(line);
+        }
+      }
+    } catch (e) {
+      if (opts.json) {
+        log(JSON.stringify({ error: String(e) }));
+      } else {
+        logError(`Canon import failed: ${e}`);
+      }
+      process.exit(1);
+    }
+  });
+
+importCommand
+  .command("chapters")
+  .description("Import existing chapters for continuation writing. Reverse-engineers all truth files.")
+  .argument("[book-id]", "Target book ID (auto-detected if only one book)")
+  .requiredOption("--from <path>", "Path to a text file (auto-split) or directory of .md/.txt files")
+  .option("--split <regex>", "Custom regex for chapter splitting (single-file mode)")
+  .option("--resume-from <n>", "Resume from chapter N (for interrupted imports)", parseInt)
+  .option("--series", "Treat as a new series (shared universe, independent story) instead of direct continuation")
+  .option("--json", "Output JSON")
+  .action(async (bookIdArg: string | undefined, opts) => {
+    try {
+      const root = findProjectRoot();
+      const bookId = await resolveBookId(bookIdArg, root);
+      const config = await loadConfig();
+
+      const state = new StateManager(root);
+      const book = await state.loadBookConfig(bookId);
+      const language = resolveCliLanguage(book.language);
+      const existingChapterCount = (await state.getNextChapterNumber(bookId)) - 1;
+      if (existingChapterCount > 0 && !opts.resumeFrom) {
+        throw new Error(
+          `Book "${bookId}" already has ${existingChapterCount} chapter(s). ` +
+          `Use --resume-from <n> to append, or delete existing chapters first.`
+        );
+      }
+
+      const fromPath = resolve(opts.from);
+      const fromStat = await stat(fromPath);
+
+      let chapters: Array<{ title: string; content: string }>;
+
+      if (fromStat.isDirectory()) {
+        // Directory mode: read each .md/.txt file in sorted order
+        const entries = await readdir(fromPath);
+        const textFiles = entries
+          .filter((f) => f.endsWith(".md") || f.endsWith(".txt"))
+          .sort();
+
+        if (textFiles.length === 0) {
+          throw new Error(`No .md or .txt files found in ${fromPath}`);
+        }
+
+        chapters = await Promise.all(
+          textFiles.map(async (f) => {
+            const content = await readFile(join(fromPath, f), "utf-8");
+            const title = f.replace(/\.(md|txt)$/, "").replace(/^\d+[_\-\s]*/, "");
+            return { title, content };
+          }),
+        );
+      } else {
+        // Single file mode: split by chapter pattern
+        const text = await readFile(fromPath, "utf-8");
+        chapters = [...splitChapters(text, opts.split)];
+
+        if (chapters.length === 0) {
+          throw new Error(
+            `No chapters found in ${fromPath}. ` +
+            `Default pattern matches "第X章" and "Chapter X". Use --split to provide a custom regex.`,
+          );
+        }
+      }
+
+      if (!opts.json) {
+        log(formatImportChaptersDiscovery(language, chapters.length, bookId));
+        if (opts.resumeFrom) {
+          log(formatImportChaptersResume(language, opts.resumeFrom));
+        }
+      }
+
+      const pipeline = new PipelineRunner(buildPipelineConfig(config, root));
+
+      const result = await pipeline.importChapters({
+        bookId,
+        chapters,
+        resumeFrom: opts.resumeFrom,
+        importMode: opts.series ? "series" : "continuation",
+      });
+
+      if (opts.json) {
+        log(JSON.stringify(result, null, 2));
+      } else {
+        for (const line of formatImportChaptersComplete(language, {
+          importedCount: result.importedCount,
+          totalWords: result.totalWords,
+          nextChapter: result.nextChapter,
+          continueBookId: bookId,
+        })) {
+          log(line);
+        }
+      }
+    } catch (e) {
+      if (opts.json) {
+        log(JSON.stringify({ error: String(e) }));
+      } else {
+        logError(`Chapter import failed: ${e}`);
+      }
+      process.exit(1);
+    }
+  });

package/inkos/packages/cli/src/commands/init.ts

@@ -0,0 +1,47 @@
+import { Command } from "commander";
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { log, logError } from "../utils.js";
+import { initializeProjectDirectory } from "../project-bootstrap.js";
+
+export const initCommand = new Command("init")
+  .description("Initialize an InkOS project (current directory by default)")
+  .argument("[name]", "Project name (creates subdirectory). Omit to init current directory.")
+  .option("--lang <language>", "Default writing language: zh (Chinese) or en (English)", "zh")
+  .action(async (name: string | undefined, opts: { lang?: string }) => {
+    const projectDir = name ? resolve(process.cwd(), name) : process.cwd();
+
+    try {
+      await mkdir(projectDir, { recursive: true });
+      await initializeProjectDirectory(projectDir, {
+        language: (opts.lang === "en" ? "en" : "zh"),
+        overwriteSupportFiles: true,
+      });
+
+      log(`Project initialized at ${projectDir}`);
+      log("");
+      const isEnglish = (opts.lang ?? "zh") === "en";
+      const exampleCreate = isEnglish
+        ? "  inkos book create --title 'My Novel' --genre progression --platform royalroad --lang en"
+        : "  inkos book create --title '我的小说' --genre xuanhuan --platform tomato";
+      if (global) {
+        log("Global LLM config detected. Ready to go!");
+        log("");
+        log("Next steps:");
+        if (name) log(`  cd ${name}`);
+        log(exampleCreate);
+      } else {
+        log("Next steps:");
+        if (name) log(`  cd ${name}`);
+        log("  # Option 1: Set global config (recommended, one-time):");
+        log("  inkos config set-global --provider openai --base-url <your-api-url> --api-key <your-key> --model <your-model>");
+        log("  # Option 2: Edit .env for this project only");
+        log("");
+        log(exampleCreate);
+      }
+      log("  inkos write next <book-id>");
+    } catch (e) {
+      logError(`Failed to initialize project: ${e}`);
+      process.exit(1);
+    }
+  });

package/inkos/packages/cli/src/commands/interact.ts

@@ -0,0 +1,109 @@
+import { Command } from "commander";
+import {
+  processProjectInteractionInput,
+  type InteractionRuntimeTools,
+} from "@actalk/inkos-core";
+import { createInteractionTools } from "../interaction/tools.js";
+
+export interface InteractCommandHooks {
+  readonly runInteraction?: (params: {
+    readonly projectRoot: string;
+    readonly input: string;
+    readonly activeBookId?: string;
+    readonly tools: InteractionRuntimeTools;
+  }) => Promise<{
+    readonly request: unknown;
+    readonly responseText?: string;
+    readonly session: {
+      readonly automationMode: string;
+      readonly activeBookId?: string;
+      readonly currentExecution?: unknown;
+      readonly pendingDecision?: unknown;
+      readonly messages: ReadonlyArray<unknown>;
+      readonly events: ReadonlyArray<unknown>;
+    };
+  }>;
+  readonly createTools?: (projectRoot: string) => Promise<InteractionRuntimeTools>;
+  readonly readInput?: () => Promise<string>;
+}
+
+async function readInteractionInput(
+  args: ReadonlyArray<string>,
+  explicitMessage: string | undefined,
+  readInput?: () => Promise<string>,
+): Promise<string> {
+  const explicit = explicitMessage?.trim();
+  if (explicit) {
+    return explicit;
+  }
+
+  const inline = args.join(" ").trim();
+  if (inline) {
+    return inline;
+  }
+
+  if (readInput) {
+    const provided = (await readInput()).trim();
+    if (provided) {
+      return provided;
+    }
+  }
+
+  if (!process.stdin.isTTY) {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk as Buffer);
+    }
+    const piped = Buffer.concat(chunks).toString("utf-8").trim();
+    if (piped) {
+      return piped;
+    }
+  }
+
+  throw new Error("Interaction message is required. Pass text arguments or pipe input via stdin.");
+}
+
+export function createInteractCommand(hooks: InteractCommandHooks = {}): Command {
+  return new Command("interact")
+    .description("Run a shared natural-language interaction against the current project")
+    .argument("[message...]", "Natural-language message")
+    .option("--message <text>", "Explicit natural-language message")
+    .option("--book <bookId>", "Bind a specific active book for this interaction")
+    .option("--json", "Emit structured JSON for external agents")
+    .action(async (messageArgs: ReadonlyArray<string>, opts) => {
+      const input = await readInteractionInput(messageArgs, opts.message, hooks.readInput);
+      const projectRoot = process.cwd();
+      const tools = hooks.createTools
+        ? await hooks.createTools(projectRoot)
+        : hooks.runInteraction
+          ? ({} as InteractionRuntimeTools)
+          : await createInteractionTools(projectRoot, undefined, { requireApiKey: false });
+      const runInteraction = hooks.runInteraction ?? processProjectInteractionInput;
+      const result = await runInteraction({
+        projectRoot,
+        input,
+        activeBookId: opts.book,
+        tools,
+      });
+
+      if (opts.json) {
+        process.stdout.write(`${JSON.stringify({
+          request: result.request,
+          responseText: result.responseText,
+          session: result.session,
+          currentExecution: result.session.currentExecution ?? null,
+          pendingDecision: result.session.pendingDecision ?? null,
+          events: result.session.events,
+        }, null, 2)}\n`);
+        return;
+      }
+
+      const text = result.responseText
+        ?? (result.session.messages.at(-1) && "content" in (result.session.messages.at(-1) as Record<string, unknown>)
+          ? String((result.session.messages.at(-1) as Record<string, unknown>).content)
+          : "");
+      if (text) {
+        process.stdout.write(`${text}\n`);
+      }
+    });
+}