intor-cli 0.0.14 → 0.0.16

package/src/core/discover-configs/discover-configs.ts

@@ -1,20 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
-import fg from "fast-glob";
 import { type IntorResolvedConfig } from "intor";
-import { createLogger } from "../scan-logger";
+import { createLogger } from "../../logger";
+import { br, cyan, yellow } from "../../render";
+import { scanFiles } from "../scan";
 import { isIntorResolvedConfig } from "./is-intor-resolved-config";
 import { loadModule } from "./load-module";
 
-const DEFAULT_PATTERNS = ["**/*.{ts,js}"];
-const DEFAULT_IGNORE = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/*.d.ts",
-  "**/*.test.*",
-  "**/*.test-d.ts",
-];
-
 export interface ConfigEntry {
   filePath: string;
   config: IntorResolvedConfig;
@@ -22,13 +14,23 @@ export interface ConfigEntry {
 
 /**
  * Discover and resolve Intor configs from the current workspace.
+ *
+ * Notes:
+ * - Configs must be declared via `defineIntorConfig(...)`
+ * - Dynamic or computed configs are intentionally not supported
  */
-export async function discoverConfigs(debug?: boolean): Promise<ConfigEntry[]> {
-  const files = await fg(DEFAULT_PATTERNS, { ignore: DEFAULT_IGNORE });
-  const log = createLogger(debug);
-  log("scan", `found ${files.length} candidate files`);
+export async function discoverConfigs(debug = false): Promise<ConfigEntry[]> {
+  const files = await scanFiles();
+
+  if (debug) br();
+  const logger = createLogger(debug);
+  logger.header(
+    `Discover configs - scanning ${yellow(files.length)} candidate files`,
+    { kind: "process", lineBreakAfter: 1 },
+  );
 
   const configEntries: ConfigEntry[] = [];
+  const seenIds = new Set<string>();
 
   // Iterate through candidate files
   for (const file of files) {
@@ -42,7 +44,7 @@ export async function discoverConfigs(debug?: boolean): Promise<ConfigEntry[]> {
     try {
       content = await fs.promises.readFile(absPath, "utf8");
     } catch {
-      log("warn", `failed to read ${relPath}`);
+      logger.process("warn", `failed to read ${relPath}`);
       continue;
     }
 
@@ -50,10 +52,10 @@ export async function discoverConfigs(debug?: boolean): Promise<ConfigEntry[]> {
     // Skip files that clearly do not define an Intor config
     // ----------------------------------------------------------------------
     if (!content.includes("defineIntorConfig(")) {
-      log("skip", `${relPath} (no defineIntorConfig)`);
+      logger.process("skip", `${relPath} (missing defineIntorConfig)`);
       continue;
     }
-    log("load", relPath);
+    logger.process("load", relPath);
 
     // ----------------------------------------------------------------------
     // Dynamic import & export inspection
@@ -61,28 +63,47 @@ export async function discoverConfigs(debug?: boolean): Promise<ConfigEntry[]> {
     try {
       const moduleExports = await loadModule(absPath);
       let matched = false;
+      let resolvedCount = 0;
 
+      // Loop through all exports
       for (const module of Object.values(moduleExports)) {
         const config = module as IntorResolvedConfig;
-        if (!isIntorResolvedConfig(config)) continue;
-
+        if (!isIntorResolvedConfig(module)) continue;
         matched = true;
 
+        // Ensure config ids are unique across the workspace
+        if (seenIds.has(module.id)) {
+          logger.process(
+            "warn",
+            `duplicate config id "${module.id}" (ignored, ${relPath})`,
+          );
+          continue;
+        }
+
+        seenIds.add(module.id);
+        resolvedCount++;
+
         configEntries.push({ filePath: absPath, config });
-        log(" ok ", `resolved config "${config.id}"`);
+        logger.process("ok", `resolved config ${cyan(config.id)}`);
       }
 
-      if (!matched) {
-        log("warn", `no valid Intor config export found in ${relPath}`);
+      if (matched && resolvedCount === 0) {
+        logger.process("warn", `no usable Intor config export (${relPath})`);
       }
     } catch {
-      log("warn", `failed to import ${relPath}`);
+      logger.process("warn", `failed to import module (${relPath})`);
     }
   }
 
   if (configEntries.length === 0) {
-    log("info", "no Intor config discovered");
+    logger.process("warn", "no Intor config discovered");
   }
 
-  return configEntries;
+  logger.footer(
+    `scanned ${yellow(files.length)} files, resolved ${yellow(
+      configEntries.length,
+    )} Intor config(s)`,
+    { kind: "process", lineBreakBefore: 1 },
+  );
+  return configEntries.sort((a, b) => a.filePath.localeCompare(b.filePath));
 }

package/src/core/extract-usages/extract-usages.ts

@@ -1,8 +1,8 @@
 import type { ExtractedUsages } from "./types";
-import pc from "picocolors";
-import { createLogger } from "../scan-logger";
+import type { SourceFile } from "ts-morph";
+import { createLogger } from "../../logger";
+import { br, yellow } from "../../render";
 import { extractUsagesFromSourceFile } from "./extract-usages-from-source-file";
-import { loadSourceFilesFromTsconfig } from "./load-source-files-from-tscofnig";
 
 /** Check whether a file-level extraction produced any meaningful usage */
 const isEmpty = (u: ExtractedUsages) =>
@@ -12,16 +12,23 @@ const isEmpty = (u: ExtractedUsages) =>
   u.trans.length === 0;
 
 export interface ExtractUsagesOptions {
-  tsconfigPath?: string;
+  sourceFiles?: SourceFile[];
   debug?: boolean;
 }
 
 /**
  * Extract all static translator usages from a TypeScript project.
  */
-export function extractUsages(options?: ExtractUsagesOptions): ExtractedUsages {
-  const { tsconfigPath = "tsconfig.json", debug = false } = options || {};
-  const log = createLogger(debug);
+export function extractUsages({
+  sourceFiles = [],
+  debug = false,
+}: ExtractUsagesOptions = {}): ExtractedUsages {
+  if (debug) br();
+  const logger = createLogger(debug);
+  logger.header(
+    `Extract usages - processing ${yellow(sourceFiles.length)} source files`,
+    { kind: "process", lineBreakAfter: 1 },
+  );
 
   const result: ExtractedUsages = {
     preKey: [],
@@ -35,36 +42,38 @@ export function extractUsages(options?: ExtractUsagesOptions): ExtractedUsages {
   let scannedFiles = 0;
   let matchedFiles = 0;
 
-  const sourceFiles = loadSourceFilesFromTsconfig(tsconfigPath, debug);
-
   // Process each source file independently
   for (const sourceFile of sourceFiles) {
     scannedFiles++;
-    log("scan", sourceFile.getFilePath());
 
     // ---------------------------------------------------------------------------
     // File-level extraction (pure analysis, no side effects)
     // ---------------------------------------------------------------------------
-    const partial = extractUsagesFromSourceFile(sourceFile);
-    if (isEmpty(partial)) continue;
+    const partialUsages = extractUsagesFromSourceFile(sourceFile);
+
+    if (isEmpty(partialUsages)) {
+      logger.process("skip", sourceFile.getFilePath());
+      continue;
+    }
+
+    logger.process("ok", sourceFile.getFilePath());
     matchedFiles++;
 
     // ---------------------------------------------------------------------------
     // Merge file-level results into the project-level result
     // ---------------------------------------------------------------------------
-    result.preKey.push(...partial.preKey);
-    result.key.push(...partial.key);
-    result.replacement.push(...partial.replacement);
-    result.rich.push(...partial.rich);
-    result.trans.push(...partial.trans);
-  }
-
-  // Debug summary
-  if (debug) {
-    console.log(
-      pc.dim(` › Scanned ${scannedFiles} files, matched ${matchedFiles} \n`),
-    );
+    result.preKey.push(...partialUsages.preKey);
+    result.key.push(...partialUsages.key);
+    result.replacement.push(...partialUsages.replacement);
+    result.rich.push(...partialUsages.rich);
+    result.trans.push(...partialUsages.trans);
   }
 
+  logger.footer(
+    `scanned ${yellow(scannedFiles)} files, extracted from ${yellow(
+      matchedFiles,
+    )} file(s)`,
+    { kind: "process", lineBreakBefore: 1 },
+  );
   return result;
 }

package/src/core/index.ts

@@ -1,19 +1,21 @@
 // discover-configs
-export { discoverConfigs } from "./discover-configs";
+export { discoverConfigs, type ConfigEntry } from "./discover-configs";
 
 // collect-messages
 export {
   collectRuntimeMessages,
   collectOtherLocaleMessages,
+  type ReaderOptions,
+  type MergeOverrides,
 } from "./collect-messages";
 
 // infer-schema
 export {
-  inferSchemas,
+  inferShapes,
   type InferNode,
-  type InferredSchemas,
+  type InferredShapes,
   extractInterpolationNames,
-} from "./infer-schema";
+} from "./infer-shape";
 
 // extract-usages
 export {
@@ -28,13 +30,16 @@ export {
   type RichUsage,
 } from "./extract-usages";
 
-// generated
+// artifacts
 export {
+  buildTypes,
   writeTypes,
+  buildSchema,
   writeSchema,
   readSchema,
-  writeMessagesSnapshot,
-} from "./generated";
+  type GeneratedSchema,
+  type SchemaEntry,
+} from "./artifacts";
 
 // constants
 export { DEFAULT_OUT_DIR, EXTRA_EXTS, type ExtraExt } from "./constants";

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

@@ -0,0 +1,4 @@
+export { inferShapes } from "./infer-shapes";
+export type { InferNode, InferredShapes } from "./types";
+
+export { extractInterpolationNames } from "./utils/extract-interpolation-names";

package/src/core/{infer-schema/messages/infer-messages-schema.ts → infer-shape/infer-messages-shape.ts}

@@ -1,15 +1,12 @@
-import type { InferNode } from "../types";
+import type { InferNode } from "./types";
 import type { MessageObject, MessageValue } from "intor";
-import { inferObject } from "../utils/infer-object";
-import { isMessageObject } from "../utils/is-message-object";
+import { inferObject } from "./utils/infer-object";
+import { isMessageObject } from "./utils/is-message-object";
 
 /**
- * Infer message value types from a message object.
- *
- * Traverses message values and derives a semantic schema tree.
- * Rendering to TypeScript type string should be done in a later stage.
+ * Infer the semantic shape of message values from a message object.
  */
-export function inferMessagesSchema(messages: MessageObject): InferNode {
+export function inferMessagesShape(messages: MessageObject): InferNode {
   if (!isMessageObject(messages) || Object.keys(messages).length === 0) {
     return { kind: "none" };
   }
@@ -17,8 +14,6 @@ export function inferMessagesSchema(messages: MessageObject): InferNode {
 }
 
 /**
- * Infer a semantic node from a single message value.
- *
  * - Primitive values → primitive node
  * - Arrays → array node (first-element policy)
  * - Objects → object node (recursive, empty pruned)

package/src/core/{infer-schema/replacements/infer-replacements-schema.ts → infer-shape/infer-replacements-shape.ts}

@@ -1,16 +1,13 @@
-import type { InferNode } from "../types";
+import type { InferNode } from "./types";
 import type { MessageObject, MessageValue } from "intor";
-import { inferObject } from "../utils/infer-object";
-import { isMessageObject } from "../utils/is-message-object";
-import { extractInterpolationNames } from "./extract-interpolation-names";
+import { extractInterpolationNames } from "./utils/extract-interpolation-names";
+import { inferObject } from "./utils/infer-object";
+import { isMessageObject } from "./utils/is-message-object";
 
 /**
- * Infer interpolation replacement schema from a message object.
- *
- * Traverses message values and extracts `{...}` interpolation names
- * into a semantic schema tree.
+ * Infer the semantic shape of interpolation replacements from a message object.
  */
-export function inferReplacementsSchema(messages: MessageObject): InferNode {
+export function inferReplacementsShape(messages: MessageObject): InferNode {
   if (!isMessageObject(messages) || Object.keys(messages).length === 0) {
     return { kind: "none" };
   }
@@ -18,8 +15,6 @@ export function inferReplacementsSchema(messages: MessageObject): InferNode {
 }
 
 /**
- * Infer replacement information from a single message value.
- *
  * - Strings are scanned for `{...}` interpolations
  * - Objects are traversed recursively
  * - Arrays and unsupported values are ignored

package/src/core/{infer-schema/rich/infer-rich-schema.ts → infer-shape/infer-rich-shape.ts}

@@ -1,16 +1,13 @@
-import type { InferNode } from "../types";
+import type { InferNode } from "./types";
 import type { MessageObject, MessageValue } from "intor";
 import { tokenize, type Token } from "intor";
-import { inferObject } from "../utils/infer-object";
-import { isMessageObject } from "../utils/is-message-object";
+import { inferObject } from "./utils/infer-object";
+import { isMessageObject } from "./utils/is-message-object";
 
 /**
- * Infer rich tag schema from a message object.
- *
- * Traverses message values and extracts rich tag names
- * into a semantic schema tree.
+ * Infer the semantic shape of rich tags from a message object.
  */
-export function inferRichSchema(messages: MessageObject): InferNode {
+export function inferRichShape(messages: MessageObject): InferNode {
   if (!isMessageObject(messages) || Object.keys(messages).length === 0) {
     return { kind: "none" };
   }
@@ -18,8 +15,6 @@ export function inferRichSchema(messages: MessageObject): InferNode {
 }
 
 /**
- * Infer rich tag information from a single message value.
- *
  * - Strings are tokenized and analyzed for rich tags
  * - Objects are traversed recursively
  * - Arrays and unsupported values are ignored

package/src/core/infer-shape/infer-shapes.ts

@@ -0,0 +1,21 @@
+import type { InferredShapes } from "./types";
+import type { MessageObject } from "intor";
+import { inferMessagesShape } from "./infer-messages-shape";
+import { inferReplacementsShape } from "./infer-replacements-shape";
+import { inferRichShape } from "./infer-rich-shape";
+import { stripInternalKeys } from "./utils/strip-internal-keys";
+
+/**
+ * Infer all semantic shapes from messages.
+ */
+export function inferShapes(messages: MessageObject): InferredShapes {
+  const inferredShapes: InferredShapes = {
+    messages: inferMessagesShape(messages),
+    replacements: inferReplacementsShape(messages),
+    rich: inferRichShape(messages),
+  };
+
+  stripInternalKeys(inferredShapes);
+
+  return inferredShapes;
+}

package/src/core/{infer-schema → infer-shape}/types.ts

@@ -35,8 +35,8 @@ export interface InferRecordNode {
   kind: "record";
 }
 
-export interface InferredSchemas {
-  messagesSchema: InferNode;
-  replacementsSchema: InferNode;
-  richSchema: InferNode;
+export interface InferredShapes {
+  messages: InferNode;
+  replacements: InferNode;
+  rich: InferNode;
 }

package/src/core/scan/index.ts

@@ -0,0 +1,2 @@
+export { loadSourceFiles } from "./load-source-files";
+export { scanFiles } from "./scan-files";

package/src/core/{extract-usages/load-source-files-from-tscofnig.ts → scan/load-source-files.ts}

@@ -1,7 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { Project, type SourceFile } from "ts-morph";
-import { createLogger } from "../scan-logger";
+import { createLogger } from "../../logger";
+import { br, yellow } from "../../render";
 
 /**
  * Load source files from a tsconfig.
@@ -16,47 +17,65 @@ import { createLogger } from "../scan-logger";
  *   where the root tsconfig only contains references.
  * - References are followed non-recursively on purpose.
  */
-export function loadSourceFilesFromTsconfig(
+export function loadSourceFiles(
   tsconfigPath: string,
-  debug: boolean,
+  debug = false,
 ): SourceFile[] {
-  const log = createLogger(debug);
+  if (debug) br();
+  const logger = createLogger(debug);
+  logger.header("Load source files - processing tsconfig", {
+    kind: "process",
+  });
+
   // ---------------------------------------------------------------------------
-  // 1. Try loading source files directly from the given tsconfig
+  // Try loading source files directly from the given tsconfig
   // ---------------------------------------------------------------------------
   const project = new Project({ tsConfigFilePath: tsconfigPath });
   const files = project.getSourceFiles();
-  if (files.length > 0) return files;
+  if (files.length > 0) {
+    logger.footer(`loaded ${yellow(files.length)} files`, { kind: "process" });
+    return files;
+  }
 
   // ---------------------------------------------------------------------------
-  // 2. No source files found → attempt to follow project references
+  // No source files found, attempt to follow project references
   // ---------------------------------------------------------------------------
   const configDir = path.dirname(tsconfigPath);
-  const rawConfig = JSON.parse(fs.readFileSync(tsconfigPath, "utf8"));
-  const references: { path: string }[] = rawConfig.references ?? [];
+  const rawTsConfig = JSON.parse(fs.readFileSync(tsconfigPath, "utf8"));
+
+  // Project references (e.g. { references: [ { path: "./tsconfig.app.json" } ] })
+  const references: { path: string }[] = rawTsConfig.references ?? [];
+  if (references.length === 0) {
+    logger.footer("no source files found", { kind: "process" });
+    return [];
+  }
 
-  if (references.length === 0) return [];
-  log("info", `no source files found, following project references`);
+  logger.log();
+  logger.process("load", `references (${references.length})`);
 
   // ---------------------------------------------------------------------------
-  // 3. Load source files from each referenced tsconfig
+  // Load source files from each referenced tsconfig
   // ---------------------------------------------------------------------------
   const collected: SourceFile[] = [];
 
   for (const ref of references) {
-    const refPath = path.resolve(configDir, ref.path);
+    const refPath = path.relative(configDir, ref.path);
 
     // Skip missing referenced tsconfig files
     if (!fs.existsSync(refPath)) {
-      log("warn", `referenced tsconfig not found: ${refPath}`);
+      logger.process("warn", `referenced tsconfig not found: ${refPath}`);
       continue;
     }
 
-    log("ref ", `${path.relative(process.cwd(), refPath)}`);
+    logger.process("load", `${path.relative(process.cwd(), refPath)}`);
 
     const refProject = new Project({ tsConfigFilePath: refPath });
     collected.push(...refProject.getSourceFiles());
   }
 
+  logger.footer(`loaded ${yellow(collected.length)} files`, {
+    kind: "process",
+    lineBreakBefore: 1,
+  });
   return collected;
 }

package/src/core/scan/scan-files.ts

@@ -0,0 +1,25 @@
+import fg from "fast-glob";
+
+const DEFAULT_PATTERNS = ["**/*.{ts,js}"];
+
+const DEFAULT_IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/*.d.ts",
+  "**/*.test.*",
+  "**/*.test-d.ts",
+];
+
+interface ScanFilesOptions {
+  patterns?: string[];
+  ignore?: string[];
+  cwd?: string;
+}
+
+export async function scanFiles({
+  patterns = DEFAULT_PATTERNS,
+  ignore = DEFAULT_IGNORE,
+  cwd = process.cwd(),
+}: ScanFilesOptions = {}) {
+  return fg(patterns, { ignore, cwd });
+}

package/src/features/check/build-scoped-usages.ts

@@ -0,0 +1,35 @@
+import type { ExtractedUsages } from "../../core";
+import { dedupePreKeyUsages } from "./dedupe-pre-key-usages";
+
+function resolveConfigKey(
+  usageConfigKey: string | undefined,
+  defaultConfigKey: string,
+) {
+  if (usageConfigKey === "__default__") return defaultConfigKey;
+  if (usageConfigKey == null) return defaultConfigKey;
+  return usageConfigKey;
+}
+
+/**
+ * Build per-config scoped usages from extracted usages
+ */
+export const buildScopeUsages = ({
+  usages,
+  defaultConfigKey,
+  configKey,
+}: {
+  usages: ExtractedUsages;
+  defaultConfigKey: string;
+  configKey: string;
+}): ExtractedUsages => {
+  const match = (u: { configKey?: string }) =>
+    resolveConfigKey(u.configKey, defaultConfigKey) === configKey;
+
+  return {
+    preKey: dedupePreKeyUsages(usages.preKey.filter((el) => match(el))),
+    key: usages.key.filter((el) => match(el)),
+    replacement: usages.replacement.filter((el) => match(el)),
+    rich: usages.rich.filter((el) => match(el)),
+    trans: usages.trans.filter((el) => match(el)),
+  };
+};