refactor: type discovery core (#219)

Author: jackwener

src/build-manifest.ts

@@ -18,7 +18,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CLIS_DIR = path.resolve(__dirname, 'clis');
 const OUTPUT = path.resolve(__dirname, '..', 'dist', 'cli-manifest.json');
 
-interface ManifestEntry {
+export interface ManifestEntry {
   site: string;
   name: string;
   description: string;
@@ -28,14 +28,14 @@ interface ManifestEntry {
   args: Array<{
     name: string;
     type?: string;
-    default?: any;
+    default?: unknown;
     required?: boolean;
     positional?: boolean;
     help?: string;
     choices?: string[];
   }>;
   columns?: string[];
-  pipeline?: any[];
+  pipeline?: Record<string, unknown>[];
   timeout?: number;
   /** 'yaml' or 'ts' — determines how executeCommand loads the handler */
   type: 'yaml' | 'ts';
@@ -45,6 +45,38 @@ interface ManifestEntry {
   navigateBefore?: boolean | string;
 }
 
+interface YamlArgDefinition {
+  type?: string;
+  default?: unknown;
+  required?: boolean;
+  positional?: boolean;
+  description?: string;
+  help?: string;
+  choices?: string[];
+}
+
+interface YamlCliDefinition {
+  site?: string;
+  name?: string;
+  description?: string;
+  domain?: string;
+  strategy?: string;
+  browser?: boolean;
+  args?: Record<string, YamlArgDefinition>;
+  columns?: string[];
+  pipeline?: Record<string, unknown>[];
+  timeout?: number;
+  navigateBefore?: boolean | string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 function extractBalancedBlock(
   source: string,
   startIndex: number,
@@ -129,7 +161,7 @@ export function parseTsArgsBlock(argsBlock: string): ManifestEntry['args'] {
     const helpMatch = body.match(/help\s*:\s*['"`]([^'"`]*)['"`]/);
     const positionalMatch = body.match(/positional\s*:\s*(true|false)/);
 
-    let defaultVal: any = undefined;
+    let defaultVal: unknown = undefined;
     if (defaultMatch) {
       const raw = defaultMatch[1].trim();
       if (raw === 'true') defaultVal = true;
@@ -158,16 +190,17 @@ export function parseTsArgsBlock(argsBlock: string): ManifestEntry['args'] {
 function scanYaml(filePath: string, site: string): ManifestEntry | null {
   try {
     const raw = fs.readFileSync(filePath, 'utf-8');
-    const def = yaml.load(raw) as any;
-    if (!def || typeof def !== 'object') return null;
+    const def = yaml.load(raw) as YamlCliDefinition | null;
+    if (!isRecord(def)) return null;
+    const cliDef = def as YamlCliDefinition;
 
-    const strategyStr = def.strategy ?? (def.browser === false ? 'public' : 'cookie');
+    const strategyStr = cliDef.strategy ?? (cliDef.browser === false ? 'public' : 'cookie');
     const strategy = strategyStr.toUpperCase();
-    const browser = def.browser ?? (strategy !== 'PUBLIC');
+    const browser = cliDef.browser ?? (strategy !== 'PUBLIC');
 
     const args: ManifestEntry['args'] = [];
-    if (def.args && typeof def.args === 'object') {
-      for (const [argName, argDef] of Object.entries(def.args as Record<string, any>)) {
+    if (cliDef.args && typeof cliDef.args === 'object') {
+      for (const [argName, argDef] of Object.entries(cliDef.args)) {
         args.push({
           name: argName,
           type: argDef?.type ?? 'str',
@@ -180,21 +213,21 @@ function scanYaml(filePath: string, site: string): ManifestEntry | null {
     }
 
     return {
-      site: def.site ?? site,
-      name: def.name ?? path.basename(filePath, path.extname(filePath)),
-      description: def.description ?? '',
-      domain: def.domain,
+      site: cliDef.site ?? site,
+      name: cliDef.name ?? path.basename(filePath, path.extname(filePath)),
+      description: cliDef.description ?? '',
+      domain: cliDef.domain,
       strategy: strategy.toLowerCase(),
       browser,
       args,
-      columns: def.columns,
-      pipeline: def.pipeline,
-      timeout: def.timeout,
+      columns: cliDef.columns,
+      pipeline: cliDef.pipeline,
+      timeout: cliDef.timeout,
       type: 'yaml',
-      navigateBefore: def.navigateBefore,
+      navigateBefore: cliDef.navigateBefore,
     };
-  } catch (err: any) {
-    process.stderr.write(`Warning: failed to parse ${filePath}: ${err.message}\n`);
+  } catch (err) {
+    process.stderr.write(`Warning: failed to parse ${filePath}: ${getErrorMessage(err)}\n`);
     return null;
   }
 }
@@ -256,9 +289,9 @@ export function scanTs(filePath: string, site: string): ManifestEntry | null {
     if (navMatch) entry.navigateBefore = navMatch[1] === 'true' ? true : false;
 
     return entry;
-  } catch (err: any) {
+  } catch (err) {
     // If parsing fails, log a warning (matching scanYaml behaviour) and skip the entry.
-    process.stderr.write(`Warning: failed to scan ${filePath}: ${err.message}\n`);
+    process.stderr.write(`Warning: failed to scan ${filePath}: ${getErrorMessage(err)}\n`);
     return null;
   }
 }

src/commanderAdapter.ts

@@ -18,6 +18,10 @@ import { render as renderOutput } from './output.js';
 import { executeCommand } from './execution.js';
 import { CliError } from './errors.js';
 
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 /**
  * Register a single CliCommand as a Commander subcommand.
  */
@@ -46,49 +50,52 @@ export function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): voi
 
   subCmd.addHelpText('after', formatRegistryHelpText(cmd));
 
-  subCmd.action(async (...actionArgs: any[]) => {
+  subCmd.action(async (...actionArgs: unknown[]) => {
     const actionOpts = actionArgs[positionalArgs.length] ?? {};
+    const optionsRecord = typeof actionOpts === 'object' && actionOpts !== null ? actionOpts as Record<string, unknown> : {};
     const startTime = Date.now();
 
     // ── Collect kwargs ──────────────────────────────────────────────────
-    const kwargs: Record<string, any> = {};
+    const kwargs: Record<string, unknown> = {};
     for (let i = 0; i < positionalArgs.length; i++) {
       const v = actionArgs[i];
       if (v !== undefined) kwargs[positionalArgs[i].name] = v;
     }
     for (const arg of cmd.args) {
       if (arg.positional) continue;
       const camelName = arg.name.replace(/-([a-z])/g, (_m, ch: string) => ch.toUpperCase());
-      const v = actionOpts[arg.name] ?? actionOpts[camelName];
+      const v = optionsRecord[arg.name] ?? optionsRecord[camelName];
       if (v !== undefined) kwargs[arg.name] = v;
     }
 
     // ── Execute + render ────────────────────────────────────────────────
     try {
-      if (actionOpts.verbose) process.env.OPENCLI_VERBOSE = '1';
+      const verbose = optionsRecord.verbose === true;
+      const format = typeof optionsRecord.format === 'string' ? optionsRecord.format : 'table';
+      if (verbose) process.env.OPENCLI_VERBOSE = '1';
 
-      const result = await executeCommand(cmd, kwargs, actionOpts.verbose);
+      const result = await executeCommand(cmd, kwargs, verbose);
 
-      if (actionOpts.verbose && (!result || (Array.isArray(result) && result.length === 0))) {
+      if (verbose && (!result || (Array.isArray(result) && result.length === 0))) {
         console.error(chalk.yellow('[Verbose] Warning: Command returned an empty result.'));
       }
       const resolved = getRegistry().get(fullName(cmd)) ?? cmd;
       renderOutput(result, {
-        fmt: actionOpts.format,
+        fmt: format,
         columns: resolved.columns,
         title: `${resolved.site}/${resolved.name}`,
         elapsed: (Date.now() - startTime) / 1000,
         source: fullName(resolved),
         footerExtra: resolved.footerExtra?.(kwargs),
       });
-    } catch (err: any) {
+    } catch (err) {
       if (err instanceof CliError) {
         console.error(chalk.red(`Error [${err.code}]: ${err.message}`));
         if (err.hint) console.error(chalk.yellow(`Hint: ${err.hint}`));
-      } else if (actionOpts.verbose && err.stack) {
+      } else if (optionsRecord.verbose === true && err instanceof Error && err.stack) {
         console.error(chalk.red(err.stack));
       } else {
-        console.error(chalk.red(`Error: ${err.message ?? err}`));
+        console.error(chalk.red(`Error: ${getErrorMessage(err)}`));
       }
       process.exitCode = 1;
     }