intor-cli 0.0.1

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

@@ -0,0 +1,42 @@
+/**
+ * Result of a semantic inference step.
+ *
+ * - none: no meaningful type could be inferred (intentionally skipped)
+ * - inferred: contains a concrete TypeScript type representation
+ */
+
+export type InferNode =
+  | InferNoneNode
+  | InferPrimitiveNode
+  | InferArrayNode
+  | InferObjectNode
+  | InferRecordNode;
+
+export interface InferNoneNode {
+  kind: "none";
+}
+
+export interface InferPrimitiveNode {
+  kind: "primitive";
+  type: "string" | "number" | "boolean" | "null";
+}
+
+export interface InferArrayNode {
+  kind: "array";
+  element: InferNode;
+}
+
+export interface InferObjectNode {
+  kind: "object";
+  properties: Record<string, InferNode>;
+}
+
+export interface InferRecordNode {
+  kind: "record";
+}
+
+export interface InferredSchemas {
+  messagesSchema: InferNode;
+  replacementsSchema: InferNode;
+  richSchema: InferNode;
+}

package/src/core/infer-schema/utils/infer-object.ts

@@ -0,0 +1,32 @@
+import type { InferNode } from "../types";
+import type { MessageObject, MessageValue } from "intor";
+
+/**
+ * Infer an object-like semantic node by aggregating inferred children.
+ *
+ * - Delegates inference to child nodes
+ * - Prunes branches without semantic meaning
+ * - Returns `none` if no children remain
+ */
+export function inferObject(
+  value: MessageObject,
+  inferChild: (value: MessageValue) => InferNode,
+): InferNode {
+  const properties: Record<string, InferNode> = {};
+
+  for (const [key, val] of Object.entries(value)) {
+    const child = inferChild(val);
+
+    // Skip branches without semantic meaning
+    if (child.kind === "none") continue;
+
+    properties[key] = child;
+  }
+
+  // No inferred children => no semantic result
+  if (Object.keys(properties).length === 0) {
+    return { kind: "none" };
+  }
+
+  return { kind: "object", properties };
+}

package/src/core/infer-schema/utils/is-message-object.ts

@@ -0,0 +1,5 @@
+import type { MessageObject } from "intor";
+
+export function isMessageObject(value: unknown): value is MessageObject {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -0,0 +1,42 @@
+import type { GeneratedSchema } from "../build";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { DEFAULT_OUT_DIR, DEFAULT_SCHEMA_FILE } from "./constants";
+
+export interface ReadGeneratedSchemaOptions {
+  cwd?: string;
+  outDir?: string;
+  fileName?: string;
+}
+
+export async function readGeneratedSchema(
+  options: ReadGeneratedSchemaOptions = {},
+): Promise<GeneratedSchema> {
+  const {
+    cwd = process.cwd(),
+    outDir = DEFAULT_OUT_DIR,
+    fileName = DEFAULT_SCHEMA_FILE,
+  } = options;
+
+  const schemaPath = path.resolve(cwd, outDir, fileName);
+
+  let raw: string;
+
+  // Try to read
+  try {
+    raw = await fs.readFile(schemaPath, "utf8");
+  } catch {
+    throw new Error(
+      `Failed to read intor schema file at "${schemaPath}".\n Have you run "intor generate"?`,
+    );
+  }
+
+  // Try to parse
+  try {
+    return JSON.parse(raw) as GeneratedSchema;
+  } catch {
+    throw new Error(
+      `Invalid JSON format in intor schema file at "${schemaPath}".`,
+    );
+  }
+}

package/src/core/scan-logger.ts

@@ -0,0 +1,10 @@
+import pc from "picocolors";
+
+const log = (tag: string, message: string) => {
+  console.log(pc.dim(` (${tag})`) + pc.gray(` ${message}`));
+};
+
+export function createLogger(enabled?: boolean) {
+  if (!enabled) return () => {};
+  return log;
+}

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

@@ -0,0 +1,51 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  DEFAULT_OUT_DIR,
+  DEFAULT_TYPES_FILE,
+  DEFAULT_SCHEMA_FILE,
+} from "./constants";
+
+export interface WriteOptions {
+  cwd?: string;
+  outDir?: string;
+  typesFileName?: string;
+  schemaFileName?: string;
+}
+
+export interface WriteGeneratedFilesResult {
+  outDir: string;
+  typesPath: string;
+  schemaPath: string;
+}
+
+export async function writeGeneratedFiles(
+  { types, schema }: { types: string; schema: unknown },
+  options: WriteOptions = {},
+): Promise<WriteGeneratedFilesResult> {
+  const {
+    cwd = process.cwd(),
+    outDir = DEFAULT_OUT_DIR,
+    typesFileName = DEFAULT_TYPES_FILE,
+    schemaFileName = DEFAULT_SCHEMA_FILE,
+  } = options;
+
+  const resolvedOutDir = path.resolve(cwd, outDir);
+  const typesPath = path.join(resolvedOutDir, typesFileName);
+  const schemaPath = path.join(resolvedOutDir, schemaFileName);
+
+  // Ensure .intor directory exists
+  await fs.mkdir(resolvedOutDir, { recursive: true });
+
+  // Write types (as-is)
+  await fs.writeFile(typesPath, types, "utf8");
+
+  // Write schema (pretty JSON for diff / debug)
+  await fs.writeFile(schemaPath, JSON.stringify(schema, null, 2), "utf8");
+
+  return {
+    outDir: resolvedOutDir,
+    typesPath,
+    schemaPath,
+  };
+}

package/src/features/check/check.ts

@@ -0,0 +1,75 @@
+/* eslint-disable unicorn/no-process-exit */
+import type { ReadGeneratedSchemaOptions } from "../../core";
+import type { ExtractUsagesOptions } from "../../core/extract-usages/extract-usages";
+import {
+  readGeneratedSchema,
+  extractUsages,
+  collectDiagnostics,
+  groupDiagnostics,
+} from "../../core";
+import { printTitle } from "../../features/print-title";
+import { spinner } from "../spinner";
+import { printSummary } from "./print-summary";
+
+function resolveConfigKey(
+  usageConfigKey: string | undefined,
+  defaultConfigKey: string,
+) {
+  if (usageConfigKey === "__default__") return defaultConfigKey;
+  if (usageConfigKey == null) return defaultConfigKey;
+  return usageConfigKey;
+}
+
+export async function check(
+  readOptions?: ReadGeneratedSchemaOptions,
+  extractOptions?: ExtractUsagesOptions,
+) {
+  printTitle("Checking intor diagnostics");
+  spinner.start();
+
+  try {
+    // -----------------------------------------------------------------------
+    // Read generated schema
+    // -----------------------------------------------------------------------
+    const generatedSchema = await readGeneratedSchema(readOptions);
+
+    // -----------------------------------------------------------------------
+    // Extract usages
+    // -----------------------------------------------------------------------
+    const usages = extractUsages(extractOptions);
+
+    // Use first config's id as default key
+    const defaultConfigKey = generatedSchema.configs[0]?.id;
+
+    spinner.stop();
+
+    // Per-config processing
+    for (const config of generatedSchema.configs) {
+      // configKey <-> config.id
+      const configKey = config.id;
+
+      // per-config usages
+      const scopedUsages = {
+        keys: usages.keys.filter(
+          (u) => resolveConfigKey(u.configKey, defaultConfigKey) === configKey,
+        ),
+        replacements: usages.replacements.filter(
+          (u) => resolveConfigKey(u.configKey, defaultConfigKey) === configKey,
+        ),
+        rich: usages.rich.filter(
+          (u) => resolveConfigKey(u.configKey, defaultConfigKey) === configKey,
+        ),
+      };
+
+      // Diagnostic
+      const diagnostics = collectDiagnostics(config.schemas, scopedUsages);
+      const grouped = groupDiagnostics(diagnostics);
+
+      printSummary(config.id, grouped);
+    }
+  } catch (error) {
+    spinner.stop();
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/src/features/check/index.ts

@@ -0,0 +1 @@
+export { check } from "./check";

package/src/features/check/print-summary.ts

@@ -0,0 +1,28 @@
+import type { DiagnosticGroup } from "../../core/diagnostics/types";
+import pc from "picocolors";
+
+export function printSummary(configId: string, grouped: DiagnosticGroup[]) {
+  // Log header
+  console.log(pc.dim("Config:"), pc.cyan(`${configId}\n`));
+
+  // Log no issues
+  if (grouped.length === 0) {
+    console.log(pc.dim("✔ Diagnostics completed with no issues.\n"));
+    return;
+  }
+
+  // Log problems
+  for (const group of grouped) {
+    const { method, messageKey, problems, file, lines } = group;
+
+    const header = `${messageKey} ${`(${method})`}\n`;
+
+    const problemsLine = [
+      ...problems.map((p) => pc.gray(`   - ${p}`)),
+      pc.dim(`   ➜ ${file}:${lines.join(",")}`),
+      "",
+    ].join("\n");
+
+    console.log(header + problemsLine);
+  }
+}

package/src/features/generate/generate.ts

@@ -0,0 +1,76 @@
+/* eslint-disable unicorn/no-process-exit */
+import type { ExtraExt } from "../../core";
+import { buildTypes, buildSchemas, type BuildInput } from "../../build";
+import {
+  discoverConfigs,
+  collectRuntimeMessages,
+  inferSchemas,
+  writeGeneratedFiles,
+} from "../../core";
+import { printTitle } from "../print-title";
+import { spinner } from "../spinner";
+import { printConfigs } from "./print-configs";
+import { printSummary } from "./print-summary";
+
+export interface GenerateOptions {
+  exts?: Array<ExtraExt>;
+  customReaders?: Record<string, string>;
+  debug?: boolean;
+}
+
+export async function generate({
+  exts = [],
+  customReaders,
+  debug,
+}: GenerateOptions) {
+  printTitle("Generating intor types");
+  spinner.start();
+  const start = performance.now();
+
+  try {
+    // -----------------------------------------------------------------------
+    // Discover configs from the current workspace
+    // -----------------------------------------------------------------------
+    const configEntries = await discoverConfigs(debug);
+    if (configEntries.length === 0) {
+      spinner.stop();
+      throw new Error("No Intor config found for type generation.");
+    }
+
+    // -----------------------------------------------------------------------
+    // Collect messages and infer schemas
+    // -----------------------------------------------------------------------
+    const buildInputs: BuildInput[] = [];
+
+    // Runtime mode - Per-config processing
+    for (const { config, filePath } of configEntries) {
+      const { id, supportedLocales } = config;
+      printConfigs(id, filePath);
+      const messages = await collectRuntimeMessages(
+        config,
+        config.defaultLocale,
+        exts,
+        customReaders,
+      );
+      const schemas = inferSchemas(messages[config.defaultLocale]);
+      buildInputs.push({ id, locales: supportedLocales, schemas });
+    }
+
+    // -----------------------------------------------------------------------
+    // Build artifacts and write output
+    // -----------------------------------------------------------------------
+    const types = buildTypes(buildInputs);
+    const schema = buildSchemas(buildInputs);
+
+    // Write generated files
+    const { outDir } = await writeGeneratedFiles({ types, schema });
+
+    spinner.stop();
+    const duration = performance.now() - start;
+    printSummary(outDir, duration);
+  } catch (error) {
+    spinner.stop();
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/src/features/generate/index.ts

@@ -0,0 +1 @@
+export { generate } from "./generate";

package/src/features/generate/print-configs.ts

@@ -0,0 +1,8 @@
+import pc from "picocolors";
+import { spinner } from "../spinner";
+
+export function printConfigs(id: string, filePath: string) {
+  spinner.stop();
+  console.log(pc.dim("- Config ") + pc.cyan(id) + pc.dim(` ${filePath}`));
+  spinner.start();
+}

package/src/features/generate/print-summary.ts

@@ -0,0 +1,19 @@
+import pc from "picocolors";
+
+export function printSummary(outDir: string, ms: number) {
+  const labelWidth = 18;
+  const label = (text: string) => pc.dim(text.padEnd(labelWidth));
+
+  console.log();
+  console.log(pc.green(pc.bold("✔ intor generate completed")));
+  console.log();
+  console.log(label("Output directory: ") + pc.gray(outDir));
+  console.log(label("Time elapsed: ") + pc.gray(`${(ms / 1000).toFixed(2)}s`));
+  console.log();
+  console.log(
+    pc.dim("💡 Remember to include ") +
+      pc.gray(".intor/**/*.d.ts") +
+      pc.dim(" in your tsconfig.json "),
+  );
+  console.log();
+}

package/src/features/index.ts

@@ -0,0 +1,2 @@
+export { generate } from "./generate";
+export { check } from "./check";

package/src/features/print-title.ts

@@ -0,0 +1,7 @@
+import pc from "picocolors";
+
+export function printTitle(title: string) {
+  console.log();
+  console.log(pc.bgBlack(` • ${title} `));
+  console.log();
+}

package/src/features/spinner.ts

@@ -0,0 +1,3 @@
+import ora from "ora";
+
+export const spinner = ora({ isEnabled: process.stdout.isTTY });