intor-cli 0.0.14 → 0.0.16

package/src/cli/menu/prompts/prompt-generate.ts

@@ -0,0 +1,106 @@
+import type { GenerateOptions } from "../../../features";
+import { text, isCancel, confirm } from "@clack/prompts";
+import { discoverConfigs } from "../../../core";
+import { promptReaderOptions } from "./shared/prompt-reader-options";
+import { promptMode, promptDebug, printOptionsSummary } from "./shared/shared";
+
+export async function promptGenerate(): Promise<GenerateOptions | null> {
+  // ------------------------------------------------------------------
+  // Discover configs early (for prompt decisions)
+  // ------------------------------------------------------------------
+  const configs = await discoverConfigs();
+  if (configs.length === 0) throw new Error("No Intor config found.");
+  const isSingleConfig = configs.length === 1;
+
+  // ------------------------------------------------------------------
+  // Mode
+  // ------------------------------------------------------------------
+  const mode = await promptMode();
+  if (!mode) return null;
+  if (mode === "default") return {};
+
+  const options: GenerateOptions = {};
+
+  // ------------------------------------------------------------------
+  // Message source
+  // ------------------------------------------------------------------
+  const useCustomMessages = await confirm({
+    message:
+      "Do you want to provide message files instead of using the loader?",
+    initialValue: false,
+  });
+  if (isCancel(useCustomMessages)) return null;
+
+  if (useCustomMessages) {
+    const sourceMode = isSingleConfig ? "single" : "mapping";
+
+    // single mode
+    if (sourceMode === "single") {
+      const file = await text({
+        message: "Path to the message file (default locale)",
+        placeholder: "messages/en/index.json",
+      });
+      if (isCancel(file)) return null;
+      options.messageSource = { mode: "single", file };
+    }
+
+    // mapping mode
+    if (sourceMode === "mapping") {
+      const files: Record<string, string> = {};
+      for (const { config } of configs) {
+        const path = await text({
+          message: `Message file for config "${config.id}" (default locale)`,
+          placeholder: "messages/en/index.json",
+        });
+        if (isCancel(path)) return null;
+        if (path) files[config.id] = path;
+      }
+      options.messageSource = { mode: "mapping", files };
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Reader options
+  // ------------------------------------------------------------------
+  const readerOptions = await promptReaderOptions();
+  if (readerOptions === null) return null;
+  if (readerOptions.exts?.length) {
+    options.exts = readerOptions.exts;
+  }
+  if (readerOptions.customReaders) {
+    options.customReaders = readerOptions.customReaders;
+  }
+
+  // ------------------------------------------------------------------
+  // Debug
+  // ------------------------------------------------------------------
+  const debug = await promptDebug();
+  if (debug === null) return null;
+  if (debug) options.debug = true;
+
+  // ------------------------------------------------------------------
+  // Summary
+  // ------------------------------------------------------------------
+  printOptionsSummary("Generate options", [
+    [
+      "message files",
+      options.messageSource?.mode === "single"
+        ? options.messageSource.file
+        : options.messageSource?.mode === "mapping"
+          ? Object.entries(options.messageSource.files)
+              .map(([id, path]) => `${id}: ${path}`)
+              .join(", ")
+          : "(loader)",
+    ],
+    ["exts", options.exts?.join(", ") ?? "(none)"],
+    [
+      "custom readers",
+      options.customReaders
+        ? Object.keys(options.customReaders).join(", ")
+        : "(none)",
+    ],
+    ["debug", options.debug ? "on" : "off"],
+  ]);
+
+  return options;
+}

package/src/cli/menu/prompts/prompt-validate.ts

@@ -0,0 +1,49 @@
+import type { ValidateOptions } from "../../../features";
+import { promptReaderOptions } from "./shared/prompt-reader-options";
+import { promptMode, promptDebug, printOptionsSummary } from "./shared/shared";
+
+export async function promptValidate(): Promise<ValidateOptions | null> {
+  // ------------------------------------------------------------------
+  // Mode
+  // ------------------------------------------------------------------
+  const mode = await promptMode();
+  if (!mode) return null;
+  if (mode === "default") return {};
+
+  const options: ValidateOptions = {};
+
+  // ------------------------------------------------------------------
+  // Reader options
+  // ------------------------------------------------------------------
+  const readerOptions = await promptReaderOptions();
+  if (readerOptions === null) return null;
+  if (readerOptions.exts?.length) {
+    options.exts = readerOptions.exts;
+  }
+  if (readerOptions.customReaders) {
+    options.customReaders = readerOptions.customReaders;
+  }
+
+  // ------------------------------------------------------------------
+  // Debug
+  // ------------------------------------------------------------------
+  const debug = await promptDebug();
+  if (debug === null) return null;
+  if (debug) options.debug = true;
+
+  // ------------------------------------------------------------------
+  // Summary
+  // ------------------------------------------------------------------
+  printOptionsSummary("Validate options", [
+    ["exts", options.exts?.join(", ") ?? "(none)"],
+    [
+      "custom readers",
+      options.customReaders
+        ? Object.keys(options.customReaders).join(", ")
+        : "(none)",
+    ],
+    ["debug", options.debug ? "on" : "off"],
+  ]);
+
+  return options;
+}

package/src/cli/menu/prompts/shared/prompt-reader-options.ts

@@ -0,0 +1,63 @@
+import type { ReaderOptions, ExtraExt } from "../../../../core";
+import { confirm, multiselect, text, isCancel } from "@clack/prompts";
+
+type FormatOption = ExtraExt | "custom";
+
+export async function promptReaderOptions(): Promise<ReaderOptions | null> {
+  const enable = await confirm({
+    message: "Enable additional message readers?",
+    initialValue: false,
+  });
+  if (isCancel(enable)) return null;
+  if (!enable) return { exts: [], customReaders: undefined };
+
+  // --------------------------------------------------
+  // Select built-in formats and/or custom reader
+  // --------------------------------------------------
+  const selected = await multiselect<FormatOption>({
+    message: "Select message readers",
+    options: [
+      { value: "md", label: "Markdown (.md)" },
+      { value: "yaml", label: "YAML (.yaml/.yml)" },
+      { value: "toml", label: "TOML (.toml)" },
+      { value: "json5", label: "JSON5 (.json5)" },
+      { value: "custom", label: "Custom reader" },
+    ],
+    required: false,
+  });
+  if (isCancel(selected)) return null;
+
+  // Extract built-in extensions
+  const exts = selected.filter((v): v is ExtraExt => v !== "custom");
+
+  let customReaders: Record<string, string> | undefined;
+
+  // --------------------------------------------------
+  // Custom reader mappings (ext=path)
+  // --------------------------------------------------
+  if (selected.includes("custom")) {
+    const mapping = await text({
+      message: "Custom reader mappings (ext=path, comma separated)",
+      placeholder: "md=./reader-md.ts",
+    });
+    if (isCancel(mapping)) return null;
+
+    customReaders = Object.fromEntries(
+      mapping
+        .split(",")
+        .map((pair) => pair.trim())
+        .filter(Boolean)
+        .map((pair) => {
+          const [ext, path] = pair.split("=", 2);
+          if (!ext || !path) {
+            throw new Error(
+              `Invalid custom reader entry: "${pair}". Expected <ext=path>.`,
+            );
+          }
+          return [ext, path];
+        }),
+    );
+  }
+
+  return { exts, customReaders };
+}

package/src/cli/menu/prompts/shared/shared.ts

@@ -0,0 +1,76 @@
+import { select, isCancel, confirm, text, note } from "@clack/prompts";
+
+// ------------------------------------------------------------------
+// Mode
+// ------------------------------------------------------------------
+export async function promptMode(): Promise<"default" | "custom" | null> {
+  const mode = await select({
+    message: "Mode?",
+    options: [
+      { value: "default", label: "Default (recommended)" },
+      { value: "custom", label: "Custom configuration" },
+    ],
+  });
+  if (isCancel(mode)) return null;
+  return mode;
+}
+
+// ------------------------------------------------------------------
+// Format
+// ------------------------------------------------------------------
+export async function promptFormat(): Promise<"human" | "json" | null> {
+  const format = await select({
+    message: "Select output format",
+    options: [
+      { value: "human", label: "Human-readable" },
+      { value: "json", label: "JSON (machine-readable)" },
+    ],
+    initialValue: "human",
+  });
+  if (isCancel(format)) return null;
+  return format as "human" | "json";
+}
+
+// ------------------------------------------------------------------
+// Output
+// ------------------------------------------------------------------
+export async function promptOutput(): Promise<string | undefined | null> {
+  const writeToFile = await confirm({
+    message: "Write output to a file?",
+    initialValue: false,
+  });
+  if (isCancel(writeToFile)) return null;
+
+  if (writeToFile) {
+    const output = await text({
+      message: "Output file path",
+      placeholder: "check-report.json",
+      defaultValue: "check-report.json",
+    });
+    if (isCancel(output)) return null;
+    return output || undefined;
+  }
+  return undefined;
+}
+
+// ------------------------------------------------------------------
+// Debug
+// ------------------------------------------------------------------
+export async function promptDebug(): Promise<boolean | null> {
+  const debug = await confirm({
+    message: "Enable debug mode?",
+    initialValue: false,
+  });
+  if (isCancel(debug)) return null;
+  return debug;
+}
+
+// ------------------------------------------------------------------
+// Summary
+// ------------------------------------------------------------------
+export function printOptionsSummary(
+  title: string,
+  lines: Array<[string, string]>,
+) {
+  note(lines.map(([k, v]) => `${k}: ${v}`).join("\n"), title);
+}

package/src/cli/menu/run.ts

@@ -0,0 +1,72 @@
+/* eslint-disable unicorn/no-process-exit */
+import { outro, select, isCancel, intro } from "@clack/prompts";
+import pc from "picocolors";
+import { features } from "../../constants";
+import { check, discover, generate, validate } from "../../features";
+import { bold, italic } from "../../render";
+import { version } from "../version";
+import { promptCheck } from "./prompts/prompt-check";
+import { promptDiscover } from "./prompts/prompt-discover";
+import { promptGenerate } from "./prompts/prompt-generate";
+import { promptValidate } from "./prompts/prompt-validate";
+
+/**
+ * Run a single CLI action with its corresponding prompt and handler.
+ */
+async function runAction<T>(
+  prompt: () => Promise<T | null>,
+  action: (options: T) => Promise<void>,
+) {
+  const options = await prompt();
+  if (!options) {
+    outro(pc.dim("Cancelled"));
+    process.exit(0);
+  }
+  await action(options);
+}
+
+/**
+ * Entry point for the interactive CLI menu.
+ */
+export async function run() {
+  intro(italic(bold("The Intor CLI.")));
+
+  const action = await select({
+    message: "Select an action",
+    options: [
+      ...Object.values(features).map(({ name, title }) => ({
+        value: name,
+        label: title,
+      })),
+      { value: "exit", label: "Exit" },
+    ],
+  });
+
+  if (isCancel(action) || action === "exit") {
+    outro("Exited");
+    process.exit(0);
+  }
+
+  switch (action) {
+    case "discover": {
+      await runAction(promptDiscover, discover);
+      break;
+    }
+    case "check": {
+      await runAction(promptCheck, check);
+      break;
+    }
+    case "generate": {
+      await runAction(promptGenerate, (options) =>
+        generate({ ...options, toolVersion: version }),
+      );
+      break;
+    }
+    case "validate": {
+      await runAction(promptValidate, validate);
+      break;
+    }
+  }
+
+  outro(pc.green("Completed"));
+}

package/src/cli/version.ts

@@ -0,0 +1,3 @@
+import package_ from "../../package.json" with { type: "json" };
+
+export const version = package_.version;

package/src/constants.ts

@@ -0,0 +1,6 @@
+export const features = {
+  discover: { name: "discover", title: "Discover intor configs" },
+  generate: { name: "generate", title: "Generate types & schemas" },
+  check: { name: "check", title: "Check translation usages" },
+  validate: { name: "validate", title: "Validate messages" },
+} as const;

package/src/core/artifacts/index.ts

@@ -0,0 +1,5 @@
+export { buildTypes, writeTypes } from "./types/index";
+
+export { buildSchema, writeSchema, readSchema } from "./schema";
+
+export type { GeneratedSchema, SchemaEntry } from "./types";

package/src/core/artifacts/schema/build-schema.ts

@@ -0,0 +1,13 @@
+import type { GeneratedSchema, SchemaEntry } from "../types";
+
+export function buildSchema(
+  entries: SchemaEntry[],
+  toolVersion?: string,
+): GeneratedSchema {
+  return {
+    version: 1,
+    toolVersion,
+    generatedAt: new Date().toISOString(),
+    entries,
+  };
+}

package/src/core/artifacts/schema/index.ts

@@ -0,0 +1,3 @@
+export { buildSchema } from "./build-schema";
+export { readSchema } from "./read-schema";
+export { writeSchema } from "./write-schema";

package/src/core/{generated → artifacts/schema}/read-schema.ts

@@ -1,9 +1,9 @@
-import type { Schema } from "../../build";
+import type { GeneratedSchema } from "../types";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { DEFAULT_OUT_DIR, DEFAULT_SCHEMA_FILE_NAME } from "../constants";
+import { DEFAULT_OUT_DIR, DEFAULT_SCHEMA_FILE_NAME } from "../../constants";
 
-export async function readSchema(): Promise<Schema> {
+export async function readSchema(): Promise<GeneratedSchema> {
   const filePath = path.join(DEFAULT_OUT_DIR, DEFAULT_SCHEMA_FILE_NAME);
 
   let raw: string;
@@ -24,7 +24,7 @@ export async function readSchema(): Promise<Schema> {
   // Parse JSON
   // ------------------------------------------------------------------
   try {
-    return JSON.parse(raw) as Schema;
+    return JSON.parse(raw) as GeneratedSchema;
   } catch {
     throw new Error(
       `Invalid JSON format in Intor schema file at "${filePath}".`,

package/src/core/artifacts/schema/write-schema.ts

@@ -0,0 +1,14 @@
+import type { GeneratedSchema } from "../types";
+import path from "node:path";
+import { DEFAULT_OUT_DIR, DEFAULT_SCHEMA_FILE_NAME } from "../../constants";
+import { ensureAndWrite } from "../ensure-and-write";
+
+export async function writeSchema(
+  generatedSchema: GeneratedSchema,
+): Promise<string> {
+  const filePath = path.join(DEFAULT_OUT_DIR, DEFAULT_SCHEMA_FILE_NAME);
+  return await ensureAndWrite(
+    filePath,
+    JSON.stringify(generatedSchema, null, 2),
+  );
+}

package/src/{build/build-types → core/artifacts/types/build}/build-types.ts

@@ -1,4 +1,4 @@
-import type { BuildInput } from "../types";
+import type { SchemaEntry } from "../../types";
 import { appendHeader, appendConfigBlock, appendFooter } from "./output";
 import { normalizeRichInferNode } from "./utils/normalize-rich-infer-node";
 import { renderInferNode } from "./utils/render-infer-node";
@@ -8,20 +8,19 @@ const GENERATED_INTERFACE_NAME = "IntorGeneratedTypes";
 /**
  * Builds the global TypeScript declaration from inferred typegen inputs.
  */
-export function buildTypes(inputs: BuildInput[]): string {
+export function buildTypes(schemaEntries: SchemaEntry[]): string {
   const lines: string[] = [];
 
   // Global declaration header
   appendHeader(lines, GENERATED_INTERFACE_NAME);
 
   // Per-config processing
-  for (const [index, input] of inputs.entries()) {
-    const localesType = input.locales.map((l) => `"${l}"`).join(" | ");
-    const messagesType = renderInferNode(input.schemas.messagesSchema);
-    const replacementsType = renderInferNode(input.schemas.replacementsSchema);
-    const richType = renderInferNode(
-      normalizeRichInferNode(input.schemas.richSchema),
-    );
+  for (const [index, entry] of schemaEntries.entries()) {
+    const localesType = entry.locales.map((l) => `"${l}"`).join(" | ");
+
+    const messagesType = renderInferNode(entry.shapes.messages);
+    const replacementsType = renderInferNode(entry.shapes.replacements);
+    const richType = renderInferNode(normalizeRichInferNode(entry.shapes.rich));
 
     if (index === 0) {
       appendConfigBlock(lines, {
@@ -34,7 +33,7 @@ export function buildTypes(inputs: BuildInput[]): string {
     }
 
     appendConfigBlock(lines, {
-      id: `"${input.id}"`,
+      id: `"${entry.id}"`,
       locales: localesType,
       messages: messagesType,
       replacements: replacementsType,

package/src/{build/build-types → core/artifacts/types/build}/utils/normalize-rich-infer-node.ts

@@ -1,4 +1,4 @@
-import type { InferNode } from "../../../core";
+import type { InferNode } from "../../../../infer-shape";
 
 /**
  * Normalize inferred rich schema before type emission.

package/src/{build/build-types → core/artifacts/types/build}/utils/render-infer-node.ts

@@ -1,4 +1,4 @@
-import type { InferNode } from "../../../core";
+import type { InferNode } from "../../../../infer-shape";
 import { indent } from "./indent";
 
 export function renderInferNode(node: InferNode, indentLevel = 4): string {

package/src/core/artifacts/types/index.ts

@@ -0,0 +1,2 @@
+export { buildTypes } from "./build";
+export { writeTypes } from "./write-types";

package/src/core/artifacts/types/write-types.ts

@@ -0,0 +1,8 @@
+import path from "node:path";
+import { DEFAULT_OUT_DIR, DEFAULT_TYPES_FILE_NAME } from "../../constants";
+import { ensureAndWrite } from "../ensure-and-write";
+
+export async function writeTypes(generatedTypes: string): Promise<string> {
+  const filePath = path.join(DEFAULT_OUT_DIR, DEFAULT_TYPES_FILE_NAME);
+  return await ensureAndWrite(filePath, generatedTypes);
+}

package/src/core/artifacts/types.ts

@@ -0,0 +1,20 @@
+import type { InferredShapes } from "../infer-shape";
+
+/**
+ * Versioned schema artifact generated from inferred semantic shapes.
+ */
+export interface GeneratedSchema {
+  version: number;
+  toolVersion?: string;
+  generatedAt: string;
+  entries: SchemaEntry[];
+}
+
+/**
+ * A schema entry representing the inferred result of a single Intor config.
+ */
+export interface SchemaEntry {
+  id: string;
+  locales: readonly string[];
+  shapes: InferredShapes;
+}

package/src/core/collect-messages/collect-other-locale-messages.ts

@@ -1,11 +1,10 @@
-import type { ExtraExt } from "../constants";
+import type { ReaderOptions } from "./types";
 import type { IntorResolvedConfig, MessageObject } from "intor";
 import { collectRuntimeMessages } from "./collect-runtime-messages";
 
 export async function collectOtherLocaleMessages(
   config: IntorResolvedConfig,
-  exts: Array<ExtraExt> = [],
-  customReaders?: Record<string, string>,
+  { exts, customReaders }: ReaderOptions,
 ): Promise<Record<string, MessageObject>> {
   const { supportedLocales, defaultLocale } = config;
 
@@ -14,12 +13,11 @@ export async function collectOtherLocaleMessages(
   for (const locale of supportedLocales) {
     if (locale === defaultLocale) continue;
 
-    const { messages } = await collectRuntimeMessages(
-      config,
-      locale,
+    const { messages } = await collectRuntimeMessages(config, locale, {
       exts,
       customReaders,
-    );
+    });
+
     result[locale] = messages[locale];
   }
 

package/src/core/collect-messages/collect-runtime-messages.ts

@@ -1,5 +1,8 @@
-import type { CollectRuntimeMessagesResult, MergeOverrides } from "./types";
-import type { ExtraExt } from "../../core";
+import type {
+  ReaderOptions,
+  CollectRuntimeMessagesResult,
+  MergeOverrides,
+} from "./types";
 import {
   mergeMessages,
   resolveLoaderOptions,
@@ -19,8 +22,7 @@ import { resolveMessagesReader } from "./resolve-messages-reader";
 export async function collectRuntimeMessages(
   config: IntorResolvedConfig,
   locale: string,
-  exts: Array<ExtraExt> = [],
-  customReaders?: Record<string, string>, // {ext, customReaderFilePath}
+  { exts = [], customReaders }: ReaderOptions,
 ): Promise<CollectRuntimeMessagesResult> {
   // ----------------------------------------------------------------------
   // Resolve readers
@@ -74,7 +76,7 @@ export async function collectRuntimeMessages(
     onEvent: (event) => {
       overrides.push({
         ...event,
-        layer: "client_over_server",
+        layer: "clientOverServer",
         locale,
         configId: config.id,
       });
@@ -88,7 +90,7 @@ export async function collectRuntimeMessages(
     onEvent: (event) => {
       overrides.push({
         ...event,
-        layer: "runtime_over_static",
+        layer: "runtimeOverStatic",
         locale,
         configId: config.id,
       });

package/src/core/collect-messages/index.ts

@@ -1,2 +1,3 @@
 export { collectRuntimeMessages } from "./collect-runtime-messages";
 export { collectOtherLocaleMessages } from "./collect-other-locale-messages";
+export type { ReaderOptions, MergeOverrides } from "./types";

package/src/core/collect-messages/readers.ts

@@ -22,6 +22,7 @@ export const getBuiltInReaders = (
       return reader ? [ext, reader] : null;
     })
     .filter((e): e is [ExtraExt, MessagesReader] => e !== null);
+
   // Entries to object
   return Object.fromEntries(entries);
 };

package/src/core/collect-messages/types.ts

@@ -1,12 +1,18 @@
+import type { ExtraExt } from "../constants";
 import type { DeepMergeOverrideEvent, LocaleMessages } from "intor";
 
+export interface ReaderOptions {
+  exts?: Array<ExtraExt>;
+  customReaders?: Record<string, string>; // {ext, customReaderFilePath}
+}
+
 export interface CollectRuntimeMessagesResult {
   messages: LocaleMessages;
   overrides: MergeOverrides[];
 }
 
 export interface MergeOverrides extends DeepMergeOverrideEvent {
-  layer: "client_over_server" | "runtime_over_static";
+  layer: "clientOverServer" | "runtimeOverStatic";
   locale: string;
   configId: string;
 }

package/src/core/constants/index.ts

@@ -1,3 +1,4 @@
+// artifacts
 export {
   DEFAULT_OUT_DIR,
   DEFAULT_TYPES_FILE_NAME,
@@ -5,4 +6,5 @@ export {
   DEFAULT_MESSAGES_SNAPSHOT_DIR,
 } from "./generated";
 
+// extra-exts
 export { EXTRA_EXTS, type ExtraExt } from "./extra-exts";