@invect/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,581 @@
+#!/usr/bin/env node
+import {
+  generateCommand
+} from "./chunk-T4KEEHFJ.js";
+import "./chunk-K4RRNATQ.js";
+import {
+  migrateCommand
+} from "./chunk-DGBTXQND.js";
+import {
+  findConfigPath,
+  loadConfig
+} from "./chunk-Q6JKV7VX.js";
+
+// src/index.ts
+import { Command as Command4 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import path from "path";
+import fs from "fs";
+import { execSync } from "child_process";
+import pc from "picocolors";
+import prompts from "prompts";
+var FRAMEWORKS = [
+  {
+    name: "Express",
+    id: "express",
+    dependency: "express",
+    adapterPackage: "@invect/express",
+    configPaths: null
+  },
+  {
+    name: "NestJS",
+    id: "nestjs",
+    dependency: "@nestjs/core",
+    adapterPackage: "@invect/nestjs",
+    configPaths: ["nest-cli.json"]
+  },
+  {
+    name: "Next.js",
+    id: "nextjs",
+    dependency: "next",
+    adapterPackage: "@invect/nextjs",
+    configPaths: ["next.config.js", "next.config.ts", "next.config.mjs"]
+  },
+  {
+    name: "Other / Custom",
+    id: "other",
+    dependency: null,
+    adapterPackage: null,
+    configPaths: null
+  }
+];
+var DATABASES = [
+  { name: "SQLite (better-sqlite3)", id: "sqlite", dependency: "better-sqlite3" },
+  { name: "PostgreSQL", id: "postgresql", dependency: "postgres" },
+  { name: "MySQL", id: "mysql", dependency: "mysql2" }
+];
+var initCommand = new Command("init").description("Initialize Invect in your project").option("--framework <framework>", "Framework to use (express, nestjs, nextjs)").option("--database <database>", "Database to use (sqlite, postgresql, mysql)").option(
+  "--package-manager <pm>",
+  "Package manager (npm, pnpm, yarn, bun)"
+).action(async (options) => {
+  console.log(
+    "\n" + [
+      `   ${pc.bold("Invect CLI")} ${pc.dim("(v0.1.0)")}`,
+      `   ${pc.gray("Let's set up Invect in your project.")}`
+    ].join("\n") + "\n"
+  );
+  const pkgPath = path.join(process.cwd(), "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    console.error(
+      pc.red("\u2717 No package.json found in the current directory.\n") + pc.dim("  Please initialize a project first (e.g., npm init).\n")
+    );
+    process.exit(1);
+  }
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  let stepNum = 0;
+  const step = (text) => {
+    stepNum++;
+    console.log(pc.white(`
+${stepNum}. ${text}`));
+  };
+  const pm = options.packageManager || detectPackageManager();
+  console.log(pc.dim(`  Package manager: ${pm}`));
+  step("Select Framework");
+  let framework;
+  if (options.framework) {
+    framework = FRAMEWORKS.find((f) => f.id === options.framework) || FRAMEWORKS[FRAMEWORKS.length - 1];
+  } else {
+    const detected = FRAMEWORKS.find((f) => f.dependency && f.dependency in allDeps);
+    if (detected) {
+      console.log(pc.dim(`  Detected: ${detected.name}`));
+      const { useDetected } = await prompts({
+        type: "confirm",
+        name: "useDetected",
+        message: `Use detected framework ${pc.cyan(detected.name)}?`,
+        initial: true
+      });
+      framework = useDetected ? detected : await askFramework();
+    } else {
+      framework = await askFramework();
+    }
+  }
+  console.log(pc.dim(`  Framework: ${framework.name}`));
+  step("Select Database");
+  let database;
+  if (options.database) {
+    database = DATABASES.find((d) => d.id === options.database) || DATABASES[0];
+  } else {
+    const detected = DATABASES.find((d) => d.dependency in allDeps);
+    if (detected) {
+      console.log(pc.dim(`  Detected: ${detected.name}`));
+      database = detected;
+    } else {
+      database = await askDatabase();
+    }
+  }
+  console.log(pc.dim(`  Database: ${database.name}`));
+  step("Install Dependencies");
+  const depsToInstall = ["@invect/core", "drizzle-orm"];
+  const devDepsToInstall = ["drizzle-kit", "@invect/cli"];
+  if (!(database.dependency in allDeps)) {
+    depsToInstall.push(database.dependency);
+  }
+  if (framework.adapterPackage && !(framework.adapterPackage in allDeps)) {
+    depsToInstall.push(framework.adapterPackage);
+  }
+  if (framework.id !== "other") {
+    if (!("@invect/frontend" in allDeps)) {
+      depsToInstall.push("@invect/frontend");
+    }
+  }
+  console.log(pc.dim(`  Dependencies: ${depsToInstall.join(", ")}`));
+  if (devDepsToInstall.length > 0) {
+    console.log(pc.dim(`  Dev dependencies: ${devDepsToInstall.join(", ")}`));
+  }
+  const { shouldInstall } = await prompts({
+    type: "confirm",
+    name: "shouldInstall",
+    message: `Install packages using ${pc.bold(pm)}?`,
+    initial: true
+  });
+  if (shouldInstall) {
+    try {
+      const installCmd = getInstallCommand(pm, depsToInstall, false);
+      console.log(pc.dim(`  $ ${installCmd}`));
+      execSync(installCmd, { stdio: "inherit", cwd: process.cwd() });
+      if (devDepsToInstall.length > 0) {
+        const devCmd = getInstallCommand(pm, devDepsToInstall, true);
+        console.log(pc.dim(`  $ ${devCmd}`));
+        execSync(devCmd, { stdio: "inherit", cwd: process.cwd() });
+      }
+    } catch {
+      console.error(pc.yellow("  \u26A0 Package installation failed. You can install manually later."));
+    }
+  }
+  step("Create Configuration");
+  const configCode = generateConfigFile(framework, database);
+  const configDir = fs.existsSync(path.join(process.cwd(), "src")) ? "src" : ".";
+  const configPath = path.join(process.cwd(), configDir, "invect.config.ts");
+  if (fs.existsSync(configPath)) {
+    console.log(pc.yellow(`  \u26A0 ${path.relative(process.cwd(), configPath)} already exists \u2014 skipping`));
+  } else {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, configCode, "utf-8");
+    console.log(pc.green(`  \u2713 Created ${path.relative(process.cwd(), configPath)}`));
+  }
+  step("Generate Encryption Key");
+  const crypto2 = await import("crypto");
+  const encryptionKey = crypto2.randomBytes(32).toString("base64");
+  const envPath = path.join(process.cwd(), ".env");
+  const envLine = `INVECT_ENCRYPTION_KEY="${encryptionKey}"`;
+  if (fs.existsSync(envPath)) {
+    const envContent = fs.readFileSync(envPath, "utf-8");
+    if (!envContent.includes("INVECT_ENCRYPTION_KEY")) {
+      fs.appendFileSync(envPath, `
+${envLine}
+`);
+      console.log(pc.green(`  \u2713 Added INVECT_ENCRYPTION_KEY to .env`));
+    } else {
+      console.log(pc.dim("  \u2139 INVECT_ENCRYPTION_KEY already set in .env"));
+    }
+  } else {
+    fs.writeFileSync(envPath, `${envLine}
+`);
+    console.log(pc.green(`  \u2713 Created .env with INVECT_ENCRYPTION_KEY`));
+  }
+  step("Generate Database Schema");
+  const { shouldGenerate } = await prompts({
+    type: "confirm",
+    name: "shouldGenerate",
+    message: "Generate database schema files now?",
+    initial: true
+  });
+  if (shouldGenerate) {
+    try {
+      const { generateAction } = await import("./generate-JDAYY3OL.js");
+      const schemaDir = fs.existsSync(path.join(process.cwd(), "src")) ? "./src/database" : "./database";
+      await generateAction({
+        config: configPath,
+        output: schemaDir,
+        yes: true
+      });
+    } catch (error) {
+      console.error(
+        pc.yellow("  \u26A0 Schema generation failed. You can run it manually later:") + "\n" + pc.dim(`    npx invect generate
+`)
+      );
+    }
+  } else {
+    console.log(
+      pc.dim(
+        "  Skipped. Run " + pc.cyan("npx invect generate") + " when ready."
+      )
+    );
+  }
+  if (database.id === "sqlite" && shouldGenerate) {
+    const { shouldMigrate } = await prompts({
+      type: "confirm",
+      name: "shouldMigrate",
+      message: "Run database migration now? (creates the SQLite database)",
+      initial: true
+    });
+    if (shouldMigrate) {
+      try {
+        const { migrateAction } = await import("./migrate-JMKLRLSJ.js");
+        await migrateAction({
+          config: configPath,
+          yes: true,
+          push: true
+          // Use push for quick dev setup
+        });
+      } catch {
+        console.error(
+          pc.yellow("  \u26A0 Migration failed. You can run it manually:") + "\n" + pc.dim("    npx invect migrate\n")
+        );
+      }
+    }
+  }
+  console.log(pc.bold(pc.green("\n\u2713 Invect initialized successfully!\n")));
+  console.log(pc.dim("  Next steps:"));
+  const nextSteps = [];
+  let n = 1;
+  nextSteps.push(`  ${n++}. Review ${pc.cyan(path.relative(process.cwd(), configPath))}`);
+  if (database.id !== "sqlite") {
+    nextSteps.push(
+      `  ${n++}. Set ${pc.cyan("DATABASE_URL")} in your .env file`
+    );
+  }
+  if (!shouldGenerate) {
+    nextSteps.push(`  ${n++}. Run ${pc.cyan("npx invect generate")} to create schema files`);
+  }
+  nextSteps.push(`  ${n++}. Run ${pc.cyan("npx invect migrate")} to apply the schema`);
+  if (framework.id === "express") {
+    nextSteps.push(`  ${n++}. Mount the router: ${pc.cyan("app.use('/invect', createInvectRouter(config))")}`);
+  } else if (framework.id === "nextjs") {
+    nextSteps.push(`  ${n++}. Create a catch-all route: ${pc.cyan("app/api/invect/[...invect]/route.ts")}`);
+  } else if (framework.id === "nestjs") {
+    nextSteps.push(`  ${n++}. Import ${pc.cyan("InvectModule.forRoot(config)")} in your AppModule`);
+  }
+  for (const s of nextSteps) {
+    console.log(s);
+  }
+  console.log("");
+});
+async function askFramework() {
+  const { framework } = await prompts({
+    type: "select",
+    name: "framework",
+    message: "Which framework are you using?",
+    choices: FRAMEWORKS.map((f) => ({
+      title: f.name,
+      value: f.id
+    }))
+  });
+  if (!framework) {
+    console.log(pc.dim("\n  Cancelled.\n"));
+    process.exit(0);
+  }
+  return FRAMEWORKS.find((f) => f.id === framework);
+}
+async function askDatabase() {
+  const { database } = await prompts({
+    type: "select",
+    name: "database",
+    message: "Which database will you use?",
+    choices: DATABASES.map((d) => ({
+      title: d.name,
+      value: d.id
+    }))
+  });
+  if (!database) {
+    console.log(pc.dim("\n  Cancelled.\n"));
+    process.exit(0);
+  }
+  return DATABASES.find((d) => d.id === database);
+}
+function generateConfigFile(framework, database) {
+  const dbConfigMap = {
+    sqlite: `  baseDatabaseConfig: {
+    type: 'sqlite',
+    connectionString: 'file:./dev.db',
+  },`,
+    postgresql: `  baseDatabaseConfig: {
+    type: 'postgresql',
+    connectionString: process.env.DATABASE_URL || 'postgresql://localhost:5432/invect',
+  },`,
+    mysql: `  baseDatabaseConfig: {
+    type: 'mysql',
+    connectionString: process.env.DATABASE_URL || 'mysql://root@localhost:3306/invect',
+  },`
+  };
+  const adapterImport = framework.adapterPackage ? `// import { ... } from '${framework.adapterPackage}';
+` : "";
+  return `/**
+ * Invect Configuration
+ *
+ * This file is read by the Invect CLI for schema generation
+ * and by your application at runtime.
+ *
+ * Docs: https://invect.dev/docs
+ */
+
+${adapterImport}export default {
+${dbConfigMap[database.id]}
+
+  // Add plugins here
+  // plugins: [],
+
+  // AI provider configuration
+  // ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+  // OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+
+  // Encryption key for credential storage (auto-generated)
+  // INVECT_ENCRYPTION_KEY: process.env.INVECT_ENCRYPTION_KEY,
+};
+`;
+}
+function detectPackageManager() {
+  const cwd = process.cwd();
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(cwd, "bun.lockb")) || fs.existsSync(path.join(cwd, "bun.lock"))) return "bun";
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function getInstallCommand(pm, packages, isDev) {
+  const flags = {
+    npm: isDev ? "--save-dev" : "",
+    pnpm: isDev ? "--save-dev" : "",
+    yarn: isDev ? "--dev" : "",
+    bun: isDev ? "--dev" : ""
+  };
+  const flag = flags[pm] || "";
+  const cmd = pm === "npm" ? "npm install" : `${pm} add`;
+  return `${cmd} ${flag} ${packages.join(" ")}`.replace(/\s+/g, " ").trim();
+}
+
+// src/commands/info.ts
+import { Command as Command2 } from "commander";
+import path2 from "path";
+import fs2 from "fs";
+import os from "os";
+import pc2 from "picocolors";
+var infoCommand = new Command2("info").description("Display diagnostic information about your Invect setup").option("--config <path>", "Path to your Invect config file").option("--json", "Output as JSON").action(async (options) => {
+  const info = {};
+  info.system = {
+    os: `${os.platform()} ${os.release()} (${os.arch()})`,
+    cpu: os.cpus()[0]?.model || "unknown",
+    memory: `${Math.round(os.totalmem() / 1024 / 1024 / 1024)}GB`,
+    nodeVersion: process.version
+  };
+  info.packageManager = detectPackageManager2();
+  info.invect = {
+    cliVersion: "0.1.0",
+    coreVersion: await detectPackageVersion("@invect/core")
+  };
+  info.frameworks = detectFrameworks();
+  info.databases = detectDatabaseTools();
+  const configPath = findConfigPath(options.config);
+  if (configPath) {
+    info.configPath = path2.relative(process.cwd(), configPath);
+    try {
+      const config = await loadConfig(configPath);
+      info.plugins = config.plugins.map((p) => ({
+        id: p.id,
+        name: p.name || p.id,
+        hasSchema: !!p.schema,
+        schemaTablesCount: p.schema ? Object.keys(p.schema).length : 0
+      }));
+      const safeConfig = redactSensitive(config.raw);
+      info.config = safeConfig;
+    } catch (error) {
+      info.configError = error instanceof Error ? error.message : String(error);
+    }
+  } else {
+    info.configPath = null;
+    info.configError = "No config file found";
+  }
+  if (options.json) {
+    console.log(JSON.stringify(info, null, 2));
+  } else {
+    printInfo(info);
+  }
+});
+function printInfo(info) {
+  console.log(pc2.bold("\n\u{1F4CB} Invect Info\n"));
+  const sys = info.system;
+  console.log(pc2.bold("  System:"));
+  console.log(pc2.dim(`    OS:      ${sys.os}`));
+  console.log(pc2.dim(`    CPU:     ${sys.cpu}`));
+  console.log(pc2.dim(`    Memory:  ${sys.memory}`));
+  console.log(pc2.dim(`    Node:    ${sys.nodeVersion}`));
+  console.log("");
+  const pm = info.packageManager;
+  console.log(pc2.bold("  Package Manager:"));
+  console.log(pc2.dim(`    ${pm}`));
+  console.log("");
+  const imp = info.invect;
+  console.log(pc2.bold("  Invect:"));
+  console.log(pc2.dim(`    CLI:   ${imp.cliVersion}`));
+  console.log(pc2.dim(`    Core:  ${imp.coreVersion}`));
+  console.log("");
+  const fw = info.frameworks;
+  console.log(pc2.bold("  Frameworks:"));
+  if (fw.length > 0) {
+    for (const f of fw) {
+      console.log(pc2.dim(`    \u2713 ${f}`));
+    }
+  } else {
+    console.log(pc2.dim("    (none detected)"));
+  }
+  console.log("");
+  const db = info.databases;
+  console.log(pc2.bold("  Database Tools:"));
+  if (db.length > 0) {
+    for (const d of db) {
+      console.log(pc2.dim(`    \u2713 ${d}`));
+    }
+  } else {
+    console.log(pc2.dim("    (none detected)"));
+  }
+  console.log("");
+  console.log(pc2.bold("  Config:"));
+  if (info.configPath) {
+    console.log(pc2.dim(`    File: ${info.configPath}`));
+  } else {
+    console.log(pc2.yellow(`    \u26A0 ${info.configError || "Not found"}`));
+  }
+  const plugins = info.plugins;
+  if (plugins && plugins.length > 0) {
+    console.log("");
+    console.log(pc2.bold("  Plugins:"));
+    for (const p of plugins) {
+      const schemaInfo = p.hasSchema ? ` (${p.schemaTablesCount} table(s))` : "";
+      console.log(pc2.dim(`    \u2713 ${p.name}${schemaInfo}`));
+    }
+  }
+  console.log("");
+}
+function detectPackageManager2() {
+  const cwd = process.cwd();
+  if (fs2.existsSync(path2.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs2.existsSync(path2.join(cwd, "bun.lockb")) || fs2.existsSync(path2.join(cwd, "bun.lock"))) return "bun";
+  if (fs2.existsSync(path2.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs2.existsSync(path2.join(cwd, "package-lock.json"))) return "npm";
+  return "unknown";
+}
+async function detectPackageVersion(pkg) {
+  try {
+    const pkgJsonPath = path2.join(process.cwd(), "node_modules", pkg, "package.json");
+    if (fs2.existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      return pkgJson.version || "unknown";
+    }
+  } catch {
+  }
+  return "not installed";
+}
+function detectFrameworks() {
+  const frameworks = [];
+  const pkgPath = path2.join(process.cwd(), "package.json");
+  if (!fs2.existsSync(pkgPath)) return frameworks;
+  try {
+    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    if (allDeps["next"]) frameworks.push(`Next.js (${allDeps["next"]})`);
+    if (allDeps["@nestjs/core"]) frameworks.push(`NestJS (${allDeps["@nestjs/core"]})`);
+    if (allDeps["express"]) frameworks.push(`Express (${allDeps["express"]})`);
+    if (allDeps["react"]) frameworks.push(`React (${allDeps["react"]})`);
+    if (allDeps["vue"]) frameworks.push(`Vue (${allDeps["vue"]})`);
+    if (allDeps["svelte"]) frameworks.push(`Svelte (${allDeps["svelte"]})`);
+    if (allDeps["hono"]) frameworks.push(`Hono (${allDeps["hono"]})`);
+    if (allDeps["fastify"]) frameworks.push(`Fastify (${allDeps["fastify"]})`);
+  } catch {
+  }
+  return frameworks;
+}
+function detectDatabaseTools() {
+  const tools = [];
+  const pkgPath = path2.join(process.cwd(), "package.json");
+  if (!fs2.existsSync(pkgPath)) return tools;
+  try {
+    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    if (allDeps["drizzle-orm"]) tools.push(`Drizzle ORM (${allDeps["drizzle-orm"]})`);
+    if (allDeps["drizzle-kit"]) tools.push(`Drizzle Kit (${allDeps["drizzle-kit"]})`);
+    if (allDeps["prisma"] || allDeps["@prisma/client"]) tools.push("Prisma");
+    if (allDeps["better-sqlite3"] || allDeps["@libsql/client"]) tools.push("SQLite");
+    if (allDeps["pg"] || allDeps["postgres"]) tools.push("PostgreSQL");
+    if (allDeps["mysql2"]) tools.push("MySQL");
+  } catch {
+  }
+  return tools;
+}
+function redactSensitive(config) {
+  const sensitiveKeys = [
+    "apiKey",
+    "api_key",
+    "secret",
+    "password",
+    "token",
+    "connectionString",
+    "databaseUrl",
+    "ANTHROPIC_API_KEY",
+    "OPENAI_API_KEY",
+    "encryptionKey"
+  ];
+  const redacted = { ...config };
+  function redactDeep(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (sensitiveKeys.some((sk) => key.toLowerCase().includes(sk.toLowerCase()))) {
+        result[key] = "[REDACTED]";
+      } else if (value && typeof value === "object" && !Array.isArray(value)) {
+        result[key] = redactDeep(value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  return redactDeep(redacted);
+}
+
+// src/commands/secret.ts
+import { Command as Command3 } from "commander";
+import crypto from "crypto";
+import pc3 from "picocolors";
+var secretCommand = new Command3("secret").description("Generate a secure encryption key for INVECT_ENCRYPTION_KEY").action(() => {
+  const key = crypto.randomBytes(32).toString("base64");
+  console.log(pc3.bold("\n\u{1F511} Generated Encryption Key\n"));
+  console.log(`  ${pc3.green(key)}`);
+  console.log("");
+  console.log(pc3.dim("  Add this to your environment:"));
+  console.log(pc3.dim(`    INVECT_ENCRYPTION_KEY="${key}"`));
+  console.log("");
+  console.log(pc3.dim("  This key is used for AES-256-GCM encryption of credentials."));
+  console.log(pc3.dim("  Store it securely \u2014 losing it means losing access to encrypted data.\n"));
+});
+
+// src/index.ts
+import "dotenv/config";
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+async function main() {
+  const program = new Command4("invect");
+  program.description("CLI for managing Invect workflow engine projects").version("0.1.0");
+  program.addCommand(generateCommand).addCommand(migrateCommand).addCommand(initCommand).addCommand(infoCommand).addCommand(secretCommand).action(() => program.help());
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  console.error("Error running Invect CLI:", error);
+  process.exit(1);
+});

package/dist/migrate-JMKLRLSJ.js

@@ -0,0 +1,9 @@
+import {
+  migrateAction,
+  migrateCommand
+} from "./chunk-DGBTXQND.js";
+import "./chunk-Q6JKV7VX.js";
+export {
+  migrateAction,
+  migrateCommand
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@invect/cli",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "CLI for managing Invect database schemas, migrations, and project setup",
+  "bin": {
+    "invect": "./dist/index.js",
+    "@invect/cli": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./api": {
+      "types": "./dist/api.d.ts",
+      "import": "./dist/api.js"
+    }
+  },
+  "dependencies": {
+    "@mrleebo/prisma-ast": "^0.14.0",
+    "commander": "^13.1.0",
+    "dotenv": "^16.4.7",
+    "jiti": "^2.4.2",
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2",
+    "@invect/core": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3",
+    "vitest": "^3.2.4"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "invect",
+    "cli",
+    "workflow",
+    "migration",
+    "drizzle"
+  ],
+  "author": "robase",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/robase/invect.git",
+    "directory": "pkg/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/robase/invect/issues"
+  },
+  "homepage": "https://invect.dev",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/api.ts --format esm --clean",
+    "dev": "tsup src/index.ts src/api.ts --format esm --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}