@rangojs/router 0.0.0-experimental.13 → 0.0.0-experimental.15

package/dist/bin/rango.js

@@ -1,22 +1,93 @@
 #!/usr/bin/env node
 
 // src/bin/rango.ts
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve2, dirname as dirname2 } from "node:path";
+import { readFileSync as readFileSync2, statSync } from "node:fs";
 
 // src/build/generate-route-types.ts
 import { readFileSync, writeFileSync, existsSync, readdirSync, unlinkSync } from "node:fs";
 import { join, dirname, resolve, relative, basename as pathBasename } from "node:path";
 import picomatch from "picomatch";
+import ts from "typescript";
+function getStringValue(node) {
+  if (ts.isStringLiteral(node)) return node.text;
+  if (ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  return null;
+}
+function extractObjectStringProperties(node) {
+  const result = {};
+  for (const prop of node.properties) {
+    if (!ts.isPropertyAssignment(prop)) continue;
+    const key = ts.isIdentifier(prop.name) ? prop.name.text : ts.isStringLiteral(prop.name) ? prop.name.text : null;
+    if (!key) continue;
+    const val = getStringValue(prop.initializer);
+    if (val !== null) result[key] = val;
+  }
+  return result;
+}
+function extractParamsFromPattern(pattern) {
+  const params = {};
+  const regex = /:([a-zA-Z_$][\w$]*)(?:\([^)]+\))?(\?)?/g;
+  let match;
+  while ((match = regex.exec(pattern)) !== null) {
+    params[match[1]] = match[2] ? "string?" : "string";
+  }
+  return Object.keys(params).length > 0 ? params : void 0;
+}
+function formatRouteEntry(key, pattern, _params, search) {
+  const hasSearch = search && Object.keys(search).length > 0;
+  if (!hasSearch) {
+    return `  ${key}: "${pattern}",`;
+  }
+  const searchBody = Object.entries(search).map(([k, v]) => `${k}: "${v}"`).join(", ");
+  return `  ${key}: { path: "${pattern}", search: { ${searchBody} } },`;
+}
 function extractRoutesFromSource(code) {
+  const sourceFile = ts.createSourceFile("input.tsx", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
   const routes = [];
-  const regex = /\bpath(?:\.[a-zA-Z_$][\w$]*)?\s*\(/g;
-  let match;
-  while ((match = regex.exec(code)) !== null) {
-    const result = parsePathCall(code, match.index + match[0].length);
-    if (result) routes.push(result);
+  function visit(node) {
+    if (ts.isCallExpression(node)) {
+      const callee = node.expression;
+      const isPath = ts.isIdentifier(callee) && callee.text === "path" || ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "path";
+      if (isPath && node.arguments.length >= 1) {
+        const route = extractRouteFromCallExpression(node);
+        if (route) routes.push(route);
+      }
+    }
+    ts.forEachChild(node, visit);
   }
+  visit(sourceFile);
   return routes;
 }
+function extractRouteFromCallExpression(node) {
+  const patternNode = node.arguments[0];
+  const pattern = getStringValue(patternNode);
+  if (pattern === null) return null;
+  let name = null;
+  let search;
+  for (let i = 1; i < node.arguments.length; i++) {
+    const arg = node.arguments[i];
+    if (ts.isObjectLiteralExpression(arg)) {
+      for (const prop of arg.properties) {
+        if (!ts.isPropertyAssignment(prop)) continue;
+        const propName = ts.isIdentifier(prop.name) ? prop.name.text : null;
+        if (propName === "name") {
+          name = getStringValue(prop.initializer);
+        } else if (propName === "search" && ts.isObjectLiteralExpression(prop.initializer)) {
+          search = extractObjectStringProperties(prop.initializer);
+        }
+      }
+    }
+  }
+  if (!name) return null;
+  const params = extractParamsFromPattern(pattern);
+  return {
+    name,
+    pattern,
+    ...params ? { params } : {},
+    ...search && Object.keys(search).length > 0 ? { search } : {}
+  };
+}
 function generatePerModuleTypesSource(routes) {
   const valid = routes.filter(({ name }) => {
     if (!name || /["'\\`\n\r]/.test(name)) {
@@ -26,17 +97,17 @@ function generatePerModuleTypesSource(routes) {
     return true;
   });
   const deduped = /* @__PURE__ */ new Map();
-  for (const { name, pattern, search } of valid) {
-    deduped.set(name, { pattern, search });
+  for (const { name, pattern, params, search } of valid) {
+    if (deduped.has(name)) {
+      console.warn(`[rsc-router] Duplicate route name "${name}" \u2014 keeping first definition`);
+      continue;
+    }
+    deduped.set(name, { pattern, params, search });
   }
   const sorted = [...deduped.entries()].sort(([a], [b]) => a.localeCompare(b));
-  const body = sorted.map(([name, { pattern, search }]) => {
+  const body = sorted.map(([name, { pattern, params, search }]) => {
     const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
-    if (search && Object.keys(search).length > 0) {
-      const searchBody = Object.entries(search).map(([k, v]) => `${k}: "${v}"`).join(", ");
-      return `  ${key}: { path: "${pattern}", search: { ${searchBody} } },`;
-    }
-    return `  ${key}: "${pattern}",`;
+    return formatRouteEntry(key, pattern, params, search);
   }).join("\n");
   return `// Auto-generated by @rangojs/router - do not edit
 export const routes = {
@@ -45,187 +116,27 @@ ${body}
 export type routes = typeof routes;
 `;
 }
-function isWhitespace(ch) {
-  return ch === " " || ch === "	" || ch === "\n" || ch === "\r";
-}
-function readString(code, pos) {
-  const quote = code[pos];
-  if (quote !== '"' && quote !== "'") return null;
-  let value = "";
-  pos++;
-  while (pos < code.length) {
-    if (code[pos] === "\\") {
-      pos++;
-      if (pos < code.length) {
-        value += code[pos];
-        pos++;
-      }
-      continue;
-    }
-    if (code[pos] === quote) {
-      return { value, end: pos + 1 };
-    }
-    value += code[pos];
-    pos++;
-  }
-  return null;
-}
-function skipStringLiteral(code, pos) {
-  const quote = code[pos];
-  if (quote === "`") {
-    pos++;
-    while (pos < code.length) {
-      if (code[pos] === "\\") {
-        pos += 2;
-        continue;
-      }
-      if (code[pos] === "`") return pos + 1;
-      if (code[pos] === "$" && pos + 1 < code.length && code[pos + 1] === "{") {
-        pos += 2;
-        let braceDepth = 1;
-        while (pos < code.length && braceDepth > 0) {
-          if (code[pos] === "{") braceDepth++;
-          else if (code[pos] === "}") braceDepth--;
-          else if (code[pos] === "\\") pos++;
-          else if (code[pos] === '"' || code[pos] === "'" || code[pos] === "`") {
-            pos = skipStringLiteral(code, pos);
-            continue;
-          }
-          if (braceDepth > 0) pos++;
-        }
-        continue;
-      }
-      pos++;
-    }
-    return pos;
-  }
-  pos++;
-  while (pos < code.length) {
-    if (code[pos] === "\\") {
-      pos += 2;
-      continue;
-    }
-    if (code[pos] === quote) return pos + 1;
-    pos++;
-  }
-  return pos;
-}
-function matchesNameColon(code, pos) {
-  if (code.slice(pos, pos + 4) !== "name") return false;
-  if (pos > 0 && /\w/.test(code[pos - 1])) return false;
-  const afterName = pos + 4;
-  if (afterName < code.length && /\w/.test(code[afterName])) return false;
-  let checkPos = afterName;
-  while (checkPos < code.length && isWhitespace(code[checkPos])) checkPos++;
-  return code[checkPos] === ":";
-}
-function extractNameValue(code, pos) {
-  pos += 4;
-  while (pos < code.length && isWhitespace(code[pos])) pos++;
-  pos++;
-  while (pos < code.length && isWhitespace(code[pos])) pos++;
-  return readString(code, pos);
-}
-function matchesSearchColon(code, pos) {
-  if (code.slice(pos, pos + 6) !== "search") return false;
-  if (pos > 0 && /\w/.test(code[pos - 1])) return false;
-  const afterSearch = pos + 6;
-  if (afterSearch < code.length && /\w/.test(code[afterSearch])) return false;
-  let checkPos = afterSearch;
-  while (checkPos < code.length && isWhitespace(code[checkPos])) checkPos++;
-  return code[checkPos] === ":";
-}
-function extractSearchValue(code, pos) {
-  pos += 6;
-  while (pos < code.length && isWhitespace(code[pos])) pos++;
-  pos++;
-  while (pos < code.length && isWhitespace(code[pos])) pos++;
-  if (code[pos] !== "{") return null;
-  pos++;
-  const schema = {};
-  while (pos < code.length) {
-    while (pos < code.length && isWhitespace(code[pos])) pos++;
-    if (code[pos] === "}") return { value: schema, end: pos + 1 };
-    if (code[pos] === ",") {
-      pos++;
-      continue;
-    }
-    let key;
-    if (code[pos] === '"' || code[pos] === "'") {
-      const keyStr = readString(code, pos);
-      if (!keyStr) return null;
-      key = keyStr.value;
-      pos = keyStr.end;
-    } else {
-      const keyStart = pos;
-      while (pos < code.length && /[\w$]/.test(code[pos])) pos++;
-      if (pos === keyStart) return null;
-      key = code.slice(keyStart, pos);
-    }
-    while (pos < code.length && isWhitespace(code[pos])) pos++;
-    if (code[pos] !== ":") return null;
-    pos++;
-    while (pos < code.length && isWhitespace(code[pos])) pos++;
-    const valStr = readString(code, pos);
-    if (!valStr) return null;
-    schema[key] = valStr.value;
-    pos = valStr.end;
+function generateRouteTypesSource(routeManifest, searchSchemas) {
+  const entries = Object.entries(routeManifest).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const objectBody = entries.map(([name, pattern]) => {
+    const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
+    const params = extractParamsFromPattern(pattern);
+    const search = searchSchemas?.[name];
+    return formatRouteEntry(key, pattern, params, search);
+  }).join("\n");
+  return `// Auto-generated by @rangojs/router - do not edit
+export const NamedRoutes = {
+${objectBody}
+} as const;
+
+declare global {
+  namespace RSCRouter {
+    interface GeneratedRouteMap extends Readonly<typeof NamedRoutes> {}
   }
-  return null;
 }
-function parsePathCall(code, pos) {
-  while (pos < code.length && isWhitespace(code[pos])) pos++;
-  const patternStr = readString(code, pos);
-  if (!patternStr) return null;
-  const pattern = patternStr.value;
-  pos = patternStr.end;
-  let depth = 1;
-  let name = null;
-  let search;
-  while (pos < code.length && depth > 0) {
-    const ch = code[pos];
-    if (isWhitespace(ch)) {
-      pos++;
-      continue;
-    }
-    if (ch === "/" && pos + 1 < code.length && code[pos + 1] === "/") {
-      pos += 2;
-      while (pos < code.length && code[pos] !== "\n") pos++;
-      continue;
-    }
-    if (ch === "/" && pos + 1 < code.length && code[pos + 1] === "*") {
-      pos += 2;
-      while (pos < code.length - 1 && !(code[pos] === "*" && code[pos + 1] === "/"))
-        pos++;
-      pos += 2;
-      continue;
-    }
-    if (depth === 2 && ch === "n" && matchesNameColon(code, pos)) {
-      const nameResult = extractNameValue(code, pos);
-      if (nameResult) {
-        name = nameResult.value;
-        pos = nameResult.end;
-        continue;
-      }
-    }
-    if (depth === 2 && ch === "s" && matchesSearchColon(code, pos)) {
-      const searchResult = extractSearchValue(code, pos);
-      if (searchResult) {
-        search = searchResult.value;
-        pos = searchResult.end;
-        continue;
-      }
-    }
-    if (ch === '"' || ch === "`" || ch === "'" && (pos === 0 || !/\w/.test(code[pos - 1]))) {
-      pos = skipStringLiteral(code, pos);
-      continue;
-    }
-    if (ch === "(" || ch === "{" || ch === "[") depth++;
-    else if (ch === ")" || ch === "}" || ch === "]") depth--;
-    pos++;
-  }
-  if (name === null) return null;
-  return { name, pattern, ...search ? { search } : {} };
+`;
 }
 function findTsFiles(dir, filter) {
   const results = [];
@@ -248,11 +159,44 @@ function findTsFiles(dir, filter) {
   }
   return results;
 }
+function findUrlsVariableNames(code) {
+  const sourceFile = ts.createSourceFile("input.tsx", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+  const names = [];
+  function visit(node) {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isCallExpression(node.initializer)) {
+      const callee = node.initializer.expression;
+      if (ts.isIdentifier(callee) && callee.text === "urls") {
+        names.push(node.name.text);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return names;
+}
 function writePerModuleRouteTypesForFile(filePath) {
   try {
     const source = readFileSync(filePath, "utf-8");
     if (!source.includes("urls(")) return;
-    const routes = extractRoutesFromSource(source);
+    const varNames = findUrlsVariableNames(source);
+    let routes;
+    if (varNames.length > 0) {
+      routes = [];
+      for (const varName of varNames) {
+        const { routes: routeMap, searchSchemas } = buildCombinedRouteMapWithSearch(filePath, varName);
+        for (const [name, pattern] of Object.entries(routeMap)) {
+          const params = extractParamsFromPattern(pattern);
+          routes.push({
+            name,
+            pattern,
+            ...params ? { params } : {},
+            ...searchSchemas[name] ? { search: searchSchemas[name] } : {}
+          });
+        }
+      }
+    } else {
+      routes = extractRoutesFromSource(source);
+    }
     if (routes.length === 0) return;
     const genPath = filePath.replace(/\.(tsx?)$/, ".gen.ts");
     const genSource = generatePerModuleTypesSource(routes);
@@ -265,23 +209,300 @@ function writePerModuleRouteTypesForFile(filePath) {
     console.warn(`[rsc-router] Failed to generate route types for ${filePath}: ${err.message}`);
   }
 }
+function extractIncludesFromSource(code) {
+  const sourceFile = ts.createSourceFile("input.tsx", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+  const results = [];
+  function visit(node) {
+    if (ts.isCallExpression(node)) {
+      const callee = node.expression;
+      if (ts.isIdentifier(callee) && callee.text === "include") {
+        const result = extractIncludeFromCallExpression(node);
+        if (result) results.push(result);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return results;
+}
+function extractIncludeFromCallExpression(node) {
+  if (node.arguments.length < 2) return null;
+  const pathPrefix = getStringValue(node.arguments[0]);
+  if (pathPrefix === null) return null;
+  const secondArg = node.arguments[1];
+  if (!ts.isIdentifier(secondArg)) return null;
+  const variableName = secondArg.text;
+  let namePrefix = null;
+  if (node.arguments.length >= 3) {
+    const thirdArg = node.arguments[2];
+    if (ts.isObjectLiteralExpression(thirdArg)) {
+      for (const prop of thirdArg.properties) {
+        if (!ts.isPropertyAssignment(prop)) continue;
+        const propName = ts.isIdentifier(prop.name) ? prop.name.text : null;
+        if (propName === "name") {
+          namePrefix = getStringValue(prop.initializer);
+        }
+      }
+    }
+  }
+  return { pathPrefix, variableName, namePrefix };
+}
+function resolveImportedVariable(code, localName) {
+  const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
+  let match;
+  while ((match = importRegex.exec(code)) !== null) {
+    const imports = match[1];
+    const specifier = match[2];
+    const parts = imports.split(",").map((s) => s.trim()).filter(Boolean);
+    for (const part of parts) {
+      const asMatch = part.match(/^(\w+)\s+as\s+(\w+)$/);
+      if (asMatch && asMatch[2] === localName)
+        return { specifier, exportedName: asMatch[1] };
+      if (part === localName) return { specifier, exportedName: localName };
+    }
+  }
+  return null;
+}
+function resolveImportPath(importSpec, fromFile) {
+  if (!importSpec.startsWith(".")) return null;
+  const dir = dirname(fromFile);
+  let base = importSpec;
+  if (base.endsWith(".js")) base = base.slice(0, -3);
+  else if (base.endsWith(".mjs")) base = base.slice(0, -4);
+  const candidates = [
+    resolve(dir, base + ".ts"),
+    resolve(dir, base + ".tsx"),
+    resolve(dir, base + "/index.ts"),
+    resolve(dir, base + "/index.tsx")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function extractUrlsBlockForVariable(code, varName) {
+  const sourceFile = ts.createSourceFile("input.tsx", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === varName && node.initializer && ts.isCallExpression(node.initializer)) {
+      const callee = node.initializer.expression;
+      if (ts.isIdentifier(callee) && callee.text === "urls") {
+        result = node.initializer.getText(sourceFile);
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSchemasOut) {
+  const routeMap = {};
+  const localRoutes = extractRoutesFromSource(block);
+  for (const { name, pattern, search } of localRoutes) {
+    routeMap[name] = pattern;
+    if (search && searchSchemasOut) {
+      searchSchemasOut[name] = search;
+    }
+  }
+  const includes = extractIncludesFromSource(block);
+  for (const { pathPrefix, variableName, namePrefix } of includes) {
+    let childResult;
+    const imported = resolveImportedVariable(fullSource, variableName);
+    if (imported) {
+      const targetFile = resolveImportPath(imported.specifier, filePath);
+      if (!targetFile) continue;
+      childResult = buildCombinedRouteMapWithSearch(
+        targetFile,
+        imported.exportedName,
+        visited
+      );
+    } else {
+      childResult = buildCombinedRouteMapWithSearch(filePath, variableName, visited);
+    }
+    for (const [name, pattern] of Object.entries(childResult.routes)) {
+      const prefixedName = namePrefix ? `${namePrefix}.${name}` : name;
+      let prefixedPattern;
+      if (pattern === "/") {
+        prefixedPattern = pathPrefix || "/";
+      } else if (pathPrefix.endsWith("/") && pattern.startsWith("/")) {
+        prefixedPattern = pathPrefix + pattern.slice(1);
+      } else {
+        prefixedPattern = pathPrefix + pattern;
+      }
+      routeMap[prefixedName] = prefixedPattern;
+      if (childResult.searchSchemas[name] && searchSchemasOut) {
+        searchSchemasOut[prefixedName] = childResult.searchSchemas[name];
+      }
+    }
+  }
+  return routeMap;
+}
+function buildCombinedRouteMapWithSearch(filePath, variableName, visited) {
+  visited = visited ?? /* @__PURE__ */ new Set();
+  const realPath = resolve(filePath);
+  const key = variableName ? `${realPath}:${variableName}` : realPath;
+  if (visited.has(key)) {
+    console.warn(`[rsc-router] Circular include detected, skipping: ${key}`);
+    return { routes: {}, searchSchemas: {} };
+  }
+  visited.add(key);
+  let source;
+  try {
+    source = readFileSync(realPath, "utf-8");
+  } catch {
+    return { routes: {}, searchSchemas: {} };
+  }
+  let block;
+  if (variableName) {
+    const extracted = extractUrlsBlockForVariable(source, variableName);
+    if (!extracted) return { routes: {}, searchSchemas: {} };
+    block = extracted;
+  } else {
+    block = source;
+  }
+  const searchSchemas = {};
+  const routes = buildRouteMapFromBlock(block, source, realPath, visited, searchSchemas);
+  return { routes, searchSchemas };
+}
+function extractUrlsVariableFromRouter(code) {
+  const routesCallMatch = code.match(/\.routes\s*\(\s*([a-zA-Z_$][\w$]*)\s*\)/);
+  if (routesCallMatch) return routesCallMatch[1];
+  const urlsOptionMatch = code.match(/urls\s*:\s*([a-zA-Z_$][\w$]*)/);
+  if (urlsOptionMatch) return urlsOptionMatch[1];
+  return null;
+}
+function findRouterFiles(root, filter) {
+  const files = findTsFiles(root, filter);
+  const result = [];
+  for (const filePath of files) {
+    if (filePath.includes(".gen.")) continue;
+    try {
+      const source = readFileSync(filePath, "utf-8");
+      if (/\bcreateRouter\s*[<(]/.test(source)) {
+        result.push(filePath);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return result;
+}
+function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
+  try {
+    const oldCombinedPath = join(root, "src", "named-routes.gen.ts");
+    if (existsSync(oldCombinedPath)) {
+      unlinkSync(oldCombinedPath);
+      console.log(`[rsc-router] Removed stale combined route types: ${oldCombinedPath}`);
+    }
+  } catch {
+  }
+  const routerFilePaths = knownRouterFiles ?? findRouterFiles(root);
+  if (routerFilePaths.length === 0) return;
+  for (const routerFilePath of routerFilePaths) {
+    let routerSource;
+    try {
+      routerSource = readFileSync(routerFilePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const urlsVarName = extractUrlsVariableFromRouter(routerSource);
+    if (!urlsVarName) continue;
+    let result;
+    const imported = resolveImportedVariable(routerSource, urlsVarName);
+    if (imported) {
+      const targetFile = resolveImportPath(imported.specifier, routerFilePath);
+      if (!targetFile) continue;
+      result = buildCombinedRouteMapWithSearch(targetFile, imported.exportedName);
+    } else {
+      result = buildCombinedRouteMapWithSearch(routerFilePath, urlsVarName);
+    }
+    const routerBasename = pathBasename(routerFilePath).replace(/\.(tsx?|jsx?)$/, "");
+    const outPath = join(dirname(routerFilePath), `${routerBasename}.named-routes.gen.ts`);
+    const existing = existsSync(outPath) ? readFileSync(outPath, "utf-8") : null;
+    if (Object.keys(result.routes).length === 0) {
+      if (!existing) {
+        const emptySource = generateRouteTypesSource({});
+        writeFileSync(outPath, emptySource);
+      }
+      continue;
+    }
+    const hasSearchSchemas = Object.keys(result.searchSchemas).length > 0;
+    const source = generateRouteTypesSource(
+      result.routes,
+      hasSearchSchemas ? result.searchSchemas : void 0
+    );
+    if (existing !== source) {
+      if (opts?.preserveIfLarger && existing) {
+        const existingCount = (existing.match(/^\s+["a-zA-Z_$][^:]*:\s*["{]/gm) || []).length;
+        const newCount = Object.keys(result.routes).length;
+        if (existingCount > newCount) {
+          continue;
+        }
+      }
+      writeFileSync(outPath, source);
+      console.log(`[rsc-router] Generated route types (${Object.keys(result.routes).length} routes) -> ${outPath}`);
+    }
+  }
+}
 
 // src/bin/rango.ts
 var [command, ...args] = process.argv.slice(2);
-if (command === "extract-names") {
-  const dir = args[0] ?? "./src";
-  const resolvedDir = resolve2(dir);
-  console.log(`[rango] Scanning ${resolvedDir} for url modules...`);
-  const files = findTsFiles(resolvedDir);
+if (command === "generate") {
+  if (args.length === 0) {
+    console.error("[rango] Usage: rango generate <file|dir> [file2 ...]");
+    process.exit(1);
+  }
+  const files = [];
+  for (const arg of args) {
+    const resolved = resolve2(arg);
+    try {
+      if (statSync(resolved).isDirectory()) {
+        files.push(...findTsFiles(resolved));
+      } else {
+        files.push(resolved);
+      }
+    } catch {
+      console.warn(`[rango] Skipping ${arg}: not found`);
+    }
+  }
+  if (files.length === 0) {
+    console.log("[rango] No files to process");
+    process.exit(0);
+  }
+  const routerFiles = [];
   for (const filePath of files) {
-    writePerModuleRouteTypesForFile(filePath);
+    try {
+      const source = readFileSync2(filePath, "utf-8");
+      const isRouter = /\bcreateRouter\s*[<(]/.test(source);
+      const isUrls = source.includes("urls(");
+      if (isRouter) {
+        routerFiles.push(filePath);
+      }
+      if (isUrls) {
+        writePerModuleRouteTypesForFile(filePath);
+      }
+    } catch (err) {
+      console.warn(`[rango] Failed to process ${filePath}: ${err.message}`);
+    }
+  }
+  for (const routerFile of routerFiles) {
+    writeCombinedRouteTypes(dirname2(routerFile), [routerFile]);
   }
-  console.log(`[rango] Scanned ${files.length} file(s)`);
+  console.log(`[rango] Processed ${files.length} file(s)${routerFiles.length ? ` (${routerFiles.length} router)` : ""}`);
   process.exit(0);
 } else {
-  console.log(`Usage: rango <command>
+  console.log(`Usage: rango generate <file|dir> [file2 ...]
+
+  Auto-detects file type (createRouter, urls) and generates
+  the appropriate .gen.ts route type files.
+
+  Pass files, directories, or a mix of both.
 
-Commands:
-  extract-names [dir]  Extract route names from url modules (default: ./src)`);
+Examples:
+  rango generate src/urls.tsx
+  rango generate src/router.tsx src/urls.tsx
+  rango generate src/`);
   process.exit(command ? 1 : 0);
 }