erdraft 0.0.1 → 0.0.2

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   DECISION_SECONDS,
+  TUNNEL_IDS,
   chooseDatabase,
   createApi,
   createServer,
@@ -16,13 +17,13 @@ import {
   storeOf,
   version_default,
   writtenIn
-} from "./chunk-SSLBX2OF.js";
+} from "./chunk-IQ5YYSCP.js";
 import "./chunk-VSN3XJPO.js";
 
 // bin/erdraft.ts
 import { fileURLToPath } from "url";
-import { existsSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join7 } from "path";
 import { text } from "stream/consumers";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -86,10 +87,10 @@ async function serveWindow(config, folder) {
 }
 
 // src/cli/run.ts
-import { readFile as readFile4 } from "fs/promises";
-import { resolve as resolve2 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { resolve as resolve4 } from "path";
 import { parseArgs } from "util";
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 
 // src/core/load-config.ts
 import { z } from "zod";
@@ -117,7 +118,9 @@ var configSchema = z.object({
   port: z.number().int().min(1).max(65535).default(9369),
   // The window's assistant: the Claude Code it runs headless, and its model (an alias or a model's full name)
   claude: z.string().min(1).default("claude"),
-  model: z.string().min(1).default("sonnet")
+  model: z.string().min(1).default("sonnet"),
+  // The provider the window is shared over the internet through (src/share/tunnels.ts)
+  tunnel: z.enum(TUNNEL_IDS).default("ngrok")
 });
 function folderOf(name) {
   const folder = name.normalize("NFKD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLocaleLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -182,16 +185,22 @@ async function loadConfig(from) {
     }
     const parent = dirname(folder);
     if (parent === folder) {
-      throw new Error(`No ${CONFIG_FILE} in ${resolve(from)} or above it`);
+      throw new Error(
+        `No ${CONFIG_FILE} in ${resolve(from)} or above it: erdraft init sets the project up`
+      );
     }
     folder = parent;
   }
 }
 
-// src/core/install-skill.ts
-import { mkdir, readFile as readFile3, writeFile } from "fs/promises";
-import { dirname as dirname2, join as join3 } from "path";
-var SKILL_PATH = join3(".claude", "skills", "erdraft", "SKILL.md");
+// src/core/init-project.ts
+import { z as z3 } from "zod";
+import { join as join6, resolve as resolve3, relative, basename as basename2 } from "path";
+import { existsSync } from "fs";
+import { writeFile as writeFile3 } from "fs/promises";
+
+// src/core/read-if-there.ts
+import { readFile as readFile3 } from "fs/promises";
 async function readIfThere2(path) {
   try {
     return await readFile3(path, "utf8");
@@ -202,9 +211,122 @@ async function readIfThere2(path) {
     throw error;
   }
 }
+
+// src/core/find-schema.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
+var DRIZZLE_CONFIGS = [
+  "drizzle.config.ts",
+  "drizzle.config.mts",
+  "drizzle.config.cts",
+  "drizzle.config.js",
+  "drizzle.config.mjs",
+  "drizzle.config.cjs",
+  "drizzle.config.json"
+];
+var USUAL_SCHEMAS = [
+  "src/db/schema.ts",
+  "src/db/schema/index.ts",
+  "src/server/db/schema.ts",
+  "src/lib/db/schema.ts",
+  "src/schema.ts",
+  "db/schema.ts",
+  "lib/db/schema.ts",
+  "drizzle/schema.ts"
+];
+var WORKSPACE_FOLDERS = ["packages", "apps"];
+var SCHEMA_KEY = /(?:^|[\s{,])["']?schema["']?\s*:\s*(["'`])([^"'`*]+)\1/;
+async function moduleAt(path) {
+  const found = await stat2(path).catch(() => void 0);
+  if (found?.isFile()) {
+    return path;
+  }
+  if (found?.isDirectory()) {
+    return moduleAt(join3(path, "index.ts"));
+  }
+  return void 0;
+}
+async function schemaIn(folder) {
+  for (const name of DRIZZLE_CONFIGS) {
+    const text2 = await readIfThere2(join3(folder, name));
+    const path = text2?.match(SCHEMA_KEY)?.[2];
+    const found = path && await moduleAt(resolve2(folder, path));
+    if (found) {
+      return found;
+    }
+  }
+  for (const path of USUAL_SCHEMAS) {
+    const found = await moduleAt(join3(folder, path));
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+async function workspacesOf(root) {
+  const folders = [];
+  for (const parent of WORKSPACE_FOLDERS) {
+    const entries = await readdir(join3(root, parent), {
+      withFileTypes: true
+    }).catch(() => []);
+    const names = entries.filter((each) => each.isDirectory()).map((each) => each.name).sort();
+    for (const name of names) {
+      folders.push(join3(root, parent, name));
+    }
+  }
+  return folders;
+}
+async function findSchema(root) {
+  for (const folder of [root, ...await workspacesOf(root)]) {
+    const found = await schemaIn(folder);
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+
+// src/core/add-mcp-server.ts
+import { z as z2 } from "zod";
+import { join as join4 } from "path";
+import { writeFile } from "fs/promises";
+var MCP_FILE = ".mcp.json";
+var ERDRAFT_SERVER = { command: "npx", args: ["-y", "erdraft", "mcp"] };
+var mcpFile = z2.looseObject({
+  mcpServers: z2.record(z2.string(), z2.unknown()).optional()
+});
+function parsed2(text2) {
+  try {
+    return mcpFile.parse(JSON.parse(text2));
+  } catch (error) {
+    throw new Error(
+      `${MCP_FILE} is not one Erdraft can add to: ${error instanceof z2.ZodError ? z2.prettifyError(error) : String(error)}`
+    );
+  }
+}
+async function addMcpServer(root) {
+  const path = join4(root, MCP_FILE);
+  const text2 = await readIfThere2(path);
+  const file = text2 === void 0 ? {} : parsed2(text2);
+  if (file.mcpServers?.erdraft !== void 0) {
+    return { path, added: false };
+  }
+  const servers = { ...file.mcpServers, erdraft: ERDRAFT_SERVER };
+  await writeFile(
+    path,
+    `${JSON.stringify({ ...file, mcpServers: servers }, null, 2)}
+`
+  );
+  return { path, added: true };
+}
+
+// src/core/install-skill.ts
+import { mkdir, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join5 } from "path";
+var SKILL_PATH = join5(".claude", "skills", "erdraft", "SKILL.md");
 async function installSkill(root, source, force = false) {
-  const path = join3(root, SKILL_PATH);
-  const skill = await readFile3(source, "utf8");
+  const path = join5(root, SKILL_PATH);
+  const skill = await readFile4(source, "utf8");
   const there = await readIfThere2(path);
   if (there === skill) {
     return { path, written: false };
@@ -215,16 +337,108 @@ async function installSkill(root, source, force = false) {
     );
   }
   await mkdir(dirname2(path), { recursive: true });
-  await writeFile(path, skill);
+  await writeFile2(path, skill);
   return { path, written: true };
 }
 
+// src/core/init-project.ts
+var packageFile = z3.looseObject({
+  name: z3.string().min(1).optional(),
+  dependencies: z3.record(z3.string(), z3.string()).optional(),
+  devDependencies: z3.record(z3.string(), z3.string()).optional()
+});
+var INSTALLS = [
+  ["pnpm-workspace.yaml", "pnpm add -D -w erdraft"],
+  ["pnpm-lock.yaml", "pnpm add -D erdraft"],
+  ["bun.lock", "bun add -d erdraft"],
+  ["bun.lockb", "bun add -d erdraft"],
+  ["yarn.lock", "yarn add -D erdraft"]
+];
+async function packageOf(root) {
+  const text2 = await readIfThere2(join6(root, "package.json")) ?? "{}";
+  try {
+    return packageFile.parse(JSON.parse(text2));
+  } catch {
+    return {};
+  }
+}
+async function schemaOf(root, given) {
+  const path = given === void 0 ? await findSchema(root) : resolve3(root, given);
+  if (path === void 0) {
+    throw new Error(
+      "Found no Drizzle schema here: erdraft init <the module that exports every table>"
+    );
+  }
+  if (!existsSync(path)) {
+    throw new Error(`There is no ${given}`);
+  }
+  return relative(root, path);
+}
+function installOf(root) {
+  const found = INSTALLS.find(([file]) => existsSync(join6(root, file)));
+  return found ? found[1] : "npm install --save-dev erdraft";
+}
+async function initProject(options) {
+  const { root, out } = options;
+  const project = await packageOf(root);
+  if (existsSync(join6(root, CONFIG_FILE)) && !options.force) {
+    out(`Kept ${CONFIG_FILE}, already here (--force writes it again).`);
+  } else {
+    const schema = await schemaOf(root, options.schema);
+    const name = options.name ?? project.name ?? basename2(root);
+    await writeFile3(
+      join6(root, CONFIG_FILE),
+      `${JSON.stringify({ name, schema }, null, 2)}
+`
+    );
+    out(`Wrote ${CONFIG_FILE}: ${name}, its schema ${schema}.`);
+  }
+  const mcp = await addMcpServer(root);
+  out(
+    mcp.added ? `Added Erdraft's MCP to ${MCP_FILE}.` : `${MCP_FILE} has Erdraft's MCP already.`
+  );
+  const skill = await installSkill(root, options.skill, options.force);
+  out(
+    skill.written ? `Wrote Erdraft's skill to ${relative(root, skill.path)}.` : `Erdraft's skill is in ${relative(root, skill.path)} already.`
+  );
+  const config = await loadConfig(root);
+  const [database] = config.databases;
+  const base = await readSchema(config, database, storeOf(config, database));
+  const installed = project.dependencies?.erdraft ?? project.devDependencies?.erdraft;
+  out(
+    `Read ${base.schema.tables.length} tables and ${base.schema.enums.length} enums from ${base.source}.`
+  );
+  const studio = [
+    "npx erdraft studio",
+    `opens the window, at http://localhost:${config.port}`
+  ];
+  const steps = installed ? [studio] : [
+    [
+      installOf(root),
+      "keeps this version in the project, which npx erdraft then runs"
+    ],
+    studio
+  ];
+  const width = Math.max(...steps.map(([command2]) => command2.length));
+  out(
+    [
+      "",
+      "Next:",
+      ...steps.map(([command2, what]) => `  ${command2.padEnd(width)}   ${what}`),
+      '  Then, in a new Claude Code session with its MCP approved, ask for a draft: "propose two ways to tag projects"'
+    ].join("\n")
+  );
+}
+
 // src/cli/run.ts
 var HELP = `erdraft: a project's data model, drafted with an agent while a person watches
 
 Usage: erdraft <command> [options] [--database <id>]
        erdraft --version
 
+  init [<schema>] [--name <name>] [--force]
+                              Set the project up: .erdraft.json (its Drizzle schema found, or the one given), the MCP
+                              in .mcp.json, the skill for its agents
   studio                      Open the window (the diagram, live)
   mcp                         Serve the MCP on stdin and stdout, for an agent
   read                        Read the schema again from the code
@@ -248,11 +462,31 @@ Usage: erdraft <command> [options] [--database <id>]
 
 A command works on the database chosen last (use), or on the one --database names. The nearest .erdraft.json says
 where the databases' schemas and their drafts are.`;
+var COMMANDS = /* @__PURE__ */ new Set([
+  "init",
+  "studio",
+  "mcp",
+  "read",
+  "tables",
+  "table",
+  "drafts",
+  "draft",
+  "propose",
+  "revise",
+  "show",
+  "wait",
+  "adopt",
+  "discard",
+  "delete",
+  "databases",
+  "install-skill",
+  "use"
+]);
 async function operationsFrom(path, options) {
   if (path === void 0) {
     return void 0;
   }
-  const text2 = path === "-" ? await options.stdin() : await readFile4(resolve2(options.cwd, path), "utf8");
+  const text2 = path === "-" ? await options.stdin() : await readFile5(resolve4(options.cwd, path), "utf8");
   return JSON.parse(text2);
 }
 function required(value, what) {
@@ -276,6 +510,7 @@ async function command(argv, options) {
       database: { type: "string" },
       seconds: { type: "string" },
       force: { type: "boolean" },
+      name: { type: "string" },
       help: { type: "boolean", short: "h" },
       version: { type: "boolean", short: "v" }
     }
@@ -289,6 +524,19 @@ async function command(argv, options) {
     options.out(HELP);
     return;
   }
+  if (!COMMANDS.has(name)) {
+    throw new Error(`Unknown command "${name}". Run erdraft --help`);
+  }
+  if (name === "init") {
+    return initProject({
+      root: options.cwd,
+      skill: options.skill,
+      schema: argument,
+      name: values.name,
+      force: values.force,
+      out: options.out
+    });
+  }
   const config = await loadConfig(options.cwd);
   const database = values.database ? databaseOf(config, values.database) : await currentDatabase(config);
   const drafts = storeOf(config, database);
@@ -301,7 +549,7 @@ async function command(argv, options) {
       draft ? (await drafts.draft(draft)).operations : []
     );
   }
-  async function schemaOf(draft) {
+  async function schemaOf2(draft) {
     return (await readOf(draft)).diff;
   }
   switch (name) {
@@ -318,11 +566,11 @@ async function command(argv, options) {
       return;
     }
     case "tables":
-      options.out(describeTables(await schemaOf(values.draft)));
+      options.out(describeTables(await schemaOf2(values.draft)));
       return;
     case "table": {
       const tableName = required(argument, "the table\u2019s name");
-      const diff = await schemaOf(values.draft);
+      const diff = await schemaOf2(values.draft);
       const table = diff.tables.find((each) => each.name === tableName);
       if (!table) {
         throw new Error(`There is no table "${tableName}"`);
@@ -374,7 +622,7 @@ async function command(argv, options) {
     }
     case "show": {
       const draft = values.schema ? null : values.draft;
-      const diff = await schemaOf(draft ?? void 0);
+      const diff = await schemaOf2(draft ?? void 0);
       if (argument && !diff.tables.some((each) => each.name === argument)) {
         throw new Error(`There is no table "${argument}"`);
       }
@@ -447,10 +695,7 @@ async function command(argv, options) {
         required(argument, "the database\u2019s id")
       );
       options.out(`Working on ${chosen.name}.`);
-      return;
     }
-    default:
-      throw new Error(`Unknown command "${name}". Run erdraft --help`);
   }
 }
 var ERROR_NAME = /^\w*Error(?: \[\w+\])?: /;
@@ -460,7 +705,7 @@ async function run(argv, options) {
     return 0;
   } catch (error) {
     options.err(
-      error instanceof z2.ZodError ? z2.prettifyError(error) : String(error).replace(ERROR_NAME, "")
+      error instanceof z4.ZodError ? z4.prettifyError(error) : String(error).replace(ERROR_NAME, "")
     );
     return 1;
   }
@@ -469,17 +714,23 @@ async function run(argv, options) {
 // bin/erdraft.ts
 var WINDOW = fileURLToPath(new URL("./window", import.meta.url));
 async function listen(config) {
-  if (existsSync(join4(WINDOW, "index.html"))) {
+  if (existsSync2(join7(WINDOW, "index.html"))) {
     return serveWindow(config, WINDOW);
   }
   const [{ createServer: createServer3 }, { default: studioConfig }] = await Promise.all([
     import("vite"),
-    import("./studio-config-TIVT4MNY.js")
+    import("./studio-config-TCMRAVMR.js")
   ]);
   const server = await createServer3(studioConfig(config));
   await server.listen();
   return server.httpServer;
 }
+process.stdout.on("error", (error) => {
+  if (error.code !== "EPIPE") {
+    throw error;
+  }
+  process.exit(0);
+});
 var code = await run(process.argv.slice(2), {
   cwd: process.cwd(),
   skill: fileURLToPath(new URL("../skill/SKILL.md", import.meta.url)),

package/dist/{studio-config-TIVT4MNY.js → studio-config-TCMRAVMR.js}

@@ -1,6 +1,6 @@
 import {
   createApi
-} from "./chunk-SSLBX2OF.js";
+} from "./chunk-IQ5YYSCP.js";
 import "./chunk-VSN3XJPO.js";
 
 // src/server/studio-config.ts