@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/cli/src/localization.ts

@@ -0,0 +1,215 @@
+import { formatLengthCount, resolveLengthCountingMode } from "@actalk/inkos-core";
+
+export type CliLanguage = "zh" | "en";
+
+type WriteIssue = {
+  readonly severity: string;
+  readonly category: string;
+  readonly description: string;
+};
+
+type WriteResultShape = {
+  readonly chapterNumber: number;
+  readonly title: string;
+  readonly wordCount: number;
+  readonly status: string;
+  readonly revised: boolean;
+  readonly issues: ReadonlyArray<WriteIssue>;
+  readonly auditPassed?: boolean;
+  readonly passedAudit?: boolean;
+};
+
+type ImportResultShape = {
+  readonly importedCount: number;
+  readonly totalWords: number;
+  readonly nextChapter: number;
+  readonly continueBookId: string;
+};
+
+function localize(language: CliLanguage, messages: { zh: string; en: string }): string {
+  return language === "en" ? messages.en : messages.zh;
+}
+
+export function resolveCliLanguage(language?: string): CliLanguage {
+  return language === "en" ? "en" : "zh";
+}
+
+export function formatBookCreateCreating(
+  language: CliLanguage,
+  title: string,
+  genre: string,
+  platform: string,
+): string {
+  return localize(language, {
+    zh: `创建书籍 "${title}"（${genre} / ${platform}）...`,
+    en: `Creating book "${title}" (${genre} / ${platform})...`,
+  });
+}
+
+export function formatBookCreateCreated(language: CliLanguage, bookId: string): string {
+  return localize(language, {
+    zh: `已创建书籍：${bookId}`,
+    en: `Book created: ${bookId}`,
+  });
+}
+
+export function formatBookCreateLocation(language: CliLanguage, bookId: string): string {
+  return localize(language, {
+    zh: `  位置：books/${bookId}/`,
+    en: `  Location: books/${bookId}/`,
+  });
+}
+
+export function formatBookCreateFoundationReady(language: CliLanguage): string {
+  return localize(language, {
+    zh: "  故事圣经、大纲和书籍规则已生成。",
+    en: "  Story bible, outline, book rules generated.",
+  });
+}
+
+export function formatBookCreateNextStep(language: CliLanguage, bookId: string): string {
+  return localize(language, {
+    zh: `下一步：inkos write next ${bookId}`,
+    en: `Next: inkos write next ${bookId}`,
+  });
+}
+
+export function formatWriteNextProgress(
+  language: CliLanguage,
+  current: number,
+  total: number,
+  bookId: string,
+): string {
+  return localize(language, {
+    zh: `[${current}/${total}] 为「${bookId}」撰写章节...`,
+    en: `[${current}/${total}] Writing chapter for "${bookId}"...`,
+  });
+}
+
+export function formatWriteNextResultLines(
+  language: CliLanguage,
+  result: WriteResultShape,
+): string[] {
+  const auditPassed = result.auditPassed ?? result.passedAudit ?? false;
+  const lengthLabel = formatLengthCount(result.wordCount, resolveLengthCountingMode(language));
+  const lines = [
+    localize(language, {
+      zh: `  第${result.chapterNumber}章：${result.title}`,
+      en: `  Chapter ${result.chapterNumber}: ${result.title}`,
+    }),
+    localize(language, {
+      zh: `  字数：${lengthLabel}`,
+      en: `  Length: ${lengthLabel}`,
+    }),
+    localize(language, {
+      zh: `  审计：${auditPassed ? "通过" : "需复核"}`,
+      en: `  Audit: ${auditPassed ? "PASSED" : "NEEDS REVIEW"}`,
+    }),
+  ];
+
+  if (result.revised) {
+    lines.push(localize(language, {
+      zh: "  自动修正：已执行（已修复关键问题）",
+      en: "  Auto-revised: YES (critical issues were fixed)",
+    }));
+  }
+
+  lines.push(localize(language, {
+    zh: `  状态：${result.status}`,
+    en: `  Status: ${result.status}`,
+  }));
+
+  if (result.issues.length > 0) {
+    lines.push(localize(language, {
+      zh: "  问题：",
+      en: "  Issues:",
+    }));
+    for (const issue of result.issues) {
+      lines.push(`    [${issue.severity}] ${issue.category}: ${issue.description}`);
+    }
+  }
+
+  return lines;
+}
+
+export function formatWriteNextComplete(language: CliLanguage): string {
+  return localize(language, {
+    zh: "完成。",
+    en: "Done.",
+  });
+}
+
+export function formatImportChaptersDiscovery(
+  language: CliLanguage,
+  chapterCount: number,
+  bookId: string,
+): string {
+  return localize(language, {
+    zh: `发现 ${chapterCount} 章，准备导入到「${bookId}」。`,
+    en: `Found ${chapterCount} chapters to import into "${bookId}".`,
+  });
+}
+
+export function formatImportChaptersResume(
+  language: CliLanguage,
+  resumeFrom: number,
+): string {
+  return localize(language, {
+    zh: `从第 ${resumeFrom} 章继续导入。`,
+    en: `Resuming from chapter ${resumeFrom}.`,
+  });
+}
+
+export function formatImportChaptersComplete(
+  language: CliLanguage,
+  result: ImportResultShape,
+): string[] {
+  const lengthLabel = formatLengthCount(result.totalWords, resolveLengthCountingMode(language));
+  return [
+    localize(language, {
+      zh: "导入完成：",
+      en: "Import complete:",
+    }),
+    localize(language, {
+      zh: `  已导入章节：${result.importedCount}`,
+      en: `  Chapters imported: ${result.importedCount}`,
+    }),
+    localize(language, {
+      zh: `  总长度：${lengthLabel}`,
+      en: `  Total length: ${lengthLabel}`,
+    }),
+    localize(language, {
+      zh: `  下一章编号：${result.nextChapter}`,
+      en: `  Next chapter number: ${result.nextChapter}`,
+    }),
+    "",
+    localize(language, {
+      zh: `运行 "inkos write next ${result.continueBookId}" 继续写作。`,
+      en: `Run "inkos write next ${result.continueBookId}" to continue writing.`,
+    }),
+  ];
+}
+
+export function formatImportCanonStart(
+  language: CliLanguage,
+  parentBookId: string,
+  targetBookId: string,
+): string {
+  return localize(language, {
+    zh: `把 "${parentBookId}" 的正典导入到 "${targetBookId}"...`,
+    en: `Importing canon from "${parentBookId}" into "${targetBookId}"...`,
+  });
+}
+
+export function formatImportCanonComplete(language: CliLanguage): string[] {
+  return [
+    localize(language, {
+      zh: "正典已导入：story/parent_canon.md",
+      en: "Canon imported: story/parent_canon.md",
+    }),
+    localize(language, {
+      zh: "Writer 和 auditor 会在番外模式下自动识别这个文件。",
+      en: "Writer and auditor will auto-detect this file for spinoff mode.",
+    }),
+  ];
+}

package/inkos/packages/cli/src/program.ts

@@ -0,0 +1,106 @@
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { configCommand } from "./commands/config.js";
+import { bookCommand } from "./commands/book.js";
+import { writeCommand } from "./commands/write.js";
+import { reviewCommand } from "./commands/review.js";
+import { statusCommand } from "./commands/status.js";
+import { radarCommand } from "./commands/radar.js";
+import { upCommand, downCommand } from "./commands/daemon.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { exportCommand } from "./commands/export.js";
+import { draftCommand } from "./commands/draft.js";
+import { auditCommand } from "./commands/audit.js";
+import { reviseCommand } from "./commands/revise.js";
+import { agentCommand } from "./commands/agent.js";
+import { planCommand } from "./commands/plan.js";
+import { composeCommand } from "./commands/compose.js";
+import { genreCommand } from "./commands/genre.js";
+import { updateCommand } from "./commands/update.js";
+import { detectCommand } from "./commands/detect.js";
+import { styleCommand } from "./commands/style.js";
+import { analyticsCommand } from "./commands/analytics.js";
+import { evalCommand } from "./commands/eval.js";
+import { importCommand } from "./commands/import.js";
+import { fanficCommand } from "./commands/fanfic.js";
+import { shortCommand } from "./commands/short-fiction.js";
+import { createStudioCommand, launchStudioEntry } from "./commands/studio.js";
+import { consolidateCommand } from "./commands/consolidate.js";
+import { createInteractCommand, type InteractCommandHooks } from "./commands/interact.js";
+import { createTuiCommand } from "./commands/tui.js";
+import { launchTui } from "./tui/app.js";
+
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json") as { version: string };
+
+export interface ProgramHooks {
+  readonly launchTui?: (projectRoot: string) => Promise<void> | void;
+  readonly launchStudio?: (projectRoot: string, port: string) => Promise<void> | void;
+  readonly runInteraction?: InteractCommandHooks["runInteraction"];
+  readonly readInteractionInput?: InteractCommandHooks["readInput"];
+}
+
+export function createProgram(hooks: ProgramHooks = {}): Command {
+  const program = new Command();
+
+  program
+    .name("inkos")
+    .description("InkOS — Multi-agent novel production system")
+    .version(version)
+    .enablePositionalOptions()
+    .option("--service <service>", "Override LLM service for this CLI run")
+    .option("--model <model>", "Override LLM model for this CLI run")
+    .option("--api-key-env <envVar>", "Read LLM API key from this environment variable for this CLI run")
+    .option("--base-url <url>", "Override LLM base URL for this CLI run")
+    .option("--api-format <chat|responses>", "Override LLM API format for this CLI run")
+    .option("--stream", "Force streaming LLM responses for this CLI run")
+    .option("--no-stream", "Force non-streaming LLM responses for this CLI run")
+    .action(async () => {
+      await launchStudioEntry(process.cwd(), "4567", { launchStudio: hooks.launchStudio });
+    });
+
+  program.addCommand(initCommand);
+  program.addCommand(configCommand);
+  program.addCommand(bookCommand);
+  program.addCommand(writeCommand);
+  program.addCommand(reviewCommand);
+  program.addCommand(statusCommand);
+  program.addCommand(radarCommand);
+  program.addCommand(upCommand);
+  program.addCommand(downCommand);
+  program.addCommand(doctorCommand);
+  program.addCommand(exportCommand);
+  program.addCommand(draftCommand);
+  program.addCommand(auditCommand);
+  program.addCommand(reviseCommand);
+  program.addCommand(agentCommand);
+  program.addCommand(planCommand);
+  program.addCommand(composeCommand);
+  program.addCommand(genreCommand);
+  program.addCommand(updateCommand);
+  program.addCommand(detectCommand);
+  program.addCommand(styleCommand);
+  program.addCommand(analyticsCommand);
+  program.addCommand(evalCommand);
+  program.addCommand(importCommand);
+  program.addCommand(fanficCommand);
+  program.addCommand(shortCommand);
+  program.addCommand(createStudioCommand({ launchStudio: hooks.launchStudio }));
+  program.addCommand(consolidateCommand);
+  program.addCommand(createInteractCommand({
+    runInteraction: hooks.runInteraction,
+    readInput: hooks.readInteractionInput,
+  }));
+  program.addCommand(createTuiCommand({ launchTui: hooks.launchTui }));
+
+  return program;
+}
+
+export async function runProgram(
+  argv: string[] = process.argv,
+  hooks: ProgramHooks = {},
+): Promise<void> {
+  const program = createProgram(hooks);
+  await program.parseAsync(argv);
+}

package/inkos/packages/cli/src/progress-text.ts

@@ -0,0 +1,85 @@
+import {
+  formatImportChaptersComplete,
+  formatImportChaptersDiscovery,
+  formatImportChaptersResume,
+  formatWriteNextComplete,
+  formatWriteNextProgress,
+  formatWriteNextResultLines,
+  type CliLanguage,
+} from "./localization.js";
+
+export { type CliLanguage };
+
+export function formatWriteStartLine(
+  language: CliLanguage,
+  current: number,
+  total: number,
+  bookId: string,
+): string {
+  return formatWriteNextProgress(language, current, total, bookId);
+}
+
+export function formatWriteCompletionLines(
+  language: CliLanguage,
+  result: {
+    readonly chapterNumber: number;
+    readonly title: string;
+    readonly wordCount: number;
+    readonly passedAudit: boolean;
+    readonly revised: boolean;
+    readonly status: string;
+    readonly issues: ReadonlyArray<{
+      readonly severity: string;
+      readonly category: string;
+      readonly description: string;
+    }>;
+  },
+): string[] {
+  return [...formatWriteNextResultLines(language, result), ""];
+}
+
+export function formatWriteDoneLine(language: CliLanguage): string {
+  return formatWriteNextComplete(language);
+}
+
+export function formatImportDiscoveryLine(
+  language: CliLanguage,
+  chapterCount: number,
+  bookId: string,
+): string {
+  return formatImportChaptersDiscovery(language, chapterCount, bookId);
+}
+
+export function formatImportResumeLine(
+  language: CliLanguage,
+  resumeFrom: number,
+): string {
+  return formatImportChaptersResume(language, resumeFrom);
+}
+
+export function formatImportCompletionLines(
+  language: CliLanguage,
+  result: {
+    readonly importedCount: number;
+    readonly totalCountLabel: string;
+    readonly nextChapter: number;
+    readonly bookId: string;
+  },
+): string[] {
+  return [
+    language === "en" ? "Import complete:" : "导入完成：",
+    language === "en"
+      ? `  Chapters imported: ${result.importedCount}`
+      : `  已导入章节：${result.importedCount}`,
+    language === "en"
+      ? `  Total length: ${result.totalCountLabel}`
+      : `  总长度：${result.totalCountLabel}`,
+    language === "en"
+      ? `  Next chapter number: ${result.nextChapter}`
+      : `  下一章编号：${result.nextChapter}`,
+    "",
+    language === "en"
+      ? `Run "inkos write next ${result.bookId}" to continue writing.`
+      : `运行 "inkos write next ${result.bookId}" 继续写作。`,
+  ];
+}

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

@@ -0,0 +1,175 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { GLOBAL_ENV_PATH } from "./utils.js";
+
+export interface ProjectBootstrapOptions {
+  readonly language?: "zh" | "en";
+  readonly overwriteSupportFiles?: boolean;
+}
+
+async function hasGlobalConfig(): Promise<boolean> {
+  try {
+    const content = await readFile(GLOBAL_ENV_PATH, "utf-8");
+    return content.includes("INKOS_LLM_API_KEY=") && !content.includes("your-api-key-here");
+  } catch {
+    return false;
+  }
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function writeMaybe(path: string, content: string, overwrite: boolean): Promise<void> {
+  if (!overwrite && await exists(path)) {
+    return;
+  }
+  await writeFile(path, content, "utf-8");
+}
+
+const DEFAULT_GITIGNORE_ENTRIES = [".env", "node_modules/", ".DS_Store"] as const;
+
+export async function ensureProjectGitignore(projectDir: string): Promise<void> {
+  const path = join(projectDir, ".gitignore");
+  let existing = "";
+  if (await exists(path)) {
+    existing = await readFile(path, "utf-8");
+  }
+
+  const existingEntries = new Set(
+    existing
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0 && !line.startsWith("#")),
+  );
+  const missing = DEFAULT_GITIGNORE_ENTRIES.filter((entry) => !existingEntries.has(entry));
+  if (missing.length === 0) return;
+
+  if (!existing) {
+    await writeFile(path, `${missing.join("\n")}\n`, "utf-8");
+    return;
+  }
+
+  const separator = existing.endsWith("\n") ? "" : "\n";
+  await writeFile(path, `${existing}${separator}${missing.join("\n")}\n`, "utf-8");
+}
+
+function buildProjectConfig(projectDir: string, language: "zh" | "en") {
+  return {
+    name: basename(projectDir),
+    version: "0.1.0" as const,
+    language,
+    llm: {
+      provider: "openai" as const,
+      service: "custom",
+      configSource: "studio" as const,
+      baseUrl: "",
+      model: "",
+      apiFormat: "chat" as const,
+      stream: true,
+    },
+    notify: [],
+    detection: {
+      enabled: false,
+      provider: "llm" as const,
+      threshold: 0.5,
+      autoRewrite: false,
+    },
+    inputGovernanceMode: "v2" as const,
+    daemon: {
+      schedule: {
+        radarCron: "0 */6 * * *",
+        writeCron: "*/15 * * * *",
+      },
+      maxConcurrentBooks: 3,
+    },
+  };
+}
+
+function buildProjectEnvTemplate(globalConfigured: boolean): string {
+  if (globalConfigured) {
+    return [
+      "# Project-level LLM overrides (optional)",
+      "# Global config at ~/.inkos/.env will be used by default.",
+      "# Switch Studio to '使用 Studio 配置' if you want per-project service settings.",
+      "# Uncomment below to override for this project only:",
+      "# INKOS_LLM_PROVIDER=openai",
+      "# INKOS_LLM_BASE_URL=",
+      "# INKOS_LLM_API_KEY=",
+      "# INKOS_LLM_MODEL=",
+      "",
+      "# Web search (optional):",
+      "# TAVILY_API_KEY=tvly-xxxxx",
+      "",
+    ].join("\n");
+  }
+
+  return [
+    "# Optional project-level LLM overrides",
+    "# Studio can manage provider / model / key without editing this file.",
+    "# Uncomment only if you want this directory to force env-based config:",
+    "# INKOS_LLM_PROVIDER=openai",
+    "# INKOS_LLM_BASE_URL=",
+    "# INKOS_LLM_API_KEY=",
+    "# INKOS_LLM_MODEL=",
+    "# INKOS_LLM_API_FORMAT=chat",
+    "# INKOS_LLM_STREAM=true",
+    "",
+    "# Web search (optional):",
+    "# TAVILY_API_KEY=tvly-xxxxx",
+    "",
+  ].join("\n");
+}
+
+export async function initializeProjectDirectory(
+  projectDir: string,
+  options: ProjectBootstrapOptions = {},
+): Promise<void> {
+  const language = options.language ?? "zh";
+  const overwriteSupportFiles = options.overwriteSupportFiles ?? true;
+  const configPath = join(projectDir, "inkos.json");
+
+  if (await exists(configPath)) {
+    throw new Error(`inkos.json already exists in ${projectDir}. Use a different directory or delete the existing project.`);
+  }
+
+  await mkdir(projectDir, { recursive: true });
+  await mkdir(join(projectDir, "books"), { recursive: true });
+  await mkdir(join(projectDir, "radar"), { recursive: true });
+
+  await writeFile(
+    configPath,
+    JSON.stringify(buildProjectConfig(projectDir, language), null, 2),
+    "utf-8",
+  );
+
+  const globalConfigured = await hasGlobalConfig();
+
+  await Promise.all([
+    writeMaybe(join(projectDir, ".env"), buildProjectEnvTemplate(globalConfigured), overwriteSupportFiles),
+    ensureProjectGitignore(projectDir),
+    writeMaybe(join(projectDir, ".nvmrc"), "22\n", overwriteSupportFiles),
+    writeMaybe(join(projectDir, ".node-version"), "22\n", overwriteSupportFiles),
+  ]);
+}
+
+export async function ensureProjectDirectoryInitialized(
+  projectDir: string,
+  options: Omit<ProjectBootstrapOptions, "overwriteSupportFiles"> = {},
+): Promise<boolean> {
+  const configPath = join(projectDir, "inkos.json");
+  if (await exists(configPath)) {
+    return false;
+  }
+
+  await initializeProjectDirectory(projectDir, {
+    language: options.language,
+    overwriteSupportFiles: false,
+  });
+  return true;
+}