@zwbigi/ink-xy 0.1.2 → 0.1.4

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

@@ -0,0 +1,397 @@
+/* ── Auto-init & environment detection for TUI ── */
+
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, basename } from "node:path";
+import readline from "node:readline/promises";
+import {
+  c, bold, dim, italic,
+  cyan, green, yellow, gray, red,
+  brightCyan, brightGreen, brightWhite,
+} from "./ansi.js";
+import { resolveTuiLocale, type TuiLocale } from "./i18n.js";
+import { GLOBAL_ENV_PATH, loadConfig } from "../utils.js";
+import { ensureProjectGitignore } from "../project-bootstrap.js";
+
+const PROVIDERS = ["openai", "anthropic", "kkaiapi", "custom"] as const;
+const KKAIAPI_BASE_URL = "https://api.kkaiapi.com/v1";
+type SetupProvider = typeof PROVIDERS[number];
+type RuntimeProvider = "openai" | "anthropic" | "custom";
+
+export function resolveSetupProvider(provider: string, baseUrl: string): RuntimeProvider {
+  const normalizedProvider = PROVIDERS.includes(provider.trim() as SetupProvider)
+    ? provider.trim() as SetupProvider
+    : "openai";
+  const normalizedUrl = baseUrl.trim().toLowerCase();
+  if (normalizedUrl.includes("api.kimi.com/coding")) {
+    return "anthropic";
+  }
+  if (normalizedProvider === "anthropic" || normalizedProvider === "custom") {
+    return normalizedProvider;
+  }
+  return "openai";
+}
+
+export function resolveSetupService(provider: string, baseUrl: string): string | undefined {
+  const normalizedProvider = provider.trim().toLowerCase();
+  const normalizedUrl = baseUrl.trim().toLowerCase();
+  if (normalizedProvider === "kkaiapi" || normalizedUrl.includes("api.kkaiapi.com")) {
+    return "kkaiapi";
+  }
+  return undefined;
+}
+
+interface SetupResult {
+  readonly projectRoot: string;
+  readonly hasLlmConfig: boolean;
+}
+
+export interface InteractiveSetupCopy {
+  readonly title: string;
+  readonly subtitle: string;
+  readonly steps: {
+    readonly provider: string;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly model: string;
+    readonly scope: string;
+  };
+  readonly hints: {
+    readonly provider: string;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly model: string;
+    readonly scope: string;
+  };
+  readonly defaults: {
+    readonly provider: string;
+    readonly baseUrl: string;
+    readonly scope: string;
+  };
+  readonly scopeChoices: {
+    readonly global: string;
+    readonly project: string;
+  };
+  readonly savedTo: string;
+}
+
+export function buildInteractiveSetupCopy(locale: TuiLocale): InteractiveSetupCopy {
+  if (locale === "en") {
+    return {
+      title: "LLM Setup",
+      subtitle: "Configure your model provider to start writing.",
+      steps: {
+        provider: "Provider",
+        baseUrl: "Base URL",
+        apiKey: "API Key",
+        model: "Model",
+        scope: "Save scope",
+      },
+      hints: {
+        provider: "openai / anthropic / kkaiapi / custom (OpenAI-compatible proxy)",
+        baseUrl: "Your API endpoint",
+        apiKey: "Paste the API key for the selected provider.",
+        model: "e.g. gpt-4o, claude-sonnet-4-20250514, deepseek-chat",
+        scope: "global = all projects, project = this directory only",
+      },
+      defaults: {
+        provider: "openai",
+        baseUrl: "(default)",
+        scope: "[global]",
+      },
+      scopeChoices: {
+        global: "all projects",
+        project: "this directory",
+      },
+      savedTo: "Saved to",
+    };
+  }
+
+  return {
+    title: "模型配置",
+    subtitle: "配置模型服务后即可开始使用。",
+    steps: {
+      provider: "服务提供方",
+      baseUrl: "接口地址",
+      apiKey: "API 密钥",
+      model: "模型",
+      scope: "保存范围",
+    },
+    hints: {
+      provider: "openai / anthropic / kkaiapi / custom（兼容 OpenAI 的代理）",
+      baseUrl: "你的 API 入口地址",
+      apiKey: "粘贴所选服务商的 API Key",
+      model: "例如 gpt-5.4、claude-sonnet-4-20250514、deepseek-chat",
+      scope: "global = 所有项目，project = 仅当前目录",
+    },
+    defaults: {
+      provider: "openai",
+      baseUrl: "（默认）",
+      scope: "[global]",
+    },
+    scopeChoices: {
+      global: "所有项目",
+      project: "当前目录",
+    },
+    savedTo: "已保存到",
+  };
+}
+
+export function buildAutoInitMessages(projectName: string, locale: TuiLocale): {
+  readonly initializing: string;
+  readonly initialized: string;
+  readonly envTemplateHeader: string;
+} {
+  if (locale === "en") {
+    return {
+      initializing: `Initializing project in ${projectName}/ ...`,
+      initialized: "Project initialized",
+      envTemplateHeader: "# LLM Configuration — run inkos tui to configure interactively",
+    };
+  }
+
+  return {
+    initializing: `正在初始化项目：${projectName}/ ...`,
+    initialized: "项目已初始化",
+    envTemplateHeader: "# LLM 配置 —— 运行 inkos tui 进行交互式配置",
+  };
+}
+
+export async function ensureProject(cwd: string): Promise<SetupResult> {
+  const configPath = join(cwd, "inkos.json");
+  const hasConfig = await fileExists(configPath);
+
+  if (!hasConfig) {
+    await autoInit(cwd);
+  }
+
+  const hasLlm = await hasLlmConfig(cwd);
+  return { projectRoot: cwd, hasLlmConfig: hasLlm };
+}
+
+export async function interactiveLlmSetup(
+  projectRoot: string,
+): Promise<void> {
+  const projectLanguage = await detectProjectLanguage(projectRoot);
+  const locale = resolveTuiLocale(process.env, projectLanguage);
+  const copy = buildInteractiveSetupCopy(locale);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    console.log();
+    console.log(`  ${c("◈", brightCyan)} ${c(copy.title, bold, brightWhite)}`);
+    console.log(c(`  ${copy.subtitle}`, dim));
+    console.log();
+
+    // Provider
+    console.log(`  ${c("1", cyan)}  ${c(copy.steps.provider, gray)}`);
+    console.log(c(`     ${copy.hints.provider}`, dim));
+    const providerInput = await rl.question(`     ${c("❯", cyan)} `);
+    const provider = PROVIDERS.includes(providerInput.trim() as SetupProvider)
+      ? providerInput.trim() as SetupProvider
+      : copy.defaults.provider as SetupProvider;
+    const providerDefaultBaseUrl = provider === "kkaiapi" ? KKAIAPI_BASE_URL : copy.defaults.baseUrl;
+    console.log(`     ${c("✓", brightGreen)} ${provider}`);
+    console.log();
+
+    // Base URL
+    console.log(`  ${c("2", cyan)}  ${c(copy.steps.baseUrl, gray)}`);
+    console.log(c(`     ${copy.hints.baseUrl}`, dim));
+    const baseUrl = await rl.question(`     ${c("❯", cyan)} `);
+    console.log(`     ${c("✓", brightGreen)} ${baseUrl.trim() || providerDefaultBaseUrl}`);
+    console.log();
+
+    // API Key
+    console.log(`  ${c("3", cyan)}  ${c(copy.steps.apiKey, gray)}`);
+    console.log(c(`     ${copy.hints.apiKey}`, dim));
+    const apiKey = await rl.question(`     ${c("❯", cyan)} `);
+    const maskedKey = apiKey.trim().length > 8
+      ? apiKey.trim().slice(0, 4) + "···" + apiKey.trim().slice(-4)
+      : "···";
+    console.log(`     ${c("✓", brightGreen)} ${maskedKey}`);
+    console.log();
+
+    // Model
+    console.log(`  ${c("4", cyan)}  ${c(copy.steps.model, gray)}`);
+    console.log(c(`     ${copy.hints.model}`, dim));
+    const model = await rl.question(`     ${c("❯", cyan)} `);
+    console.log(`     ${c("✓", brightGreen)} ${model.trim()}`);
+    console.log();
+
+    // Scope
+    console.log(`  ${c("5", cyan)}  ${c(copy.steps.scope, gray)}`);
+    console.log(c(`     ${copy.hints.scope}`, dim));
+    const scope = await rl.question(`     ${c("❯", cyan)} ${c(copy.defaults.scope, dim)} `);
+    const useGlobal = scope.trim().toLowerCase() !== "project";
+    const effectiveBaseUrl = baseUrl.trim() || (provider === "kkaiapi" ? providerDefaultBaseUrl : "");
+    const finalProvider = resolveSetupProvider(provider, effectiveBaseUrl);
+    const finalService = resolveSetupService(provider, effectiveBaseUrl);
+
+    const envContent = [
+      `INKOS_LLM_PROVIDER=${finalProvider}`,
+      ...(finalService ? [`INKOS_LLM_SERVICE=${finalService}`] : []),
+      `INKOS_LLM_BASE_URL=${effectiveBaseUrl}`,
+      `INKOS_LLM_API_KEY=${apiKey.trim()}`,
+      `INKOS_LLM_MODEL=${model.trim()}`,
+    ].join("\n");
+
+    if (useGlobal) {
+      const globalDir = join(GLOBAL_ENV_PATH, "..");
+      await mkdir(globalDir, { recursive: true });
+      await writeFile(GLOBAL_ENV_PATH, envContent + "\n", "utf-8");
+      console.log();
+      console.log(`  ${c("✓", brightGreen, bold)} ${c(copy.savedTo, dim)} ${c(GLOBAL_ENV_PATH, gray)}`);
+    } else {
+      await writeFile(join(projectRoot, ".env"), envContent + "\n", "utf-8");
+      console.log();
+      console.log(`  ${c("✓", brightGreen, bold)} ${c(copy.savedTo, dim)} ${c(".env", gray)}`);
+    }
+    console.log();
+  } finally {
+    rl.close();
+  }
+}
+
+async function autoInit(cwd: string): Promise<void> {
+  const projectName = basename(cwd);
+  const locale = resolveTuiLocale();
+  const messages = buildAutoInitMessages(projectName, locale);
+  console.log();
+  console.log(`  ${c("◌", cyan)} ${c(messages.initializing, dim)}`);
+
+  await mkdir(join(cwd, "books"), { recursive: true });
+  await mkdir(join(cwd, "radar"), { recursive: true });
+
+  const config = {
+    name: projectName,
+    version: "0.1.0",
+    language: "zh",
+    llm: {
+      provider: process.env.INKOS_LLM_PROVIDER ?? "openai",
+      baseUrl: process.env.INKOS_LLM_BASE_URL ?? "",
+      model: process.env.INKOS_LLM_MODEL ?? "",
+    },
+    notify: [],
+    daemon: {
+      schedule: {
+        radarCron: "0 */6 * * *",
+        writeCron: "*/15 * * * *",
+      },
+      maxConcurrentBooks: 3,
+    },
+  };
+
+  await writeFile(
+    join(cwd, "inkos.json"),
+    JSON.stringify(config, null, 2),
+    "utf-8",
+  );
+
+  const hasGlobal = await hasGlobalConfig();
+  if (!hasGlobal) {
+    await writeFile(
+      join(cwd, ".env"),
+      [
+        messages.envTemplateHeader,
+        "INKOS_LLM_PROVIDER=openai",
+        "INKOS_LLM_BASE_URL=",
+        "INKOS_LLM_API_KEY=",
+        "INKOS_LLM_MODEL=",
+      ].join("\n"),
+      "utf-8",
+    );
+  }
+
+  await ensureProjectGitignore(cwd);
+
+  console.log(`  ${c("✓", brightGreen, bold)} ${c(messages.initialized, dim)}`);
+}
+
+async function hasLlmConfig(projectRoot: string): Promise<boolean> {
+  const projectEnv = join(projectRoot, ".env");
+  if (await checkEnvForKey(projectEnv)) return true;
+  return checkEnvForKey(GLOBAL_ENV_PATH);
+}
+
+async function hasGlobalConfig(): Promise<boolean> {
+  return checkEnvForKey(GLOBAL_ENV_PATH);
+}
+
+async function checkEnvForKey(envPath: string): Promise<boolean> {
+  try {
+    const content = await readFile(envPath, "utf-8");
+    const match = content.match(/INKOS_LLM_API_KEY=(.+)/);
+    return !!match && match[1]!.trim().length > 0 && !match[1]!.includes("your-api-key");
+  } catch {
+    return false;
+  }
+}
+
+export interface ModelInfo {
+  readonly provider: string;
+  readonly model: string;
+  readonly baseUrl: string;
+}
+
+export async function detectModelInfo(projectRoot: string): Promise<ModelInfo | undefined> {
+  try {
+    const config = await loadConfig({ requireApiKey: false, projectRoot });
+    const service = config.llm.service?.trim();
+    const provider = service || config.llm.provider || "openai";
+    const model = config.llm.model?.trim() || "unknown";
+    return {
+      provider,
+      model,
+      baseUrl: config.llm.baseUrl ?? "",
+    };
+  } catch {
+    // Fall back to legacy env parsing below.
+  }
+
+  const paths = [join(projectRoot, ".env"), GLOBAL_ENV_PATH];
+  for (const p of paths) {
+    const info = await parseEnvModel(p);
+    if (info) return info;
+  }
+  return undefined;
+}
+
+export async function detectProjectLanguage(projectRoot: string): Promise<string | undefined> {
+  try {
+    const raw = await readFile(join(projectRoot, "inkos.json"), "utf-8");
+    const parsed = JSON.parse(raw) as { language?: string };
+    return parsed.language;
+  } catch {
+    return undefined;
+  }
+}
+
+async function parseEnvModel(envPath: string): Promise<ModelInfo | undefined> {
+  try {
+    const content = await readFile(envPath, "utf-8");
+    const get = (key: string) => {
+      const m = content.match(new RegExp(`^${key}=(.+)$`, "m"));
+      return m?.[1]?.trim() ?? "";
+    };
+    const key = get("INKOS_LLM_API_KEY");
+    if (!key || key.includes("your-api-key")) return undefined;
+    return {
+      provider: get("INKOS_LLM_PROVIDER") || "openai",
+      model: get("INKOS_LLM_MODEL") || "unknown",
+      baseUrl: get("INKOS_LLM_BASE_URL") || "",
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/inkos/packages/cli/src/tui/slash-autocomplete.ts

@@ -0,0 +1,62 @@
+export const SLASH_COMMANDS = [
+  "/new 输入你的想法",
+  "/write",
+  "/books",
+  "/rewrite <n>",
+  "/focus <text>",
+  "/truth <file> <content>",
+  "/rename <from> => <to>",
+  "/replace <n> <from> => <to>",
+  "/export [txt|md|epub]",
+  "/help",
+  "/status",
+  "/clear",
+  "/depth <light|normal|deep>",
+  "/quit",
+  "/exit",
+] as const;
+
+export type SlashNavigationDirection = "up" | "down";
+
+export function getSlashSuggestions(input: string, commands: readonly string[]): string[] {
+  const value = input.trim();
+  if (!value.startsWith("/")) {
+    return [];
+  }
+
+  return commands.filter((command) => slashCommandStem(command).startsWith(value));
+}
+
+export function getNextSlashSelection(
+  currentIndex: number,
+  suggestionCount: number,
+  direction: SlashNavigationDirection,
+): number {
+  if (suggestionCount <= 0) {
+    return 0;
+  }
+
+  if (direction === "down") {
+    return (currentIndex + 1) % suggestionCount;
+  }
+
+  return (currentIndex - 1 + suggestionCount) % suggestionCount;
+}
+
+export function applySlashSuggestion(
+  _input: string,
+  suggestions: readonly string[],
+  selectedIndex: number,
+): string {
+  const suggestion = suggestions[selectedIndex] ?? "";
+  return slashSuggestionInsertion(suggestion);
+}
+
+function slashCommandStem(command: string): string {
+  return command.match(/^\/\S+/)?.[0] ?? command;
+}
+
+function slashSuggestionInsertion(suggestion: string): string {
+  const stem = slashCommandStem(suggestion);
+  return suggestion === stem ? stem : `${stem} `;
+}

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

@@ -0,0 +1,17 @@
+/** Whether the terminal is macOS Terminal.app. */
+export const isAppleTerminal = process.env.TERM_PROGRAM === "Apple_Terminal";
+
+export const WARM_ACCENT = "#c88a56";
+export const WARM_MUTED = "#8f8374";
+export const WARM_REPLY = "#f0e6d8";
+export const WARM_BORDER = "#6b6156";
+
+// Semantic status colors
+export const STATUS_SUCCESS = "#7ec87e";
+export const STATUS_ERROR = "#e06060";
+export const STATUS_ACTIVE = "#d4a76a";
+export const STATUS_IDLE = "#7a7268";
+
+// Role colors
+export const ROLE_USER = "#a8c4d4";
+export const ROLE_SYSTEM = "#b8a8d0";

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

@@ -0,0 +1,222 @@
+import { readFile, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createLLMClient, StateManager, createLogger, createStderrSink, createJsonLineSink, resolveEffectiveLLMConfig, loadLLMEnvLayers, GLOBAL_CONFIG_DIR, GLOBAL_ENV_PATH, type EffectiveLLMConfigResult, type LLMConfigCliOverrides, type ProjectConfig, type PipelineConfig, type LogSink } from "@actalk/inkos-core";
+import { formatSqliteMemorySupportWarning } from "./runtime-requirements.js";
+
+export { GLOBAL_CONFIG_DIR, GLOBAL_ENV_PATH };
+
+let sqliteMemorySupportWarned = false;
+
+export async function resolveContext(opts: {
+  readonly context?: string;
+  readonly contextFile?: string;
+}): Promise<string | undefined> {
+  if (opts.context) return opts.context;
+  if (opts.contextFile) {
+    return readFile(resolve(opts.contextFile), "utf-8");
+  }
+  if (process.env.INKOS_NO_STDIN === "true") {
+    return undefined;
+  }
+  // Read from stdin if piped (non-TTY)
+  if (!process.stdin.isTTY) {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk as Buffer);
+    }
+    const text = Buffer.concat(chunks).toString("utf-8").trim();
+    if (text.length > 0) return text;
+  }
+  return undefined;
+}
+
+export function findProjectRoot(): string {
+  return process.cwd();
+}
+
+export async function loadConfig(options?: {
+  readonly requireApiKey?: boolean;
+  readonly projectRoot?: string;
+  readonly cli?: LLMConfigCliOverrides;
+}): Promise<ProjectConfig> {
+  return (await loadConfigWithDiagnostics(options)).config;
+}
+
+export async function loadConfigWithDiagnostics(options?: {
+  readonly requireApiKey?: boolean;
+  readonly projectRoot?: string;
+  readonly cli?: LLMConfigCliOverrides;
+}): Promise<EffectiveLLMConfigResult> {
+  const root = options?.projectRoot ?? findProjectRoot();
+  const cli = {
+    ...parseLLMOverridesFromArgv(process.argv.slice(2)),
+    ...options?.cli,
+  };
+  const envLayers = await loadLLMEnvLayers(root);
+  return resolveEffectiveLLMConfig({
+    consumer: "cli",
+    projectRoot: root,
+    envLayers,
+    cli,
+    requireApiKey: options?.requireApiKey,
+  });
+}
+
+export function createClient(config: ProjectConfig) {
+  return createLLMClient(config.llm);
+}
+
+export function parseLLMOverridesFromArgv(argv: readonly string[]): LLMConfigCliOverrides {
+  const overrides: {
+    service?: string;
+    model?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    apiFormat?: "chat" | "responses";
+    stream?: boolean;
+  } = {};
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg) continue;
+
+    const [flag, inlineValue] = arg.split("=", 2) as [string, string | undefined];
+    const nextValue = () => inlineValue ?? argv[++i];
+
+    if (flag === "--service") {
+      const value = nextValue();
+      if (value) overrides.service = value;
+    } else if (flag === "--model") {
+      const value = nextValue();
+      if (value) overrides.model = value;
+    } else if (flag === "--api-key-env") {
+      const value = nextValue();
+      if (value) overrides.apiKeyEnv = value;
+    } else if (flag === "--base-url") {
+      const value = nextValue();
+      if (value) overrides.baseUrl = value;
+    } else if (flag === "--api-format") {
+      const value = nextValue();
+      if (value === "chat" || value === "responses") overrides.apiFormat = value;
+    } else if (flag === "--stream") {
+      overrides.stream = true;
+    } else if (flag === "--no-stream") {
+      overrides.stream = false;
+    }
+  }
+
+  return overrides;
+}
+
+export function buildPipelineConfig(
+  config: ProjectConfig,
+  root: string,
+  extra?: Partial<Pick<PipelineConfig, "notifyChannels" | "radarSources" | "externalContext" | "inputGovernanceMode">> & {
+    readonly quiet?: boolean;
+    readonly logFile?: NodeJS.WritableStream;
+  },
+): PipelineConfig {
+  if (!extra?.quiet && !sqliteMemorySupportWarned) {
+    const warning = formatSqliteMemorySupportWarning();
+    if (warning) {
+      sqliteMemorySupportWarned = true;
+      process.stderr.write(`[WARN] ${warning}\n`);
+    }
+  }
+
+  const sinks: LogSink[] = [];
+  if (!extra?.quiet) {
+    sinks.push(createStderrSink({ minLevel: "info" }));
+  }
+  if (extra?.logFile) {
+    sinks.push(createJsonLineSink(extra.logFile));
+  }
+
+  const hasLogging = sinks.length > 0;
+  const logger = hasLogging ? createLogger({ tag: "inkos", sinks }) : undefined;
+
+  const onStreamProgress = hasLogging
+    ? (progress: { readonly elapsedMs: number; readonly totalChars: number; readonly chineseChars: number; readonly status: string }) => {
+        if (progress.status === "streaming") {
+          logger?.info(
+            `streaming ${Math.round(progress.elapsedMs / 1000)}s, ${progress.totalChars} chars (${progress.chineseChars} CJK)`,
+          );
+        }
+      }
+    : undefined;
+
+  return {
+    client: createLLMClient(config.llm),
+    model: config.llm.model,
+    projectRoot: root,
+    defaultLLMConfig: config.llm,
+    foundationReviewRetries: config.foundation.reviewRetries,
+    writingReviewRetries: config.writing?.reviewRetries ?? 1,
+    modelOverrides: config.modelOverrides,
+    inputGovernanceMode: extra?.inputGovernanceMode ?? config.inputGovernanceMode,
+    notifyChannels: extra?.notifyChannels ?? config.notify,
+    radarSources: extra?.radarSources,
+    externalContext: extra?.externalContext,
+    logger,
+    onStreamProgress,
+  };
+}
+
+export function log(message: string): void {
+  process.stdout.write(`${message}\n`);
+}
+
+export function logError(message: string): void {
+  process.stderr.write(`[ERROR] ${message}\n`);
+}
+
+/**
+ * Resolve book-id: if provided use it, otherwise auto-detect when exactly one book exists.
+ * Validates that the book actually exists.
+ */
+export async function resolveBookId(
+  bookIdArg: string | undefined,
+  root: string,
+): Promise<string> {
+  const state = new StateManager(root);
+  const books = await state.listBooks();
+
+  if (bookIdArg) {
+    if (!books.includes(bookIdArg)) {
+      const available = books.length > 0 ? books.join(", ") : "(none)";
+      throw new Error(
+        `Book "${bookIdArg}" not found. Available books: ${available}`,
+      );
+    }
+    return bookIdArg;
+  }
+
+  if (books.length === 0) {
+    throw new Error(
+      "No books found. Create one first:\n  inkos book create --title '...' --genre xuanhuan",
+    );
+  }
+  if (books.length === 1) {
+    return books[0]!;
+  }
+  throw new Error(
+    `Multiple books found: ${books.join(", ")}\nPlease specify a book-id.`,
+  );
+}
+
+export async function getLegacyMigrationHint(
+  root: string,
+  bookId: string,
+): Promise<string | null> {
+  const state = new StateManager(root);
+  const stateDir = join(state.bookDir(bookId), "story", "state");
+  try {
+    const info = await stat(stateDir);
+    if (info.isDirectory()) {
+      return null;
+    }
+  } catch {
+    return `Book "${bookId}" uses legacy format (pre-v0.6). The next write will auto-migrate its state files.`;
+  }
+  return `Book "${bookId}" uses legacy format (pre-v0.6). The next write will auto-migrate its state files.`;
+}

package/inkos/packages/cli/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}