intor-cli 0.0.14 → 0.0.16

package/src/features/validate/{messages/validate-messages-schema.ts → missing/collect-missing-messages.ts}

@@ -1,12 +1,12 @@
+import type { MissingRequirements } from "./collect-missing-requirements";
 import type { InferNode } from "../../../core";
-import type { ValidationResult } from "../validate-locale-messages";
 import type { MessageObject } from "intor";
 
-export function validateMessagesSchema(
+export function collectMissingMessages(
   schema: InferNode,
   messages: MessageObject,
   path: string,
-  result: ValidationResult,
+  result: MissingRequirements,
 ) {
   // Only object schemas define required message keys
   if (schema.kind !== "object") return;
@@ -19,13 +19,13 @@ export function validateMessagesSchema(
 
     // Schema requires this key, but message does not provide it
     if (value === undefined) {
-      result.missingKeys.push(nextPath);
+      result.missingMessages.push(nextPath);
       continue;
     }
 
     // Recurse into nested message objects
     if (typeof value === "object" && value !== null) {
-      validateMessagesSchema(
+      collectMissingMessages(
         expected,
         value as MessageObject,
         nextPath,

package/src/features/validate/{replacements/validate-replacements-schema.ts → missing/collect-missing-replacements.ts}

@@ -1,13 +1,13 @@
+import type { MissingRequirements } from "./collect-missing-requirements";
 import type { InferNode } from "../../../core";
-import type { ValidationResult } from "../validate-locale-messages";
 import type { MessageObject } from "intor";
 import { extractInterpolationNames } from "../../../core";
 
-export function validateReplacementsSchema(
+export function collectMissingReplacements(
   schema: InferNode,
   messages: MessageObject,
   path: string,
-  result: ValidationResult,
+  result: MissingRequirements,
 ) {
   // Only object schemas define required message keys
   if (schema.kind !== "object") return;
@@ -40,7 +40,7 @@ export function validateReplacementsSchema(
 
     // Recurse into nested message objects
     if (typeof value === "object" && value !== null) {
-      validateReplacementsSchema(
+      collectMissingReplacements(
         expected,
         value as MessageObject,
         nextPath,

package/src/features/validate/missing/collect-missing-requirements.ts

@@ -0,0 +1,44 @@
+import type { InferredShapes } from "../../../core";
+import type { MessageObject } from "intor";
+import { collectMissingMessages } from "./collect-missing-messages";
+import { collectMissingReplacements } from "./collect-missing-replacements";
+import { collectMissingRich } from "./collect-missing-rich";
+
+export interface MissingRequirements {
+  missingMessages: string[];
+  missingReplacements: Array<{ key: string; name: string }>;
+  missingRich: Array<{ key: string; tag: string }>;
+}
+
+/**
+ * Collect missing translation requirements by comparing
+ * inferred semantic schemas with locale messages.
+ */
+export function collectMissingRequirements(
+  schemas: InferredShapes,
+  localeMessages: MessageObject,
+): MissingRequirements {
+  const missingRequirements: MissingRequirements = {
+    missingMessages: [],
+    missingReplacements: [],
+    missingRich: [],
+  };
+
+  collectMissingMessages(
+    schemas.messages,
+    localeMessages,
+    "",
+    missingRequirements,
+  );
+
+  collectMissingReplacements(
+    schemas.replacements,
+    localeMessages,
+    "",
+    missingRequirements,
+  );
+
+  collectMissingRich(schemas.rich, localeMessages, "", missingRequirements);
+
+  return missingRequirements;
+}

package/src/features/validate/{rich/validate-rich-schema.ts → missing/collect-missing-rich.ts}

@@ -1,12 +1,12 @@
+import type { MissingRequirements } from "./collect-missing-requirements";
 import type { InferNode } from "../../../core";
-import type { ValidationResult } from "../validate-locale-messages";
 import { tokenize, type MessageObject, type Token } from "intor";
 
-export function validateRichSchema(
+export function collectMissingRich(
   schema: InferNode,
   messages: MessageObject,
   path: string,
-  result: ValidationResult,
+  result: MissingRequirements,
 ) {
   // Only object schemas define expected rich tags
   if (schema.kind !== "object") return;
@@ -34,7 +34,7 @@ export function validateRichSchema(
       // Report any schema-required rich tags missing in the message
       for (const tag of Object.keys(expected.properties)) {
         if (actualTags.has(tag)) continue;
-        result.missingRichTags.push({ key: nextPath, tag });
+        result.missingRich.push({ key: nextPath, tag });
       }
 
       continue;
@@ -42,7 +42,7 @@ export function validateRichSchema(
 
     // Recurse into nested message objects
     if (typeof value === "object" && value !== null) {
-      validateRichSchema(expected, value as MessageObject, nextPath, result);
+      collectMissingRich(expected, value as MessageObject, nextPath, result);
     }
   }
 }

package/src/features/validate/render-config-summary.ts

@@ -0,0 +1,47 @@
+import type { MissingRequirementsByLocale } from "./types";
+import { createLogger } from "../../logger";
+import { cyan, br, yellow } from "../../render";
+import { renderLocaleBlocks } from "./render-locale-blocks";
+
+// { [locale: string]: MissingRequirements; } → { string; MissingRequirements; }[]
+function normalizeMissingByLocale(
+  missingByLocale: MissingRequirementsByLocale,
+) {
+  return Object.entries(missingByLocale)
+    .map(([locale, missing]) => ({ locale, missing }))
+    .filter(
+      ({ missing }) =>
+        missing.missingMessages.length > 0 ||
+        missing.missingReplacements.length > 0 ||
+        missing.missingRich.length > 0,
+    );
+}
+
+export function renderConfigSummary(
+  configId: string,
+  missingByLocale: MissingRequirementsByLocale,
+  enabled = true,
+) {
+  if (!enabled) return;
+  const logger = createLogger();
+  br();
+
+  const entries = normalizeMissingByLocale(missingByLocale);
+
+  if (entries.length === 0) {
+    logger.ok(`${cyan(configId)}: no problems found`);
+    return;
+  }
+
+  // Log header
+  logger.header(
+    `${cyan(configId)}: ${yellow(entries.length)} problem locale(s)`,
+    { lineBreakAfter: 1 },
+  );
+
+  // Render locale blocks
+  renderLocaleBlocks(entries);
+
+  // Log footer
+  logger.footer("", { lineBreakBefore: 1 });
+}

package/src/features/validate/render-locale-blocks.ts

@@ -0,0 +1,56 @@
+import type { MissingRequirements } from "./missing/collect-missing-requirements";
+import { createLogger } from "../../logger";
+import { dim, italic, gray } from "../../render";
+
+export function renderLocaleBlocks(
+  entries: { locale: string; missing: MissingRequirements }[],
+) {
+  const logger = createLogger();
+  const prefix = dim("│  ");
+
+  for (let i = 0; i < entries.length; i++) {
+    const { locale, missing } = entries[i];
+    const isLastLocale = i === entries.length - 1;
+
+    const { missingMessages, missingReplacements, missingRich } = missing;
+
+    logger.header(italic(locale), { prefix });
+    logger.log("", { prefix });
+
+    let hasPrintedSection = false;
+
+    // messages
+    if (missingMessages.length > 0) {
+      logger.log(gray("Missing messages:"), { prefix });
+      for (const message of missingMessages) {
+        logger.log(`  - ${message}`, { prefix });
+      }
+      hasPrintedSection = true;
+    }
+
+    // replacements
+    if (missingReplacements.length > 0) {
+      if (hasPrintedSection) logger.log("", { prefix });
+      logger.log(gray("Missing replacements:"), { prefix });
+      for (const { key, name } of missingReplacements) {
+        logger.log(`  - ${key}: ${name}`, { prefix });
+      }
+      hasPrintedSection = true;
+    }
+
+    // rich
+    if (missingRich.length > 0) {
+      if (hasPrintedSection) logger.log("", { prefix });
+      logger.log(gray("Missing rich tags:"), { prefix });
+      for (const { key, tag } of missingRich) {
+        logger.log(`  - ${key}: ${tag}`, { prefix });
+      }
+    }
+
+    logger.log("", { prefix });
+    logger.footer("", { prefix });
+
+    // locale ↔ locale spacing
+    if (!isLastLocale) logger.log();
+  }
+}

package/src/features/validate/types.ts

@@ -0,0 +1,14 @@
+import type { ReaderOptions } from "../../core";
+import type { MissingRequirements } from "./missing/collect-missing-requirements";
+
+export type MissingRequirementsByLocale = {
+  [locale: string]: MissingRequirements;
+};
+
+export type MissingReport = { [configId: string]: MissingRequirementsByLocale };
+
+export interface ValidateOptions extends ReaderOptions {
+  format?: "human" | "json";
+  output?: string;
+  debug?: boolean;
+}

package/src/features/validate/validate.ts

@@ -1,83 +1,78 @@
 /* eslint-disable unicorn/no-process-exit */
-import { discoverConfigs, readSchema, type ExtraExt } from "../../core";
+import type {
+  MissingReport,
+  MissingRequirementsByLocale,
+  ValidateOptions,
+} from "./types";
+import { features } from "../../constants";
+import { discoverConfigs, readSchema } from "../../core";
 import { collectOtherLocaleMessages } from "../../core";
-import { printMissingSchema, printTitle } from "../print";
-import { spinner } from "../spinner";
-import { printSummary } from "./print-summary";
-import {
-  validateLocaleMessages,
-  type ValidationResult,
-} from "./validate-locale-messages";
-
-export interface ValidateOptions {
-  exts?: Array<ExtraExt>;
-  customReaders?: Record<string, string>;
-  debug?: boolean;
-}
+import { renderMissingConfigSchema, renderTitle } from "../../render";
+import { spinner } from "../shared/spinner";
+import { writeJsonReport } from "../shared/write-json-report";
+import { collectMissingRequirements } from "./missing/collect-missing-requirements";
+import { renderConfigSummary } from "./render-config-summary";
 
 export async function validate({
   exts = [],
   customReaders,
+  format = "human",
+  output,
   debug,
 }: ValidateOptions) {
-  printTitle("Validating intor translations");
-  spinner.start();
+  const isHuman = format === "human";
+  renderTitle(features.validate.title, isHuman);
 
   // -----------------------------------------------------------------------
   // Discover configs from the current workspace
   // -----------------------------------------------------------------------
   const configEntries = await discoverConfigs(debug);
-  if (configEntries.length === 0) {
-    spinner.stop();
-    throw new Error("No Intor config found.");
-  }
+  if (configEntries.length === 0) throw new Error("No Intor config found.");
 
   try {
-    // -----------------------------------------------------------------------
+    // ---------------------------------------------------------------------
     // Read generated schema
-    // -----------------------------------------------------------------------
+    // ---------------------------------------------------------------------
     const schema = await readSchema();
-
-    const resultsByConfig: Record<
-      string,
-      Record<string, ValidationResult>
-    > = {};
+    const report: MissingReport = {};
 
     // Per-config processing
     for (const { config } of configEntries) {
-      const schemaConfig = schema.configs.find((c) => c.id === config.id);
+      const schemaConfig = schema.entries.find((c) => c.id === config.id);
       if (!schemaConfig) {
-        spinner.stop();
-        printMissingSchema(config.id);
-        spinner.start();
+        renderMissingConfigSchema(config.id, isHuman);
         continue;
       }
+      const { shapes } = schemaConfig;
 
+      // -------------------------------------------------------------------
       // Load all non-default locale messages
-      const localeMessages = await collectOtherLocaleMessages(
-        config,
+      // -------------------------------------------------------------------
+      if (isHuman) spinner.start();
+      const localeMessages = await collectOtherLocaleMessages(config, {
         exts,
         customReaders,
-      );
+      });
+      if (isHuman) spinner.stop();
 
-      const results: Record<string, ValidationResult> = {};
+      // -------------------------------------------------------------------
+      // Collect missing requirements per locale
+      // -------------------------------------------------------------------
+      const missingByLocale: MissingRequirementsByLocale = {};
       for (const locale of config.supportedLocales) {
         if (locale === config.defaultLocale) continue;
         const messages = localeMessages[locale];
         if (!messages) continue;
-        results[locale] = validateLocaleMessages(
-          schemaConfig.schemas,
-          messages,
-        );
+        missingByLocale[locale] = collectMissingRequirements(shapes, messages);
       }
 
-      resultsByConfig[config.id] = results;
+      report[config.id] = missingByLocale;
+      renderConfigSummary(config.id, missingByLocale, isHuman);
     }
 
-    spinner.stop();
-    printSummary(resultsByConfig);
+    if (format === "json") await writeJsonReport(report, output);
   } catch (error) {
-    spinner.stop();
+    if (isHuman) spinner.stop();
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }

package/src/logger.ts

@@ -0,0 +1,95 @@
+import { dim, green, red, yellow } from "./render";
+
+type Logger = {
+  header: (message?: string, options?: LogOptions) => void;
+  log: (message?: string, options?: LogOptions) => void;
+  footer: (message?: string, options?: LogOptions) => void;
+  process: (tag: ProcessTag, message: string) => void;
+  ok: (message?: string) => void;
+  error: (message?: string) => void;
+};
+
+const noop = () => {};
+const noopLogger: Logger = {
+  header: noop,
+  log: noop,
+  footer: noop,
+  process: noop,
+  ok: noop,
+  error: noop,
+};
+
+type LogOptions = {
+  prefix?: string;
+  kind?: "process";
+  lineBreakBefore?: number;
+  lineBreakAfter?: number;
+};
+
+const SPACER = dim("│  ");
+const log = console.log;
+
+export function createLogger(enabled = true): Logger {
+  if (!enabled) return noopLogger;
+
+  return {
+    header: (message = "", options: LogOptions = {}) => {
+      const prefix = options.prefix ?? "";
+      const symbol = options.kind === "process" ? dim("○ ") : "";
+      const before = options.lineBreakBefore ?? 0;
+      const after = options.lineBreakAfter ?? 0;
+
+      for (let i = 0; i < before; i++) log(SPACER);
+      log(prefix + dim("┌─ ") + symbol + message);
+      for (let i = 0; i < after; i++) log(SPACER);
+    },
+
+    log: (message = "", options: LogOptions = {}) => {
+      const prefix = options.prefix ?? "";
+      log(prefix + SPACER + message);
+    },
+
+    footer: (message = "", options: LogOptions = {}) => {
+      const prefix = options.prefix ?? "";
+      const symbol = options.kind === "process" ? dim("● ") : "";
+      const before = options.lineBreakBefore ?? 0;
+      const after = options.lineBreakAfter ?? 0;
+
+      for (let i = 0; i < before; i++) log(SPACER);
+      log(prefix + dim("└─ ") + symbol + message);
+      for (let i = 0; i < after; i++) log(SPACER);
+    },
+
+    process: (tag: ProcessTag, message: string) => {
+      log(...formatProcessLog(tag, message));
+    },
+
+    ok: (message = "") => {
+      log(dim("╶─ ") + green("✔ ") + message);
+    },
+
+    error: (message = "") => {
+      log(dim("╶─ ") + red("✖ ") + message);
+    },
+  };
+}
+
+// Format process log
+type ProcessTag = "ok" | "warn" | "skip" | "load" | string;
+type TagStyle = {
+  color?: (s: string) => string;
+  dimMessage?: boolean;
+};
+const TAG_STYLES: Record<string, TagStyle> = {
+  ok: { color: green },
+  warn: { color: yellow },
+  skip: { color: dim, dimMessage: true },
+  load: {},
+};
+const formatProcessLog = (tag: ProcessTag, message: string) => {
+  const style = TAG_STYLES[tag] ?? {};
+  const paddedTag = tag.padEnd(4, " ");
+  const finalTag = style.color ? style.color(paddedTag) : paddedTag;
+  const finalMessage = style.dimMessage ? dim(message) : message;
+  return [SPACER + dim("│ ") + finalTag + dim(" │ ") + finalMessage];
+};

package/src/render.ts

@@ -0,0 +1,57 @@
+import type { ConfigEntry } from "./core";
+import pc from "picocolors";
+import { toRelativePath } from "./features/shared/to-relative-path";
+import { createLogger } from "./logger";
+
+// Formatting utilities
+export const dim = pc.dim;
+export const cyan = pc.cyan;
+export const green = pc.green;
+export const bold = pc.bold;
+export const italic = pc.italic;
+export const gray = pc.gray;
+export const yellow = pc.yellow;
+export const red = pc.red;
+export const bgBlack = pc.bgBlack;
+
+// Layout helpers
+export function br(count = 1, enabled = true) {
+  if (!enabled) return;
+  for (let i = 0; i < count; i++) console.log();
+}
+
+// Render feature title
+export function renderTitle(title = "", enabled = true) {
+  if (!enabled) return;
+  console.log(" " + bgBlack(` ${title} `));
+}
+
+// Render discovered Intor configs
+export function renderConfigs(configEntries: ConfigEntry[], enabled = true) {
+  if (!enabled) return;
+  const logger = createLogger();
+
+  // Log header
+  logger.header(`Discovered ${yellow(configEntries.length)} Intor config(s):`, {
+    lineBreakAfter: 1,
+  });
+
+  for (const { filePath, config } of configEntries) {
+    logger.log(`${cyan(config.id)}  ${dim(`⚲ ${toRelativePath(filePath)}`)}`);
+  }
+
+  // Log footer
+  logger.footer("", { lineBreakBefore: 1 });
+}
+
+// Render schema-not-found message for config
+export function renderMissingConfigSchema(configId: string, enabled = true) {
+  if (!enabled) return;
+  const logger = createLogger();
+
+  br();
+  logger.error(
+    cyan(configId) +
+      `: schema not found, run ${italic("intor generate")} and retry`,
+  );
+}

package/src/build/build-schemas/build-schemas.ts

@@ -1,13 +0,0 @@
-import type { BuildInput, Schema } from "../types";
-
-export function buildSchemas(inputs: BuildInput[]): Schema {
-  return {
-    version: 1,
-    generatedAt: new Date().toISOString(),
-    configs: inputs.map((input) => ({
-      id: input.id,
-      locales: input.locales,
-      schemas: input.schemas,
-    })),
-  };
-}

package/src/build/build-schemas/index.ts

@@ -1 +0,0 @@
-export { buildSchemas } from "./build-schemas";

package/src/build/index.ts

@@ -1,3 +0,0 @@
-export { buildTypes } from "./build-types";
-export { buildSchemas } from "./build-schemas";
-export type { BuildInput, Schema } from "./types";

package/src/build/types.ts

@@ -1,20 +0,0 @@
-import type { InferredSchemas } from "../core";
-
-export interface BuildInput {
-  id: string;
-  locales: readonly string[];
-  schemas: InferredSchemas;
-}
-
-// Schema
-export interface Schema {
-  version: number;
-  generatedAt: string;
-  configs: SchemaConfig[];
-}
-
-export interface SchemaConfig {
-  id: string;
-  locales: readonly string[];
-  schemas: InferredSchemas;
-}

package/src/core/generated/index.ts

@@ -1,6 +0,0 @@
-export { writeTypes } from "./write-types";
-
-export { writeSchema } from "./write-schema";
-export { readSchema } from "./read-schema";
-
-export { writeMessagesSnapshot } from "./write-messages-snapshot";

package/src/core/generated/write-messages-snapshot.ts

@@ -1,27 +0,0 @@
-/* eslint-disable unicorn/no-array-sort */
-import type { MessageObject } from "intor";
-import path from "node:path";
-import { DEFAULT_OUT_DIR, DEFAULT_MESSAGES_SNAPSHOT_DIR } from "../constants";
-import { ensureAndWrite } from "./ensure-and-write";
-
-export async function writeMessagesSnapshot(
-  localeMessages: Record<string, MessageObject>,
-): Promise<string[]> {
-  const filePaths: string[] = [];
-
-  for (const locale of Object.keys(localeMessages).sort()) {
-    const messages = localeMessages[locale];
-
-    const filePath = path.join(
-      DEFAULT_OUT_DIR,
-      DEFAULT_MESSAGES_SNAPSHOT_DIR,
-      `${locale}.json`,
-    );
-
-    await ensureAndWrite(filePath, JSON.stringify(messages, null, 2));
-
-    filePaths.push(filePath);
-  }
-
-  return filePaths;
-}

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

@@ -1,9 +0,0 @@
-import type { Schema } from "../../build";
-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(schema: Schema): Promise<string> {
-  const filePath = path.join(DEFAULT_OUT_DIR, DEFAULT_SCHEMA_FILE_NAME);
-  return await ensureAndWrite(filePath, JSON.stringify(schema, null, 2));
-}

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

@@ -1,8 +0,0 @@
-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(types: string): Promise<string> {
-  const filePath = path.join(DEFAULT_OUT_DIR, DEFAULT_TYPES_FILE_NAME);
-  return await ensureAndWrite(filePath, types);
-}

package/src/core/infer-schema/index.ts

@@ -1,4 +0,0 @@
-export { inferSchemas } from "./infer-schemas";
-export type { InferNode, InferredSchemas } from "./types";
-
-export { extractInterpolationNames } from "./replacements/extract-interpolation-names";

package/src/core/infer-schema/infer-schemas.ts

@@ -1,20 +0,0 @@
-import type { InferredSchemas } from "./types";
-import type { MessageObject } from "intor";
-import { inferMessagesSchema } from "./messages";
-import { inferReplacementsSchema } from "./replacements";
-import { inferRichSchema } from "./rich";
-import { stripInternalKeys } from "./utils/strip-internal-keys";
-
-/**
- * Infer all semantic schemas from messages.
- */
-export function inferSchemas(messages: MessageObject): InferredSchemas {
-  const schemas = {
-    messagesSchema: inferMessagesSchema(messages),
-    replacementsSchema: inferReplacementsSchema(messages),
-    richSchema: inferRichSchema(messages),
-  };
-
-  stripInternalKeys(schemas);
-  return schemas;
-}

package/src/core/infer-schema/messages/index.ts

@@ -1 +0,0 @@
-export { inferMessagesSchema } from "./infer-messages-schema";

package/src/core/infer-schema/replacements/index.ts

@@ -1 +0,0 @@
-export { inferReplacementsSchema } from "./infer-replacements-schema";

package/src/core/infer-schema/rich/index.ts

@@ -1 +0,0 @@
-export { inferRichSchema } from "./infer-rich-schema";