@typokit/cli 0.1.4

package/src/index.test.ts

@@ -0,0 +1,217 @@
+// @typokit/cli — Build Command Tests
+
+import { describe, it, expect } from "@rstest/core";
+import { parseArgs, createLogger, loadConfig } from "./index.js";
+import type { BuildError } from "./commands/build.js";
+import type { TypoKitConfig } from "./config.js";
+
+// ─── parseArgs ───────────────────────────────────────────────
+
+describe("parseArgs", () => {
+  it("extracts command from argv", () => {
+    const result = parseArgs(["node", "typokit", "build"]);
+    expect(result.command).toBe("build");
+    expect(Object.keys(result.flags).length).toBe(0);
+  });
+
+  it("extracts --verbose flag", () => {
+    const result = parseArgs(["node", "typokit", "build", "--verbose"]);
+    expect(result.command).toBe("build");
+    expect(result.flags["verbose"]).toBe(true);
+  });
+
+  it("extracts -v short flag", () => {
+    const result = parseArgs(["node", "typokit", "build", "-v"]);
+    expect(result.flags["v"]).toBe(true);
+  });
+
+  it("extracts --root with value", () => {
+    const result = parseArgs(["node", "typokit", "build", "--root", "/my/dir"]);
+    expect(result.flags["root"]).toBe("/my/dir");
+  });
+
+  it("returns empty command for no args", () => {
+    const result = parseArgs(["node", "typokit"]);
+    expect(result.command).toBe("");
+  });
+
+  it("collects positional args after command", () => {
+    const result = parseArgs(["node", "typokit", "build", "extra1", "extra2"]);
+    expect(result.positional).toEqual(["extra1", "extra2"]);
+  });
+});
+
+// ─── createLogger ────────────────────────────────────────────
+
+describe("createLogger", () => {
+  it("creates a logger with all methods", () => {
+    const logger = createLogger({ verbose: false });
+    expect(typeof logger.info).toBe("function");
+    expect(typeof logger.success).toBe("function");
+    expect(typeof logger.warn).toBe("function");
+    expect(typeof logger.error).toBe("function");
+    expect(typeof logger.verbose).toBe("function");
+    expect(typeof logger.step).toBe("function");
+  });
+
+  it("verbose logger does not throw when verbose is false", () => {
+    const logger = createLogger({ verbose: false });
+    // Should not throw
+    logger.verbose("test message");
+    logger.info("test info");
+  });
+
+  it("verbose logger does not throw when verbose is true", () => {
+    const logger = createLogger({ verbose: true });
+    logger.verbose("test message");
+  });
+});
+
+// ─── loadConfig ──────────────────────────────────────────────
+
+describe("loadConfig", () => {
+  it("returns default config for nonexistent directory", async () => {
+    const config = await loadConfig("/nonexistent/path/that/does/not/exist");
+    expect(config.compiler).toBe("tsc");
+    expect(config.outputDir).toBe(".typokit");
+    expect(config.distDir).toBe("dist");
+    expect(Array.isArray(config.typeFiles)).toBe(true);
+    expect(Array.isArray(config.routeFiles)).toBe(true);
+  });
+
+  it("returns default config when no typokit field in package.json", async () => {
+    // The monorepo root doesn't have a typokit field
+    const config = await loadConfig(".");
+    expect(config.compiler).toBe("tsc");
+  });
+});
+
+// ─── Build Error Types ──────────────────────────────────────
+
+describe("BuildError", () => {
+  it("BuildError interface has expected shape", () => {
+    const err: BuildError = {
+      source: "tsc",
+      phase: "compile",
+      message: "Cannot find module",
+      file: "src/app.ts",
+      line: 42,
+      errorType: "TS2307",
+    };
+    expect(err.source).toBe("tsc");
+    expect(err.phase).toBe("compile");
+    expect(err.message).toBe("Cannot find module");
+    expect(err.file).toBe("src/app.ts");
+    expect(err.line).toBe(42);
+    expect(err.errorType).toBe("TS2307");
+  });
+
+  it("BuildError works without optional fields", () => {
+    const err: BuildError = {
+      source: "transform",
+      phase: "transform",
+      message: "Parse error",
+    };
+    expect(err.file).toBeUndefined();
+    expect(err.line).toBeUndefined();
+  });
+});
+
+// ─── Config Types ────────────────────────────────────────────
+
+describe("TypoKitConfig", () => {
+  it("accepts partial config", () => {
+    const config: TypoKitConfig = {
+      compiler: "tsup",
+      outputDir: ".custom",
+    };
+    expect(config.compiler).toBe("tsup");
+    expect(config.outputDir).toBe(".custom");
+  });
+
+  it("accepts all compiler options", () => {
+    const configs: TypoKitConfig[] = [
+      { compiler: "tsc" },
+      { compiler: "tsup" },
+      { compiler: "swc" },
+    ];
+    expect(configs.length).toBe(3);
+  });
+});
+
+// ─── Integration: Build with mock project ────────────────────
+
+describe("executeBuild integration", () => {
+  it("succeeds with no source files (empty project)", async () => {
+    const { executeBuild } = await import("./commands/build.js");
+
+    const logger = createLogger({ verbose: false });
+    const result = await executeBuild({
+      rootDir: "/nonexistent/empty/project",
+      config: {
+        typeFiles: [],
+        routeFiles: [],
+        outputDir: ".typokit",
+        distDir: "dist",
+        compiler: "tsc",
+        compilerArgs: ["--noEmit"],
+      },
+      logger,
+      verbose: false,
+    });
+
+    // Will fail at compile step since /nonexistent doesn't exist
+    // but it should handle the error gracefully without throwing
+    expect(typeof result.success).toBe("boolean");
+    expect(typeof result.duration).toBe("number");
+    expect(Array.isArray(result.errors)).toBe(true);
+    expect(Array.isArray(result.outputs)).toBe(true);
+  });
+
+  it("reports structured errors on compiler failure", async () => {
+    const { executeBuild } = await import("./commands/build.js");
+    const logger = createLogger({ verbose: false });
+
+    const result = await executeBuild({
+      rootDir: "/nonexistent/path",
+      config: {
+        typeFiles: [],
+        routeFiles: [],
+        outputDir: ".typokit",
+        distDir: "dist",
+        compiler: "tsc",
+        compilerArgs: ["--noEmit", "--project", "nonexistent.json"],
+      },
+      logger,
+      verbose: false,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.duration).toBeGreaterThan(0);
+  });
+
+  it("returns BuildResult shape on failure", async () => {
+    const { executeBuild } = await import("./commands/build.js");
+    const logger = createLogger({ verbose: true });
+
+    const result = await executeBuild({
+      rootDir: "/nonexistent",
+      config: {
+        typeFiles: ["src/**/*.types.ts"],
+        routeFiles: [],
+        outputDir: ".typokit",
+        distDir: "dist",
+        compiler: "tsc",
+        compilerArgs: ["--noEmit"],
+      },
+      logger,
+      verbose: true,
+    });
+
+    expect(typeof result.success).toBe("boolean");
+    expect(typeof result.duration).toBe("number");
+    expect(Array.isArray(result.outputs)).toBe(true);
+    expect(Array.isArray(result.errors)).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,397 @@
+// @typokit/cli — Main entry point
+
+export { createLogger } from "./logger.js";
+export type { CliLogger } from "./logger.js";
+export { loadConfig } from "./config.js";
+export type { TypoKitConfig } from "./config.js";
+export { executeBuild } from "./commands/build.js";
+export type { BuildCommandOptions, BuildError } from "./commands/build.js";
+export {
+  executeDev,
+  createDevState,
+  detectChangedFiles,
+  updateTrackedFiles,
+  buildDepGraph,
+  getAffectedOutputs,
+  isCacheValid,
+  updateCache,
+} from "./commands/dev.js";
+export type { DevCommandOptions, DevServerState } from "./commands/dev.js";
+export {
+  executeInspect,
+  inspectRoutes,
+  inspectRoute,
+  inspectMiddleware,
+  inspectDependencies,
+  inspectSchema,
+  inspectErrors,
+  inspectPerformance,
+  inspectServer,
+  inspectBuildPipeline,
+} from "./commands/inspect.js";
+export type { InspectOptions, InspectResult } from "./commands/inspect.js";
+export {
+  executeGenerate,
+  generateDb,
+  generateClient,
+  generateOpenapi,
+  generateTests,
+  generateClientCode,
+} from "./commands/generate.js";
+export type {
+  GenerateCommandOptions,
+  GenerateResult,
+} from "./commands/generate.js";
+export {
+  executeMigrate,
+  migrateGenerate,
+  migrateDiff,
+  migrateApply,
+} from "./commands/migrate.js";
+export type {
+  MigrateCommandOptions,
+  MigrateResult,
+} from "./commands/migrate.js";
+export {
+  executeScaffold,
+  scaffoldInit,
+  scaffoldRoute,
+  scaffoldService,
+  generateRouteContracts,
+  generateRouteHandlers,
+  generateRouteMiddleware,
+  generateService,
+  generatePackageJson,
+  generateTsconfig,
+  generateAppTs,
+  generateTypesTs,
+  toPascalCase,
+  toCamelCase,
+} from "./commands/scaffold.js";
+export type {
+  ScaffoldCommandOptions,
+  ScaffoldResult,
+  InitOptions,
+} from "./commands/scaffold.js";
+export {
+  executeTest,
+  detectTestRunner,
+  buildRunnerCommand,
+  schemasChanged,
+} from "./commands/test.js";
+export type {
+  TestCommandOptions,
+  TestResult,
+  TestRunner,
+} from "./commands/test.js";
+
+/** Parse CLI arguments into a structured object */
+export function parseArgs(argv: string[]): {
+  command: string;
+  flags: Record<string, string | boolean>;
+  positional: string[];
+} {
+  const flags: Record<string, string | boolean> = {};
+  const positional: string[] = [];
+  let command = "";
+
+  // Skip node and script path (argv[0], argv[1])
+  const args = argv.slice(2);
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-")) {
+      const key = arg.slice(1);
+      flags[key] = true;
+    } else if (!command) {
+      command = arg;
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  return { command, flags, positional };
+}
+
+/**
+ * Run the CLI with the given argv.
+ * Returns the exit code (0 = success, 1 = failure).
+ */
+export async function run(argv: string[]): Promise<number> {
+  const { resolve } = (await import(/* @vite-ignore */ "path")) as {
+    resolve: (...args: string[]) => string;
+  };
+
+  const { command, flags, positional } = parseArgs(argv);
+  const verbose = flags["verbose"] === true || flags["v"] === true;
+
+  const { createLogger: createLog } = await import("./logger.js");
+  const logger = createLog({ verbose });
+
+  if (!command || command === "help") {
+    logger.info("Usage: typokit <command> [options]");
+    logger.info("");
+    logger.info("Commands:");
+    logger.info("  build              Run the full build pipeline");
+    logger.info("  dev                Start dev server with watch mode");
+    logger.info("  generate:<sub>     Generate specific artifacts");
+    logger.info("    generate:db      Generate DB schema from types");
+    logger.info("    generate:client  Generate API client from contracts");
+    logger.info("    generate:openapi Generate OpenAPI spec (--output <path>)");
+    logger.info("    generate:tests   Regenerate contract tests");
+    logger.info("  migrate:<sub>      Database migration management");
+    logger.info(
+      "    migrate:generate Generate migration from type diff (--name <name>)",
+    );
+    logger.info(
+      "    migrate:diff     Show pending schema changes (--json for JSON)",
+    );
+    logger.info(
+      "    migrate:apply    Apply pending migrations (--force for destructive)",
+    );
+    logger.info(
+      "  inspect <sub>      Inspect framework state (routes, schema, etc.)",
+    );
+    logger.info("  test               Run all tests (auto-detects runner)");
+    logger.info("  test:contracts     Run generated contract tests only");
+    logger.info("  test:integration   Run integration tests");
+    logger.info(
+      "  init [name]        Create a new TypoKit project from template",
+    );
+    logger.info("  add route <name>   Scaffold a new route module");
+    logger.info("  add service <name> Scaffold a new service file");
+    logger.info("");
+    logger.info("Options:");
+    logger.info("  --verbose, -v         Show detailed output");
+    logger.info(
+      "  --root <dir>          Project root directory (default: cwd)",
+    );
+    logger.info(
+      "  --json                Output as JSON (for inspect commands)",
+    );
+    logger.info("  --format json         Alias for --json");
+    logger.info(
+      "  --runner <runner>     Override test runner (jest|vitest|rstest)",
+    );
+    logger.info("  --debug-port <port>   Debug sidecar port (default: 9800)");
+    return 0;
+  }
+
+  if (command === "build") {
+    const g = globalThis as Record<string, unknown>;
+    const proc = g["process"] as { cwd(): string } | undefined;
+    const cwd = proc?.cwd() ?? ".";
+    const rootDir =
+      typeof flags["root"] === "string" ? resolve(flags["root"]) : cwd;
+
+    const { loadConfig: loadConf } = await import("./config.js");
+    const config = await loadConf(rootDir);
+
+    const { executeBuild: execBuild } = await import("./commands/build.js");
+    const result = await execBuild({
+      rootDir,
+      config,
+      logger,
+      verbose,
+    });
+
+    return result.success ? 0 : 1;
+  }
+
+  if (command === "dev") {
+    const g = globalThis as Record<string, unknown>;
+    const proc = g["process"] as { cwd(): string } | undefined;
+    const cwd = proc?.cwd() ?? ".";
+    const rootDir =
+      typeof flags["root"] === "string" ? resolve(flags["root"]) : cwd;
+
+    const debugPort =
+      typeof flags["debug-port"] === "string"
+        ? parseInt(flags["debug-port"], 10)
+        : 9800;
+
+    const { loadConfig: loadConf } = await import("./config.js");
+    const config = await loadConf(rootDir);
+
+    const { executeDev: execDev } = await import("./commands/dev.js");
+    const { state } = await execDev({
+      rootDir,
+      config,
+      logger,
+      verbose,
+      debugPort,
+    });
+
+    // Keep running until stopped (dev mode is long-running)
+    // The executeDev function sets up watchers and signal handlers
+    // We return 0 when it stops
+    if (!state.running) {
+      return 1;
+    }
+
+    // In a real scenario, we'd await a signal here
+    // For now, return 0 to indicate successful start
+    return 0;
+  }
+
+  if (command.startsWith("generate:")) {
+    const g = globalThis as Record<string, unknown>;
+    const proc = g["process"] as { cwd(): string } | undefined;
+    const cwd = proc?.cwd() ?? ".";
+    const rootDir =
+      typeof flags["root"] === "string" ? resolve(flags["root"]) : cwd;
+
+    const { loadConfig: loadConf } = await import("./config.js");
+    const config = await loadConf(rootDir);
+
+    const subcommand = command.slice("generate:".length);
+    const { executeGenerate: execGenerate } =
+      await import("./commands/generate.js");
+    const result = await execGenerate({
+      rootDir,
+      config,
+      logger,
+      subcommand,
+      flags,
+      verbose,
+    });
+
+    return result.success ? 0 : 1;
+  }
+
+  if (command.startsWith("migrate:")) {
+    const g = globalThis as Record<string, unknown>;
+    const proc = g["process"] as { cwd(): string } | undefined;
+    const cwd = proc?.cwd() ?? ".";
+    const rootDir =
+      typeof flags["root"] === "string" ? resolve(flags["root"]) : cwd;
+
+    const { loadConfig: loadConf } = await import("./config.js");
+    const config = await loadConf(rootDir);
+
+    const subcommand = command.slice("migrate:".length);
+    const { executeMigrate: execMigrate } =
+      await import("./commands/migrate.js");
+    const result = await execMigrate({
+      rootDir,
+      config,
+      logger,
+      subcommand,
+      flags,
+      verbose,
+    });
+
+    return result.success ? 0 : 1;
+  }
+
+  if (command === "inspect") {
+    const g = globalThis as Record<string, unknown>;
+    const proc = g["process"] as { cwd(): string } | undefined;
+    const cwd = proc?.cwd() ?? ".";
+    const rootDir =
+      typeof flags["root"] === "string" ? resolve(flags["root"]) : cwd;
+
+    const { loadConfig: loadConf } = await import("./config.js");
+    const config = await loadConf(rootDir);
+
+    const { executeInspect: execInspect } =
+      await import("./commands/inspect.js");
+    const subcommand = positional[0] ?? "";
+    const subPositional = positional.slice(1);
+
+    const result = await execInspect({
+      rootDir,
+      config,
+      logger,
+      subcommand,
+      positional: subPositional,
+      flags,
+    });
+
+    return result.success ? 0 : 1;
+  }
+
+  if (command === "init") {
+    const g = globalThis as Record<string, unknown>;
+    const proc = g["process"] as { cwd(): string } | undefined;
+    const cwd = proc?.cwd() ?? ".";
+    const rootDir =
+      typeof flags["root"] === "string" ? resolve(flags["root"]) : cwd;
+
+    const { executeScaffold: execScaffold } =
+      await import("./commands/scaffold.js");
+    const result = await execScaffold({
+      rootDir,
+      logger,
+      subcommand: "init",
+      positional,
+      flags,
+      verbose,
+    });
+
+    return result.success ? 0 : 1;
+  }
+
+  if (command === "add") {
+    const g = globalThis as Record<string, unknown>;
+    const proc = g["process"] as { cwd(): string } | undefined;
+    const cwd = proc?.cwd() ?? ".";
+    const rootDir =
+      typeof flags["root"] === "string" ? resolve(flags["root"]) : cwd;
+
+    const subcommand = positional[0] ?? "";
+    const subPositional = positional.slice(1);
+
+    const { executeScaffold: execScaffold } =
+      await import("./commands/scaffold.js");
+    const result = await execScaffold({
+      rootDir,
+      logger,
+      subcommand,
+      positional: subPositional,
+      flags,
+      verbose,
+    });
+
+    return result.success ? 0 : 1;
+  }
+
+  if (command === "test" || command.startsWith("test:")) {
+    const g = globalThis as Record<string, unknown>;
+    const proc = g["process"] as { cwd(): string } | undefined;
+    const cwd = proc?.cwd() ?? ".";
+    const rootDir =
+      typeof flags["root"] === "string" ? resolve(flags["root"]) : cwd;
+
+    const { loadConfig: loadConf } = await import("./config.js");
+    const config = await loadConf(rootDir);
+
+    const subcommand =
+      command === "test" ? "all" : command.slice("test:".length);
+
+    const { executeTest: execTest } = await import("./commands/test.js");
+    const result = await execTest({
+      rootDir,
+      config,
+      logger,
+      subcommand,
+      flags,
+      verbose,
+    });
+
+    return result.success ? 0 : 1;
+  }
+
+  logger.error(`Unknown command: ${command}`);
+  logger.info("Run 'typokit help' for usage information.");
+  return 1;
+}