@giselles-ai/sandkit 0.1.0

package/dist/bin.js

@@ -0,0 +1,697 @@
+#!/usr/bin/env node
+
+// src/cli/generate.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+
+// src/schema/generate.ts
+var typeMap = {
+  sqlite: {
+    text: { type: "text" },
+    integer: { type: "integer" },
+    boolean: { type: "integer", options: "{ mode: 'boolean' }" },
+    json: { type: "text", options: "{ mode: 'json' }" },
+    timestamp: { type: "integer", options: "{ mode: 'timestamp_ms' }" }
+  },
+  postgresql: {
+    text: { type: "text" },
+    integer: { type: "integer" },
+    boolean: { type: "boolean" },
+    json: { type: "jsonb" },
+    timestamp: { type: "timestamp" }
+  },
+  mysql: {
+    text: { type: "text" },
+    integer: { type: "int" },
+    boolean: { type: "boolean" },
+    json: { type: "json" },
+    timestamp: { type: "timestamp" }
+  }
+};
+var tableFactoryByDialect = {
+  sqlite: "sqliteTable",
+  postgresql: "pgTable",
+  mysql: "mysqlTable"
+};
+function renderTextSchema(model) {
+  const exportNameByTable = new Map(
+    model.tables.map((table) => [table.name, table.exportName ?? table.name])
+  );
+  const entries = model.tables.map((table) => {
+    const builder = tableFactoryByDialect[model.dialect];
+    const tableExpr = model.dialect === "sqlite" ? `${builder}("${table.name}", {` : `${builder}("${table.name}", {
+`;
+    const row = table.columns.map((column) => {
+      const mappedDialect = typeMap[model.dialect];
+      if (!mappedDialect) {
+        throw new Error(`Unsupported dialect "${model.dialect}"`);
+      }
+      const mappedType = mappedDialect[column.type];
+      if (!mappedType) {
+        throw new Error(
+          `Unsupported column type "${column.type}" for dialect "${model.dialect}"`
+        );
+      }
+      const optionsSuffix = mappedType.options ? `, ${mappedType.options}` : "";
+      const defaultValue = column.defaultValue === null ? "default null" : "";
+      const required = column.nullable === true ? "" : ".notNull()";
+      const unique = column.unique ? ".unique()" : "";
+      const primary = column.primaryKey ? ".primaryKey()" : "";
+      const ref = column.references ? `.references(() => ${exportNameByTable.get(column.references.table) ?? column.references.table}.${column.references.field})` : "";
+      return `  ${column.name}: ${mappedType.type}("${column.name}"${optionsSuffix})${required}${defaultValue}${unique}${primary}${ref}`;
+    }).join(",\n");
+    const rows = row ? `
+${row}
+` : "\n";
+    const exportName = table.exportName ?? table.name;
+    return `export const ${exportName} = ${tableExpr}${rows}});`;
+  }).join("\n\n");
+  const imports = {
+    sqlite: 'import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";',
+    postgresql: 'import { boolean, integer, jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core";',
+    mysql: 'import { boolean, int, json, mysqlTable, text, timestamp } from "drizzle-orm/mysql-core";'
+  };
+  return `// This file is generated from Sandkit schema model.
+// Provider: ${model.dialect}
+// Version: ${model.version}
+
+${imports[model.dialect]}
+
+${entries}
+
+export const sandkitSchema = {
+${model.tables.map((table) => {
+    const exportName = table.exportName ?? table.name;
+    return `  ${exportName},`;
+  }).join("\n")}
+};
+`;
+}
+function createGeneratePayload(dialect, model) {
+  return {
+    dialect,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      tableCount: model.tables.length,
+      tableNames: model.tables.map((table) => table.name)
+    },
+    schemaText: renderTextSchema(model)
+  };
+}
+
+// src/schema/model.ts
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var baseSchemaName = "sandkit";
+var tablePrefix = "sandkit_";
+var sandkitWorkspaceExport = "sandkitWorkspaces";
+var sandkitRunExport = "sandkitRuns";
+var sandkitPolicyExport = "sandkitPolicies";
+var sandkitSetupStateExport = "sandkitSetupStates";
+var sandkitWorkspaceTable = {
+  name: `${tablePrefix}workspaces`,
+  exportName: sandkitWorkspaceExport,
+  comment: "Persistent workspace metadata.",
+  columns: [
+    {
+      name: "id",
+      type: "text",
+      primaryKey: true,
+      nullable: false,
+      comment: "Workspace identifier."
+    },
+    {
+      name: "metadata",
+      type: "json",
+      nullable: true,
+      comment: "Durable workspace metadata, including sandbox lifecycle state."
+    },
+    {
+      name: "sandboxId",
+      type: "text",
+      nullable: true,
+      comment: "Stable id returned by the sandbox provider."
+    },
+    { name: "status", type: "text", nullable: false },
+    { name: "name", type: "text", nullable: true },
+    {
+      name: "lastResumedAt",
+      type: "timestamp",
+      nullable: true,
+      comment: "Most recent point when Sandkit resolved a concrete sandbox session."
+    },
+    { name: "createdAt", type: "timestamp", nullable: false },
+    { name: "updatedAt", type: "timestamp", nullable: false }
+  ],
+  indexes: [{ name: "workspaces_status_idx", columns: ["status"] }]
+};
+var sandkitRunTable = {
+  name: `${tablePrefix}runs`,
+  exportName: sandkitRunExport,
+  comment: "Execution facts for unit-of-work runs.",
+  columns: [
+    {
+      name: "id",
+      type: "text",
+      primaryKey: true,
+      nullable: false,
+      comment: "Run identifier."
+    },
+    {
+      name: "workspace_id",
+      type: "text",
+      nullable: false,
+      comment: "FK to workspace.",
+      references: {
+        table: sandkitWorkspaceTable.name,
+        field: "id"
+      }
+    },
+    { name: "command", type: "text", nullable: false },
+    {
+      name: "args",
+      type: "json",
+      nullable: true,
+      comment: "Arguments for the executed command."
+    },
+    {
+      name: "provider",
+      type: "text",
+      nullable: false,
+      comment: "Driver identity used for execution (e.g. vercel-sandbox, mock)."
+    },
+    {
+      name: "execution_target_id",
+      type: "text",
+      nullable: false,
+      comment: "Driver execution target used by the command run."
+    },
+    {
+      name: "status",
+      type: "text",
+      nullable: false,
+      comment: "Unit status."
+    },
+    {
+      name: "policy_snapshot_id",
+      type: "text",
+      nullable: true,
+      comment: "FK to policy snapshot row."
+    },
+    {
+      name: "provider_commit",
+      type: "json",
+      nullable: true,
+      comment: "Provider durability metadata at run completion."
+    },
+    { name: "exit_code", type: "integer", nullable: true },
+    { name: "stdout", type: "text", nullable: true },
+    { name: "stderr", type: "text", nullable: true },
+    { name: "started_at", type: "timestamp", nullable: false },
+    { name: "finished_at", type: "timestamp", nullable: true }
+  ],
+  indexes: [
+    { name: "runs_workspace_id_idx", columns: ["workspace_id"] },
+    { name: "runs_finished_at_idx", columns: ["finished_at"] },
+    { name: "runs_status_idx", columns: ["status"] }
+  ]
+};
+var sandkitPolicyTable = {
+  name: `${tablePrefix}policies`,
+  exportName: sandkitPolicyExport,
+  comment: "Network policy snapshots and source of truth.",
+  columns: [
+    {
+      name: "id",
+      type: "text",
+      primaryKey: true,
+      nullable: false
+    },
+    {
+      name: "workspace_id",
+      type: "text",
+      nullable: false,
+      comment: "FK to workspace.",
+      references: {
+        table: sandkitWorkspaceTable.name,
+        field: "id"
+      }
+    },
+    { name: "policy_id", type: "text", nullable: false },
+    { name: "config", type: "json", nullable: false },
+    { name: "created_at", type: "timestamp", nullable: false }
+  ],
+  indexes: [{ name: "policies_workspace_id_idx", columns: ["workspace_id"] }]
+};
+var sandkitSetupStateTable = {
+  name: `${tablePrefix}setup_states`,
+  exportName: sandkitSetupStateExport,
+  comment: "Durable shared setup state shared by all workspaces on one adapter.",
+  columns: [
+    {
+      name: "id",
+      type: "text",
+      primaryKey: true,
+      nullable: false,
+      comment: "Shared setup state identifier."
+    },
+    {
+      name: "state",
+      type: "json",
+      nullable: false,
+      comment: "Serialized durable setup snapshot state."
+    },
+    { name: "createdAt", type: "timestamp", nullable: false },
+    { name: "updatedAt", type: "timestamp", nullable: false }
+  ]
+};
+function createSandkitSchemaModel(dialect = "sqlite") {
+  const schemaName = dialect === "postgresql" ? `${baseSchemaName}_schema` : baseSchemaName;
+  return {
+    name: schemaName,
+    version: 4,
+    dialect,
+    tables: [
+      {
+        ...sandkitWorkspaceTable,
+        schema: dialect === "postgresql" ? "public" : void 0
+      },
+      {
+        ...sandkitRunTable,
+        schema: dialect === "postgresql" ? "public" : void 0
+      },
+      {
+        ...sandkitPolicyTable,
+        schema: dialect === "postgresql" ? "public" : void 0
+      },
+      {
+        ...sandkitSetupStateTable,
+        schema: dialect === "postgresql" ? "public" : void 0
+      }
+    ]
+  };
+}
+function createModelSnapshot(dialect = "sqlite") {
+  return {
+    model: createSandkitSchemaModel(dialect),
+    generatedAt: nowIso()
+  };
+}
+
+// src/cli/discovery.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { createInterface } from "readline";
+var drizzleConfigFiles = [
+  "drizzle.config.ts",
+  "drizzle.config.js",
+  "drizzle.config.mjs",
+  "drizzle.config.cjs",
+  "drizzle.config.mts",
+  "drizzle.config.cts",
+  "drizzle.config.json",
+  "drizzle.config.yaml",
+  "drizzle.config.yml"
+];
+var drizzleDependency = "drizzle-orm";
+function parsePackageJsonDependencies(packagePath, evidence) {
+  if (!existsSync(packagePath)) {
+    return [];
+  }
+  let packageData = {};
+  try {
+    packageData = JSON.parse(readFileSync(packagePath, "utf8"));
+  } catch {
+    return [];
+  }
+  const dependencies = { ...packageData.dependencies, ...packageData.devDependencies };
+  const depNames = Object.keys(dependencies);
+  if (!depNames.includes(drizzleDependency)) {
+    return [];
+  }
+  evidence.push({
+    source: "package.json",
+    signal: "Dependency `drizzle-orm` found.",
+    score: 1.1
+  });
+  const sqliteSignals = [
+    ["better-sqlite3", "sqlite"],
+    ["libsql", "sqlite"],
+    ["@libsql/client", "sqlite"],
+    ["@turso", "sqlite"]
+  ].flatMap(
+    ([name, provider]) => depNames.some((dep) => dep.includes(name)) ? [{ provider, weight: 1.6 }] : []
+  );
+  const postgresSignals = [
+    ["pg", "postgresql"],
+    ["postgres", "postgresql"],
+    ["@vercel/postgres", "postgresql"],
+    ["@neondatabase/serverless", "postgresql"]
+  ].flatMap(
+    ([name, provider]) => depNames.some((dep) => dep.includes(name)) ? [{ provider, weight: 1.6 }] : []
+  );
+  const addSignals = (signals) => signals.forEach(
+    (entry) => evidence.push({
+      source: "package.json",
+      signal: `Dependency implies ${entry.provider} driver usage (${entry.provider} signal).`,
+      provider: entry.provider,
+      score: entry.weight
+    })
+  );
+  addSignals(sqliteSignals);
+  addSignals(postgresSignals);
+  return [...sqliteSignals, ...postgresSignals];
+}
+function inspectDrizzleConfig(cwd, evidence) {
+  const results = [];
+  for (const filename of drizzleConfigFiles) {
+    const configPath = join(cwd, filename);
+    if (!existsSync(configPath)) {
+      continue;
+    }
+    let text = "";
+    try {
+      text = readFileSync(configPath, "utf8");
+    } catch {
+      continue;
+    }
+    evidence.push({
+      source: filename,
+      signal: `Found drizzle config file: ${filename}.`,
+      score: 0.6
+    });
+    if (/dialect\s*:\s*["']sqlite["']/i.test(text)) {
+      evidence.push({
+        source: filename,
+        signal: "Drizzle config sets dialect to sqlite.",
+        provider: "sqlite",
+        score: 3
+      });
+      return [{ provider: "sqlite", weight: 3 }];
+    }
+    if (/dialect\s*:\s*["']postgresql["']/i.test(text)) {
+      evidence.push({
+        source: filename,
+        signal: "Drizzle config sets dialect to postgresql.",
+        provider: "postgresql",
+        score: 3
+      });
+      return [{ provider: "postgresql", weight: 3 }];
+    }
+    if (/dialect\s*:\s*["']mysql["']/i.test(text)) {
+      evidence.push({
+        source: filename,
+        signal: "Drizzle config sets dialect to mysql.",
+        provider: "mysql",
+        score: 3
+      });
+      return [{ provider: "mysql", weight: 3 }];
+    }
+    const dbUrlMatch = text.match(/url\s*:\s*["'`](.*?)["'`]/i);
+    if (dbUrlMatch?.[1]) {
+      const url = dbUrlMatch[1].toLowerCase();
+      if (url.includes("turso") || url.includes("libsql") || url.includes("sqlite")) {
+        evidence.push({
+          source: filename,
+          signal: "Drizzle config DB URL contains sqlite/libsql/turso hints.",
+          provider: "sqlite",
+          score: 2
+        });
+        results.push({ provider: "sqlite", weight: 2 });
+      }
+      if (url.includes("postgres")) {
+        evidence.push({
+          source: filename,
+          signal: "Drizzle config DB URL contains postgres hints.",
+          provider: "postgresql",
+          score: 2
+        });
+        results.push({ provider: "postgresql", weight: 2 });
+      }
+    }
+  }
+  return results;
+}
+function collectEvidence(cwd) {
+  const evidence = [];
+  const packageSignals = parsePackageJsonDependencies(join(cwd, "package.json"), evidence);
+  const drizzleSignals = inspectDrizzleConfig(cwd, evidence);
+  return {
+    evidence,
+    isDrizzleProject: packageSignals.length > 0 || drizzleSignals.length > 0
+  };
+}
+function rankProviderSignals(evidence) {
+  const totals = { sqlite: 0, postgresql: 0, mysql: 0 };
+  for (const item of evidence) {
+    if (!item.provider) continue;
+    totals[item.provider] += item.score;
+  }
+  const ranked = Object.entries(totals).sort((a, b) => b[1] - a[1]).filter((entry) => entry[1] > 0);
+  if (ranked.length === 0) {
+    return { provider: void 0, confidence: 0 };
+  }
+  const [winner, winnerScore] = ranked[0];
+  const secondScore = ranked[1]?.[1] ?? 0;
+  const confidence = winnerScore === 0 ? 0 : winnerScore / (winnerScore + secondScore);
+  return { provider: winner, confidence };
+}
+function promptWithChoices(question, options, fallback) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      if (options.includes(normalized)) {
+        resolve(normalized);
+        return;
+      }
+      resolve(fallback);
+    });
+  });
+}
+async function resolveProviderWithDiscovery(options, cwd = process.cwd()) {
+  const requestedProvider = options.provider ?? options.dialect;
+  const normalizedProvider = requestedProvider === "pg" ? "postgresql" : requestedProvider;
+  if (normalizedProvider) {
+    if (normalizedProvider !== "sqlite" && normalizedProvider !== "postgresql" && normalizedProvider !== "mysql") {
+      throw new Error("Invalid provider. Use one of: sqlite, postgresql, mysql.");
+    }
+    return {
+      adapter: "drizzle",
+      provider: normalizedProvider,
+      confidence: 1,
+      evidence: [
+        {
+          source: "cli",
+          signal: `Provider explicitly set as ${normalizedProvider}.`,
+          provider: normalizedProvider,
+          score: 100
+        }
+      ],
+      prompted: false
+    };
+  }
+  if (options.adapter && options.adapter !== "drizzle") {
+    throw new Error("Unsupported adapter. This release supports --adapter drizzle only.");
+  }
+  const { evidence, isDrizzleProject } = collectEvidence(cwd);
+  const inference = rankProviderSignals(evidence);
+  const adapter = isDrizzleProject ? "drizzle" : "drizzle";
+  if (!isDrizzleProject) {
+    throw new Error(
+      "Could not detect a drizzle project from this directory. Run inside a Drizzle project and pass --dialect/--adapter explicitly if needed."
+    );
+  }
+  if (inference.provider && inference.confidence >= 0.75) {
+    return {
+      adapter,
+      provider: inference.provider,
+      confidence: inference.confidence,
+      evidence,
+      prompted: false
+    };
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error(
+      "Could not infer database provider confidently. Re-run with --dialect <sqlite|postgresql|pg>."
+    );
+  }
+  const prompt = await promptWithChoices(
+    `Could not infer the database provider from repo signals.
+Select provider [sqlite|postgresql|mysql] (default sqlite): `,
+    ["sqlite", "postgresql", "mysql"],
+    "sqlite"
+  );
+  return {
+    adapter,
+    provider: prompt,
+    confidence: inference.confidence,
+    evidence,
+    prompted: true
+  };
+}
+
+// src/cli/generate.ts
+function usage() {
+  return [
+    "Usage: sandkit generate [--adapter drizzle] [--dialect <sqlite|postgresql|pg>] [--out <file>] [--stdout]",
+    "Example: npx @giselles-ai/sandkit generate --dialect sqlite --stdout",
+    "Example: npx @giselles-ai/sandkit generate --adapter drizzle --dialect postgresql --stdout",
+    "If --stdout is omitted, output is shown to console by default.",
+    "Default output file: db/schema/sandkit.ts"
+  ].join("\n");
+}
+function parseGenerateArgs(argv) {
+  let provider;
+  let dialect;
+  let adapter;
+  let out;
+  let stdout = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--adapter") {
+      const next = argv[i + 1];
+      if (next === "drizzle") {
+        adapter = next;
+        i++;
+        continue;
+      }
+      throw new Error("Unsupported --adapter value. Use --adapter drizzle.");
+    }
+    if (arg === "--provider") {
+      const next = argv[i + 1];
+      if (next === "sqlite" || next === "postgresql" || next === "mysql") {
+        provider = next;
+        i++;
+        continue;
+      }
+      throw new Error(`Invalid provider: ${next}`);
+    }
+    if (arg === "--dialect") {
+      const next = argv[i + 1];
+      if (next === "sqlite" || next === "postgresql" || next === "pg") {
+        dialect = next === "pg" ? "postgresql" : next;
+        i++;
+        continue;
+      }
+      throw new Error(`Invalid dialect: ${next}`);
+    }
+    if (arg === "--out") {
+      const next = argv[i + 1];
+      if (!next) {
+        throw new Error("Missing --out path");
+      }
+      out = next;
+      i++;
+      continue;
+    }
+    if (arg === "--stdout") {
+      stdout = true;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      throw new Error(usage());
+    }
+    if (arg === "generate") {
+      continue;
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+  return {
+    provider,
+    dialect,
+    adapter,
+    out,
+    stdout
+  };
+}
+function runGenerateCommand(options) {
+  const snapshot = createModelSnapshot(options.provider);
+  const payload = createGeneratePayload(options.provider, snapshot.model);
+  const defaultOutputFile = options.adapter === "drizzle" || options.adapter === void 0 ? "db/schema/sandkit.ts" : `sandkit-schema.${options.provider}.ts`;
+  const outputFile = options.out ?? defaultOutputFile;
+  const result = {
+    command: "generate",
+    provider: options.provider,
+    outputTarget: options.stdout ? "stdout" : "file",
+    outputFile: options.stdout ? null : outputFile,
+    payload: {
+      generatedAt: payload.generatedAt,
+      summary: payload.summary,
+      schemaText: payload.schemaText
+    }
+  };
+  if (!options.stdout) {
+    mkdirSync(dirname(outputFile), { recursive: true });
+    writeFileSync(outputFile, payload.schemaText, "utf8");
+  }
+  return result;
+}
+async function runCliGenerate(argv) {
+  const options = parseGenerateArgs(argv);
+  const discovered = await resolveProviderWithDiscovery({
+    provider: options.provider,
+    adapter: options.adapter,
+    dialect: options.dialect,
+    stdout: false,
+    out: options.out
+  });
+  return runGenerateCommand({
+    provider: discovered.provider,
+    adapter: discovered.adapter,
+    dialect: options.dialect,
+    out: options.out,
+    stdout: options.stdout
+  });
+}
+
+// src/cli/index.ts
+function buildHelp() {
+  return [
+    "Sandkit CLI",
+    "Commands: generate",
+    "",
+    "  sandkit generate [--adapter drizzle] [--dialect <sqlite|postgresql|pg>] [--stdout] [--out file]",
+    "",
+    "When --stdout is set, output is returned in memory and printed by caller."
+  ].join("\n");
+}
+function parseArgs(argv) {
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    throw new Error(buildHelp());
+  }
+  const command = argv[0];
+  if (command !== "generate") {
+    throw new Error(`Unknown command: ${command}`);
+  }
+  const rest = argv.slice(1);
+  const commandOptions = parseGenerateArgs(rest);
+  return { command, ...commandOptions, rest };
+}
+async function runCli(argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv);
+  if (parsed.command === "generate") {
+    const { rest } = parsed;
+    return runCliGenerate(rest);
+  }
+  throw new Error(`Unhandled command: ${parsed.command}`);
+}
+
+// src/cli/bin.ts
+var args = process.argv.slice(2);
+try {
+  const result = await runCli(args);
+  if (result.outputTarget === "stdout") {
+    process.stdout.write(`${result.payload.schemaText}
+`);
+  }
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}
+`);
+  process.exitCode = 1;
+}
+//# sourceMappingURL=bin.js.map