intor-cli 0.0.1

package/src/core/diagnostics/utils/get-schema-node-at-path.ts

@@ -0,0 +1,29 @@
+import type { InferNode } from "../../infer-schema";
+
+/**
+ * Resolve a dot-separated key path to a schema node.
+ *
+ * Returns:
+ *   - InferNode if the path exists
+ *   - null if any segment is missing or non-object
+ */
+export function getSchemaNodeAtPath(
+  schema: InferNode,
+  path: string,
+): InferNode | null {
+  if (schema.kind !== "object") return null;
+
+  const segments = path.split(".");
+  let node: InferNode = schema;
+
+  for (const segment of segments) {
+    if (node.kind !== "object") return null;
+
+    const next: InferNode | undefined = node.properties[segment];
+    if (!next) return null;
+
+    node = next;
+  }
+
+  return node;
+}

package/src/core/diagnostics/utils/index-usages-by-key.ts

@@ -0,0 +1,28 @@
+import type { TranslatorMethod } from "../../extract-usages";
+import { resolveKeyPath } from "./resolve-key-path";
+
+/**
+ * Index extracted usages by their resolved message key.
+ */
+export function indexUsagesByKey<
+  T extends { key: string; preKey?: string; method: TranslatorMethod },
+>(usages: T[]): Map<string, T[]> {
+  const map = new Map<string, T[]>();
+
+  for (const usage of usages) {
+    const keyPath = resolveKeyPath(usage.key, usage.preKey);
+    const indexKey = `${usage.method}::${keyPath}`;
+
+    // Append this usage to the existing group for the same key
+    const list = map.get(indexKey);
+
+    if (list) {
+      list.push(usage);
+    } else {
+      // First usage encountered for this message key
+      map.set(indexKey, [usage]);
+    }
+  }
+
+  return map;
+}

package/src/core/diagnostics/utils/resolve-key-path.ts

@@ -0,0 +1,5 @@
+export function resolveKeyPath(key: string, preKey?: string): string {
+  if (!preKey) return key;
+  if (!key) return preKey;
+  return `${preKey}.${key}`;
+}

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

@@ -0,0 +1,87 @@
+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 { isIntorResolvedConfig } from "./is-intor-resolved-config";
+
+const DEFAULT_PATTERNS = ["**/*.{ts,js}"];
+const DEFAULT_IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/*.d.ts",
+  "**/*.test.*",
+  "**/*.test-d.ts",
+];
+
+export interface ConfigEntry {
+  filePath: string;
+  config: IntorResolvedConfig;
+}
+
+/**
+ * Discover and resolve Intor configs from the current workspace.
+ */
+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`);
+
+  const configEntries: ConfigEntry[] = [];
+
+  // Iterate through candidate files
+  for (const file of files) {
+    const absPath = path.resolve(process.cwd(), file);
+    const relPath = path.relative(process.cwd(), absPath);
+
+    // ----------------------------------------------------------------------
+    // Read file content
+    // ----------------------------------------------------------------------
+    let content: string;
+    try {
+      content = await fs.promises.readFile(absPath, "utf8");
+    } catch {
+      log("warn", `failed to read ${relPath}`);
+      continue;
+    }
+
+    // ----------------------------------------------------------------------
+    // Skip files that clearly do not define an Intor config
+    // ----------------------------------------------------------------------
+    if (!content.includes("defineIntorConfig(")) {
+      log("skip", `${relPath} (no defineIntorConfig)`);
+      continue;
+    }
+    log("load", relPath);
+
+    // ----------------------------------------------------------------------
+    // Dynamic import & export inspection
+    // ----------------------------------------------------------------------
+    try {
+      const moduleExports = await import(absPath);
+      let matched = false;
+
+      for (const module of Object.values(moduleExports)) {
+        const config = module as IntorResolvedConfig;
+        if (!isIntorResolvedConfig(config)) continue;
+
+        matched = true;
+
+        configEntries.push({ filePath: absPath, config });
+        log(" ok ", `resolved config "${config.id}"`);
+      }
+
+      if (!matched) {
+        log("warn", `no valid Intor config export found in ${relPath}`);
+      }
+    } catch {
+      log("warn", `failed to import ${relPath}`);
+    }
+  }
+
+  if (configEntries.length === 0) {
+    log("info", "no Intor config discovered");
+  }
+
+  return configEntries;
+}

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

@@ -0,0 +1 @@
+export { discoverConfigs, type ConfigEntry } from "./discover-configs";

package/src/core/discover-configs/is-intor-resolved-config.ts

@@ -0,0 +1,15 @@
+import type { IntorResolvedConfig } from "intor";
+
+export function isIntorResolvedConfig(
+  value: unknown,
+): value is IntorResolvedConfig {
+  if (!value || typeof value !== "object") return false;
+
+  const config = value as IntorResolvedConfig;
+
+  return (
+    typeof config.id === "string" &&
+    typeof config.defaultLocale === "string" &&
+    Array.isArray(config.supportedLocales)
+  );
+}

package/src/core/extract-usages/README.md

@@ -0,0 +1,84 @@
+## Extract Targets
+
+#### • Translator Usages (collectTranslatorUsages)
+
+Extracts translator method bindings only from destructured calls of registered translator factories.
+
+```ts
+// ✅ Supported
+const { t, hasKey } = useTranslator();
+t("home.title");
+hasKey("home.title");
+
+// ❌ Not supported
+const translator = useTranslator();
+translator.t("home.title");
+```
+
+#### • Key Usages (collectKeyUsages)
+
+Extracts static string literal keys from the first argument of registered translator method calls.
+
+```ts
+// ✅ Supported
+t("title");
+t(`title`);
+
+// ❌ Not supported
+t(key);
+t(getTitle());
+t(`title.${key}`);
+```
+
+#### • Replacement Usages (collectReplacementUsages)
+
+Extracts static replacement keys based on method semantics.
+
+- For `t`: from the last object-literal argument.
+- For `tRich`: from the object-literal argument following rich tag definitions.
+
+```ts
+// ✅ Supported
+t("title", { name: "John", count: 3 });
+t("title", options, { name: "John" });
+
+// ❌ Not supported
+t("title");
+t("title", replacements);
+t("title", { name: getName() });
+tRich("title", { link: () => null });
+```
+
+#### • Rich Usages (collectRichUsages)
+
+Extracts static rich tag names from `tRich` calls only.
+
+```ts
+// ✅ Supported
+tRich("title", {
+  link: () => <a>Link</a>,
+  strong: () => <strong>Text</strong>,
+});
+
+// ❌ Not supported
+tRich("title", richTags);
+```
+
+#### • PreKeys (collectPreKeys)
+
+1. If the first argument is a static string literal, use it as preKey.
+2. Otherwise, if the last argument is an object literal containing a static preKey, use it.
+3. Ignore all other cases.
+
+```ts
+// ✅ Supported (positional)
+const { t, hasKey } = useTranslator("home");
+
+// ✅ Supported (options object)
+const { tRich } = getTranslator(_, _, { preKey: "dashboard" });
+
+// ❌ Not supported
+const { t } = useTranslator(prefix);
+const { t } = getTranslator({ preKey: dynamic });
+const translator = useTranslator("home"); // non-destructured binding
+```

package/src/core/extract-usages/collectors/collect-key-usages.ts

@@ -0,0 +1,40 @@
+import type { KeyUsage, TranslatorBindingMap } from "../types";
+import type { SourceFile } from "ts-morph";
+import { isStaticStringLiteral } from "./utils/is-static-string-literal";
+import { walkTranslatorMethodCalls } from "./utils/walk-translator-method-calls";
+
+/**
+ * Collect static translation key usages from translator method calls
+ * within a single source file.
+ */
+export function collectKeyUsages(
+  sourceFile: SourceFile,
+  translatorBindingMap: TranslatorBindingMap,
+): KeyUsage[] {
+  const keyUsages: KeyUsage[] = [];
+
+  walkTranslatorMethodCalls(
+    sourceFile,
+    translatorBindingMap,
+    ({ sourceFile, translatorUsage, call, localName }) => {
+      const firstArg = call.getArguments()[0];
+      if (!isStaticStringLiteral(firstArg)) return;
+
+      // Resolve source location for diagnostics
+      const pos = sourceFile.getLineAndColumnAtPos(firstArg.getStart());
+
+      keyUsages.push({
+        configKey: translatorUsage.configKey,
+        factory: translatorUsage.factory,
+        method: translatorUsage.method,
+        localName,
+        key: firstArg.getLiteralText(),
+        file: sourceFile.getFilePath(),
+        line: pos.line,
+        column: pos.column,
+      });
+    },
+  );
+
+  return keyUsages;
+}

package/src/core/extract-usages/collectors/collect-pre-keys.ts

@@ -0,0 +1,58 @@
+import type { PreKeyMap, TranslatorBindingMap } from "../types";
+import { SyntaxKind, type SourceFile } from "ts-morph";
+import { getObjectArg } from "./utils/get-object-arg";
+import { isStaticStringLiteral } from "./utils/is-static-string-literal";
+import { walkTranslatorBindings } from "./utils/walk-translator-bindings";
+
+const PREKEY_PROPERTY_NAME = "preKey";
+
+/**
+ * Collect static preKey values associated with translator bindings
+ * within a single source file.
+ */
+export function collectPreKeys(
+  sourceFile: SourceFile,
+  translatorBindingMap: TranslatorBindingMap,
+): PreKeyMap {
+  const preKeyMap = new Map<string, string>();
+
+  walkTranslatorBindings(sourceFile, ({ call, binding }) => {
+    // Iterate over destructured translator binding elements (e.g. { t, hasKey, ... })
+    for (const el of binding.getElements()) {
+      const localName = el.getNameNode().getText(); // `t` from `const { t } = useTranslator`
+      if (!translatorBindingMap.has(localName)) continue;
+
+      // -----------------------------------------------------------------------
+      // Resolve static preKey from translator factory arguments
+      // -----------------------------------------------------------------------
+      // 1. From the first positional string argument (e.g. `useTranslator("preKey")`)
+      const firstArg = call.getArguments()[0];
+      if (isStaticStringLiteral(firstArg)) {
+        preKeyMap.set(localName, firstArg.getLiteralText());
+        continue;
+      }
+
+      // 2. From the last options object (e.g. `getTranslator(_, { preKey })`)
+      const lastArg = getObjectArg(call, "last");
+      if (!lastArg) continue;
+
+      // Extract the `preKey` property from the options object
+      const prop = lastArg.getProperty(PREKEY_PROPERTY_NAME);
+      if (!prop || !prop.isKind(SyntaxKind.PropertyAssignment)) continue;
+
+      // Only accept static string initializers as preKey values
+      const value = prop.getInitializer();
+      if (!value) continue;
+      if (
+        !value.isKind(SyntaxKind.StringLiteral) &&
+        !value.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)
+      ) {
+        continue;
+      }
+
+      preKeyMap.set(localName, value.getLiteralText());
+    }
+  });
+
+  return preKeyMap;
+}

package/src/core/extract-usages/collectors/collect-replacement-usages.ts

@@ -0,0 +1,68 @@
+import type { ReplacementUsage, TranslatorBindingMap } from "../types";
+import type { ObjectLiteralExpression, SourceFile } from "ts-morph";
+import { TRANSLATOR_METHOD } from "../translator-registry";
+import { extractStaticObjectKeys } from "./utils/extract-static-object-keys";
+import { getObjectArg } from "./utils/get-object-arg";
+import { isStaticStringLiteral } from "./utils/is-static-string-literal";
+import { walkTranslatorMethodCalls } from "./utils/walk-translator-method-calls";
+
+/**
+ * Collect static replacement usages from translator method calls
+ * within a single source file.
+ */
+export function collectReplacementUsages(
+  sourceFile: SourceFile,
+  translatorBindingMap: TranslatorBindingMap,
+): ReplacementUsage[] {
+  const replacementUsages: ReplacementUsage[] = [];
+
+  walkTranslatorMethodCalls(
+    sourceFile,
+    translatorBindingMap,
+    ({ sourceFile, translatorUsage, call, localName }) => {
+      if (translatorUsage.method !== "t" && translatorUsage.method !== "tRich")
+        return;
+
+      const firstArg = call.getArguments()[0];
+      if (!isStaticStringLiteral(firstArg)) return;
+
+      // ----------------------------------------------------------------------
+      // Resolve replacements based on method semantics
+      // ----------------------------------------------------------------------
+      let replacementArg: ObjectLiteralExpression | null = null;
+
+      if (translatorUsage.method === TRANSLATOR_METHOD.t) {
+        replacementArg = getObjectArg(call, 2);
+      }
+
+      if (translatorUsage.method === TRANSLATOR_METHOD.tRich) {
+        replacementArg = getObjectArg(call, 3);
+      }
+
+      if (!replacementArg) return;
+
+      // ----------------------------------------------------------------------
+      // Extract static replacement keys from the replacements object
+      // ----------------------------------------------------------------------
+      const keys: string[] = extractStaticObjectKeys(replacementArg);
+      if (keys.length === 0) return;
+
+      // Resolve source location for diagnostics
+      const pos = sourceFile.getLineAndColumnAtPos(replacementArg.getStart());
+
+      replacementUsages.push({
+        configKey: translatorUsage.configKey,
+        factory: translatorUsage.factory,
+        method: translatorUsage.method,
+        localName,
+        key: firstArg.getLiteralText(),
+        replacements: keys,
+        file: sourceFile.getFilePath(),
+        line: pos.line,
+        column: pos.column,
+      });
+    },
+  );
+
+  return replacementUsages;
+}

package/src/core/extract-usages/collectors/collect-rich-usages.ts

@@ -0,0 +1,57 @@
+import type { RichUsage, TranslatorBindingMap } from "../types";
+import type { SourceFile } from "ts-morph";
+import { extractStaticObjectKeys } from "./utils/extract-static-object-keys";
+import { getObjectArg } from "./utils/get-object-arg";
+import { isStaticStringLiteral } from "./utils/is-static-string-literal";
+import { walkTranslatorMethodCalls } from "./utils/walk-translator-method-calls";
+
+/**
+ * Collect static rich tag usages from translator method calls
+ * within a single source file.
+ */
+export function collectRichUsages(
+  sourceFile: SourceFile,
+  translatorBindingMap: TranslatorBindingMap,
+): RichUsage[] {
+  const richUsages: RichUsage[] = [];
+
+  walkTranslatorMethodCalls(
+    sourceFile,
+    translatorBindingMap,
+    ({ sourceFile, translatorUsage, call, localName }) => {
+      if (translatorUsage.method !== "tRich") return;
+
+      const firstArg = call.getArguments()[0];
+      if (!isStaticStringLiteral(firstArg)) return;
+
+      // ----------------------------------------------------------------------
+      // Resolve rich tags from the first object-literal argument after the key
+      // ----------------------------------------------------------------------
+      const richArg = getObjectArg(call, 2);
+      if (!richArg) return;
+
+      // ----------------------------------------------------------------------
+      // Extract static rich tag definitions from the rich object argument
+      // ----------------------------------------------------------------------
+      const keys: string[] = extractStaticObjectKeys(richArg);
+      if (keys.length === 0) return;
+
+      // Resolve source location for diagnostics
+      const pos = sourceFile.getLineAndColumnAtPos(richArg.getStart());
+
+      richUsages.push({
+        configKey: translatorUsage.configKey,
+        factory: translatorUsage.factory,
+        method: translatorUsage.method,
+        localName,
+        key: firstArg.getLiteralText(),
+        rich: keys,
+        file: sourceFile.getFilePath(),
+        line: pos.line,
+        column: pos.column,
+      });
+    },
+  );
+
+  return richUsages;
+}

package/src/core/extract-usages/collectors/collect-translator-bindings.ts

@@ -0,0 +1,56 @@
+import type { TranslatorBinding, TranslatorBindingMap } from "../types";
+import { SyntaxKind, type SourceFile } from "ts-morph";
+import { getConfigKey } from "../../../core/extract-usages/collectors/utils/get-config-key";
+import {
+  TRANSLATOR_FACTORIES,
+  TRANSLATOR_METHODS,
+  type TranslatorFactory,
+  type TranslatorMethod,
+} from "../translator-registry";
+import { walkTranslatorBindings } from "./utils/walk-translator-bindings";
+
+export const TRANSLATOR_FACTORIES_SET = new Set<TranslatorFactory>(
+  TRANSLATOR_FACTORIES,
+);
+export const TRANSLATOR_METHODS_SET = new Set<TranslatorMethod>(
+  TRANSLATOR_METHODS,
+);
+
+/**
+ * Collect static translator bindings from supported translator factories
+ * within a single source file.
+ */
+export function collectTranslatorBindings(
+  sourceFile: SourceFile,
+): TranslatorBindingMap {
+  const translatorBindingMap = new Map<string, TranslatorBinding>();
+
+  walkTranslatorBindings(sourceFile, ({ call, binding }) => {
+    // ----------------------------------------------------------------------
+    // Resolve the translator factory name and ensure it is supported
+    // ----------------------------------------------------------------------
+    const expr = call.getExpression();
+    if (!expr.isKind(SyntaxKind.Identifier)) return;
+    const factoryName = expr.getText() as TranslatorFactory;
+    if (!TRANSLATOR_FACTORIES_SET.has(factoryName)) return;
+
+    // Iterate over destructured translator binding elements (e.g. { t, hasKey, ... })
+    for (const el of binding.getElements()) {
+      // ----------------------------------------------------------------------
+      // Resolve the translator method name from the destructured binding
+      // ----------------------------------------------------------------------
+      const localName = el.getNameNode().getText(); // `t` from `const { t } = useTranslator`
+      const aliasName = el.getPropertyNameNode()?.getText(); // `translate` from `const { t: translate } = useTranslator`
+      const methodName = (aliasName ?? localName) as TranslatorMethod; // aliasName > originalName
+      if (!TRANSLATOR_METHODS_SET.has(methodName)) continue;
+
+      translatorBindingMap.set(localName, {
+        factory: factoryName,
+        method: methodName,
+        configKey: getConfigKey(call),
+      });
+    }
+  });
+
+  return translatorBindingMap;
+}

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

@@ -0,0 +1,5 @@
+export { collectTranslatorBindings } from "./collect-translator-bindings";
+export { collectKeyUsages } from "./collect-key-usages";
+export { collectReplacementUsages } from "./collect-replacement-usages";
+export { collectRichUsages } from "./collect-rich-usages";
+export { collectPreKeys } from "./collect-pre-keys";

package/src/core/extract-usages/collectors/utils/extract-static-object-keys.ts

@@ -0,0 +1,31 @@
+import { SyntaxKind, type ObjectLiteralExpression } from "ts-morph";
+
+/**
+ * Extract static property keys from an object literal expression.
+ */
+export function extractStaticObjectKeys(
+  obj: ObjectLiteralExpression,
+): string[] {
+  const keys: string[] = [];
+
+  // Walk through object literal properties
+  for (const prop of obj.getProperties()) {
+    // Only support simple property assignments (skip spreads, methods, etc.)
+    if (!prop.isKind(SyntaxKind.PropertyAssignment)) continue;
+
+    const nameNode = prop.getNameNode();
+
+    // { foo: ... }
+    if (nameNode.isKind(SyntaxKind.Identifier)) {
+      keys.push(nameNode.getText());
+      continue;
+    }
+
+    // { "foo": ... }
+    if (nameNode.isKind(SyntaxKind.StringLiteral)) {
+      keys.push(nameNode.getLiteralText());
+    }
+  }
+
+  return keys;
+}

package/src/core/extract-usages/collectors/utils/get-config-key.ts

@@ -0,0 +1,15 @@
+import { SyntaxKind, type CallExpression } from "ts-morph";
+
+export function getConfigKey(call: CallExpression): string | undefined {
+  const typeArgs = call.getTypeArguments();
+  if (typeArgs.length === 0) return undefined;
+
+  const firstArg = typeArgs[0];
+
+  if (!firstArg.isKind(SyntaxKind.LiteralType)) return undefined;
+
+  const literal = firstArg.getLiteral();
+  if (!literal || !literal.isKind(SyntaxKind.StringLiteral)) return undefined;
+
+  return literal.getLiteralText();
+}

package/src/core/extract-usages/collectors/utils/get-object-arg.ts

@@ -0,0 +1,42 @@
+import type {
+  CallExpression,
+  Node,
+  ObjectLiteralExpression,
+  ts,
+} from "ts-morph";
+import { SyntaxKind } from "ts-morph";
+
+/**
+ * position:
+ * - "first" | "last"
+ * - number: 1-based argument position (2 = second argument)
+ */
+type ObjectArgPosition = "first" | "last" | number;
+
+export function getObjectArg(
+  node: CallExpression,
+  position: ObjectArgPosition,
+): ObjectLiteralExpression | null {
+  const args = node.getArguments();
+
+  let target: Node<ts.Node> | undefined | null = null;
+
+  switch (position) {
+    case "first": {
+      target = args[0];
+      break;
+    }
+
+    case "last": {
+      target = args.at(-1);
+      break;
+    }
+
+    default: {
+      target = args[position - 1];
+    }
+  }
+
+  if (!target?.isKind(SyntaxKind.ObjectLiteralExpression)) return null;
+  return target;
+}

package/src/core/extract-usages/collectors/utils/is-static-string-literal.ts

@@ -0,0 +1,26 @@
+import type {
+  Node,
+  NoSubstitutionTemplateLiteral,
+  StringLiteral,
+  ts,
+} from "ts-morph";
+import { SyntaxKind } from "ts-morph";
+
+/**
+ * Check whether a node is a static string literal.
+ *
+ * Supports:
+ * - "text"
+ * - 'text'
+ * - \`text\` (no substitutions)
+ */
+export function isStaticStringLiteral(
+  node: Node<ts.Node> | undefined,
+): node is StringLiteral | NoSubstitutionTemplateLiteral {
+  if (!node) return false;
+
+  return (
+    node.isKind(SyntaxKind.StringLiteral) ||
+    node.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)
+  );
+}