create-graphene 0.0.16 → 0.0.18

package/dist/cli.js

@@ -6,14 +6,19 @@ import * as clack from "@clack/prompts";
 import { spawn } from "node:child_process";
 import { access, mkdir, readFile, readlink, readdir, symlink, writeFile } from "node:fs/promises";
 import path2 from "node:path";
+import { styleText } from "node:util";
 
 // ../cli/package.json
 var package_default = {
   name: "@graphenedata/cli",
-  version: "0.0.16",
+  version: "0.0.18",
   private: true,
   license: "Elastic-2.0",
   author: "Graphene Systems Inc",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/graphene-data/graphene.git"
+  },
   bin: {
     graphene: "./bin.js"
   },
@@ -53,6 +58,7 @@ var package_default = {
     json5: "^2.2.3",
     mdsvex: "^0.12.6",
     "sanitize-html": "^2.17.0",
+    svelte: "5.55.3",
     unified: "^11.0.5",
     "unist-util-visit": "4.1.2",
     vite: "7.3.2",
@@ -113,7 +119,7 @@ var CreateCancelled = class extends Error {
   }
 };
 function parseArgs(argv) {
-  let options = { yes: false, install: true, name: void 0, targetDir: void 0, help: false };
+  let options = { yes: false, install: true, skipCredentialValidation: false, name: void 0, targetDir: void 0, help: false };
   for (let i = 0; i < argv.length; i++) {
     let arg = argv[i];
     if (arg === "--yes" || arg === "-y") {
@@ -124,6 +130,10 @@ function parseArgs(argv) {
       options.install = false;
       continue;
     }
+    if (arg === "--skip-credential-validation") {
+      options.skipCredentialValidation = true;
+      continue;
+    }
     if (arg === "--help" || arg === "-h") {
       options.help = true;
       continue;
@@ -167,8 +177,10 @@ function renderTemplate({ answers, cliVersion }) {
     if (answers.duckdbPath) graphene.duckdb = { path: answers.duckdbPath };
   } else if (answers.database === "snowflake") {
     graphene.snowflake = { account: answers.snowflakeAccount || "", username: answers.snowflakeUsername || "" };
-  } else {
+  } else if (answers.database === "bigquery") {
     graphene.bigquery = { projectId: answers.bigqueryProjectId || "" };
+  } else {
+    graphene.clickhouse = { url: answers.clickhouseUrl || "", username: answers.clickhouseUsername || "" };
   }
   let pkg = {
     name: answers.projectName,
@@ -191,7 +203,7 @@ function renderTemplate({ answers, cliVersion }) {
   let files = {
     "package.json": JSON.stringify(pkg, null, 2) + "\n",
     ".gitignore": ["node_modules", ".env", "*.duckdb"].join("\n") + "\n",
-    "AGENTS.md": renderAgents(answers),
+    [agentsFileName(answers.skillLinkTarget)]: renderAgents(answers),
     "index.md": renderIndex(answers)
   };
   if (answers.packageManager?.name === "yarn") files[".yarnrc.yml"] = "nodeLinker: node-modules\n";
@@ -205,6 +217,10 @@ function grapheneCommand(packageManager, args) {
   if (packageManager?.name === "bun") return `bun run graphene ${args}`;
   return `npx graphene ${args}`;
 }
+function agentsFileName(skillLinkTarget) {
+  if (skillLinkTarget === ".claude") return "CLAUDE.md";
+  return "AGENTS.md";
+}
 function renderAgents(answers) {
   return [
     "## Graphene Reference",
@@ -221,6 +237,7 @@ function renderAgents(answers) {
 function databaseLabel(database) {
   if (database === "snowflake") return "Snowflake";
   if (database === "bigquery") return "BigQuery";
+  if (database === "clickhouse") return "ClickHouse";
   return "DuckDB";
 }
 function renderIndex(answers) {
@@ -233,6 +250,8 @@ function renderEnvFile(answers) {
     if (answers.snowflakePassphrase) lines.push(`SNOWFLAKE_PRI_PASSPHRASE=${answers.snowflakePassphrase}`);
   } else if (answers.database === "bigquery") {
     lines.push(`GOOGLE_APPLICATION_CREDENTIALS=${answers.bigqueryKeyPath || ""}`);
+  } else if (answers.database === "clickhouse") {
+    lines.push(`CLICKHOUSE_PASSWORD=${answers.clickhousePassword || ""}`);
   }
   return lines.length ? lines.join("\n") + "\n" : null;
 }
@@ -258,9 +277,10 @@ function printHelp(stdout) {
       "Usage: npm create graphene [target-dir] [-- --yes] [--name <project-name>] [--no-install]",
       "",
       "Options:",
-      "  -y, --yes        Skip prompts and accept defaults",
-      "  --name <name>    Set the generated package name",
-      "  --no-install     Skip dependency installation"
+      "  -y, --yes                      Skip prompts and accept defaults",
+      "  --name <name>                  Set the generated package name",
+      "  --no-install                   Skip dependency installation",
+      "  --skip-credential-validation   Skip warehouse credential validation"
     ].join("\n") + "\n"
   );
 }
@@ -280,11 +300,18 @@ function validateFileExtension(filePath, expectedExtension) {
   if (typeof filePath !== "string" || !filePath.trim()) return `Path to ${expectedExtension} file is required`;
   if (!filePath.endsWith(expectedExtension)) return `File must end with ${expectedExtension}`;
 }
-async function promptExistingFilePath({ message, expectedExtension, input, output }) {
+async function promptExistingFilePath({
+  message,
+  expectedExtension,
+  initialValue,
+  input,
+  output
+}) {
   while (true) {
     let filePath = unwrapPrompt(
       await clack.path({
         message,
+        initialValue,
         validate: (value) => validateFileExtension(value, expectedExtension),
         ...promptOptions(input, output)
       })
@@ -297,14 +324,10 @@ async function promptExistingFilePath({ message, expectedExtension, input, outpu
     }
   }
 }
-function namespacePlaceholder(database) {
-  if (database === "snowflake") return "MY_DB.ANALYTICS";
-  if (database === "bigquery") return "my-project.analytics";
-  return "analytics";
-}
 function getWarehouseClient(database) {
   if (database === "snowflake") return "snowflake-sdk";
   if (database === "bigquery") return "@google-cloud/bigquery";
+  if (database === "clickhouse") return "@clickhouse/client";
   return "@duckdb/node-api";
 }
 function getWarehouseClientVersion(packageName) {
@@ -312,6 +335,175 @@ function getWarehouseClientVersion(packageName) {
   if (!version) throw new Error(`Missing ${packageName} peerDependency in cli/package.json`);
   return version;
 }
+async function promptWarehouseCredentials(answers, input, output) {
+  if (answers.database === "snowflake") {
+    answers.snowflakeAccount = unwrapPrompt(
+      await clack.text({
+        message: "Snowflake account ID",
+        placeholder: "myorg-myaccount",
+        initialValue: answers.snowflakeAccount,
+        validate: validateRequired("Snowflake account ID is required"),
+        ...promptOptions(input, output)
+      })
+    );
+    answers.snowflakeUsername = unwrapPrompt(
+      await clack.text({
+        message: "Snowflake username",
+        placeholder: "graphene_user",
+        initialValue: answers.snowflakeUsername,
+        validate: validateRequired("Snowflake username is required"),
+        ...promptOptions(input, output)
+      })
+    );
+    answers.snowflakeKeyPath = await promptExistingFilePath({ message: "Path to .p8 key file", expectedExtension: ".p8", initialValue: answers.snowflakeKeyPath, input, output });
+    answers.snowflakePassphrase = unwrapPrompt(await clack.password({ message: "Key passphrase", ...promptOptions(input, output) }));
+    return;
+  }
+  if (answers.database === "bigquery") {
+    answers.bigqueryProjectId = unwrapPrompt(
+      await clack.text({
+        message: "GCP project ID",
+        placeholder: "my-project-123",
+        initialValue: answers.bigqueryProjectId,
+        validate: validateRequired("GCP project ID is required"),
+        ...promptOptions(input, output)
+      })
+    );
+    answers.bigqueryKeyPath = await promptExistingFilePath({
+      message: "Path to service account .json key file",
+      expectedExtension: ".json",
+      initialValue: answers.bigqueryKeyPath,
+      input,
+      output
+    });
+    return;
+  }
+  if (answers.database === "clickhouse") {
+    answers.clickhouseUrl = unwrapPrompt(
+      await clack.text({
+        message: "ClickHouse URL",
+        placeholder: "https://example.clickhouse.cloud:8443",
+        initialValue: answers.clickhouseUrl,
+        validate: validateRequired("ClickHouse URL is required"),
+        ...promptOptions(input, output)
+      })
+    );
+    answers.clickhouseUsername = unwrapPrompt(
+      await clack.text({
+        message: "ClickHouse username",
+        placeholder: "default",
+        initialValue: answers.clickhouseUsername,
+        validate: validateRequired("ClickHouse username is required"),
+        ...promptOptions(input, output)
+      })
+    );
+    answers.clickhousePassword = unwrapPrompt(
+      await clack.password({
+        message: "ClickHouse password",
+        validate: validateRequired("ClickHouse password is required"),
+        ...promptOptions(input, output)
+      })
+    );
+  }
+}
+async function collectWarehouseCredentials(answers, options, input, output) {
+  while (true) {
+    await promptWarehouseCredentials(answers, input, output);
+    if (options.skipCredentialValidation) return;
+    let result = await testWarehouseCredentials(answers, output);
+    if (result.ok) return;
+    clack.log.error(`${databaseLabel(answers.database)} credential validation failed: ${result.error}`, { output });
+    let action = unwrapPrompt(
+      await clack.select({
+        message: "How would you like to continue?",
+        options: [
+          { value: "edit", label: "Edit credentials" },
+          { value: "continue", label: "Continue anyway" }
+        ],
+        ...promptOptions(input, output)
+      })
+    );
+    if (action === "continue") return;
+  }
+}
+async function testWarehouseCredentials(answers, output) {
+  let task = clack.taskLog({ title: `Testing ${databaseLabel(answers.database)} credentials...`, retainLog: true, output });
+  try {
+    await withTimeout(runWarehouseCredentialTest(answers), 15e3, `${databaseLabel(answers.database)} credential validation timed out`);
+    task.success("Credentials validated");
+    return { ok: true };
+  } catch (err) {
+    task.error("Credential validation failed", { showLog: true });
+    return { ok: false, error: formatCredentialError(err) };
+  }
+}
+async function withTimeout(promise, ms, message) {
+  let timeout;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => reject(new Error(message)), ms);
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+function runWarehouseCredentialTest(answers) {
+  if (answers.database === "snowflake") return testSnowflakeCredentials(answers);
+  if (answers.database === "bigquery") return testBigQueryCredentials(answers);
+  if (answers.database === "clickhouse") return testClickHouseCredentials(answers);
+  return Promise.resolve();
+}
+async function testSnowflakeCredentials(answers) {
+  let snowflake = (await import("snowflake-sdk")).default;
+  snowflake.configure({ logLevel: "WARN", logFilePath: "/dev/null" });
+  let connection = snowflake.createConnection({
+    account: answers.snowflakeAccount,
+    username: answers.snowflakeUsername,
+    privateKeyPath: answers.snowflakeKeyPath,
+    privateKeyPass: answers.snowflakePassphrase,
+    authenticator: "SNOWFLAKE_JWT",
+    application: "Graphene"
+  });
+  try {
+    await new Promise((resolve, reject) => {
+      connection.connect((err) => err ? reject(err) : resolve());
+    });
+  } finally {
+    await new Promise((resolve) => {
+      connection.destroy(() => resolve());
+    }).catch(() => {
+    });
+  }
+}
+async function testBigQueryCredentials(answers) {
+  let { BigQuery } = await import("@google-cloud/bigquery");
+  let credentials = JSON.parse(await readFile(answers.bigqueryKeyPath || "", "utf8"));
+  let client = new BigQuery({ projectId: answers.bigqueryProjectId, credentials, userAgent: "Graphene" });
+  await client.createQueryJob({ query: "select 1", useLegacySql: false, dryRun: true });
+}
+async function testClickHouseCredentials(answers) {
+  let { createClient } = await import("@clickhouse/client");
+  let client = createClient({
+    url: answers.clickhouseUrl,
+    username: answers.clickhouseUsername,
+    password: answers.clickhousePassword,
+    database: answers.defaultNamespace || "default",
+    application: "Graphene"
+  });
+  try {
+    let result = await client.query({ query: "SELECT 1", format: "JSONEachRow" });
+    await result.json();
+  } finally {
+    await client.close();
+  }
+}
+function formatCredentialError(err) {
+  if (err instanceof Error && err.message) return err.message;
+  return String(err || "Unknown error");
+}
 async function collectAnswers({ options, packageManager, input, output }) {
   if (options.yes) {
     let targetDir2 = options.targetDir || "graphene-app";
@@ -340,74 +532,23 @@ async function collectAnswers({ options, packageManager, input, output }) {
     await clack.select({
       message: "Database",
       options: [
-        { value: "duckdb", label: "DuckDB (local file)" },
         { value: "snowflake", label: "Snowflake" },
-        { value: "bigquery", label: "BigQuery" }
+        { value: "bigquery", label: "BigQuery" },
+        { value: "clickhouse", label: "ClickHouse" },
+        { value: "duckdb", label: "DuckDB (local file)" }
       ],
       ...promptOptions(input, output)
     })
   );
-  let defaultNamespace = unwrapPrompt(
-    await clack.text({
-      message: "Default namespace (optional)",
-      placeholder: namespacePlaceholder(database),
-      ...promptOptions(input, output)
-    })
-  ).trim();
   let answers = {
     targetDir,
     projectName,
     packageManager,
     database,
-    defaultNamespace: defaultNamespace || void 0,
     skillLinkTarget: "none"
   };
-  if (database === "duckdb") {
-    answers.duckdbPath = unwrapPrompt(
-      await clack.text({
-        message: "Path to .duckdb file",
-        placeholder: "./data.duckdb",
-        validate(value) {
-          if (typeof value !== "string" || !value.trim()) return;
-          if (!value.endsWith(".duckdb")) return "DuckDB path must end with .duckdb";
-        },
-        ...promptOptions(input, output)
-      })
-    ).trim() || void 0;
-  } else if (database === "snowflake") {
-    answers.snowflakeAccount = unwrapPrompt(
-      await clack.text({
-        message: "Snowflake account ID",
-        placeholder: "myorg-myaccount",
-        validate: validateRequired("Snowflake account ID is required"),
-        ...promptOptions(input, output)
-      })
-    );
-    answers.snowflakeUsername = unwrapPrompt(
-      await clack.text({
-        message: "Snowflake username",
-        placeholder: "graphene_user",
-        validate: validateRequired("Snowflake username is required"),
-        ...promptOptions(input, output)
-      })
-    );
-    answers.snowflakeKeyPath = await promptExistingFilePath({ message: "Path to .p8 key file", expectedExtension: ".p8", input, output });
-    answers.snowflakePassphrase = unwrapPrompt(
-      await clack.password({
-        message: "Key passphrase",
-        ...promptOptions(input, output)
-      })
-    );
-  } else {
-    answers.bigqueryProjectId = unwrapPrompt(
-      await clack.text({
-        message: "GCP project ID",
-        placeholder: "my-project-123",
-        validate: validateRequired("GCP project ID is required"),
-        ...promptOptions(input, output)
-      })
-    );
-    answers.bigqueryKeyPath = await promptExistingFilePath({ message: "Path to service account .json key file", expectedExtension: ".json", input, output });
+  if (database !== "duckdb") {
+    await collectWarehouseCredentials(answers, options, input, output);
   }
   if (options.install) {
     answers.skillLinkTarget = unwrapPrompt(
@@ -505,7 +646,7 @@ async function runCreate({ argv, cwd, env = {}, stdin, stdout }) {
       if (install.code !== 0) throw new Error(install.stderr.trim() || `${packageManager.name} install failed with code ${install.code}`);
       await symlinkGrapheneSkill(targetDir, answers.skillLinkTarget);
     }
-    clack.outro("Done!", { output: stdout });
+    clack.outro(completionMessage(answers), { output: stdout });
   } catch (err) {
     if (err instanceof CreateCancelled) {
       clack.cancel("Operation cancelled.", { output: stdout });
@@ -514,6 +655,25 @@ async function runCreate({ argv, cwd, env = {}, stdin, stdout }) {
     throw err;
   }
 }
+function completionMessage(answers) {
+  if (answers.database !== "duckdb") return "Done!";
+  return [
+    "Done!",
+    "",
+    `For DuckDB, copy your ${color("cyan", ".duckdb")} file into the ${color("magenta", answers.projectName)} folder so Graphene can discover it.`,
+    "",
+    `If the duckdb file lives elsewhere, set the path in ${color("magenta", "package.json")}:`,
+    "",
+    color("gray", '"graphene": {'),
+    color("gray", '  "duckdb": {'),
+    color("gray", '    "path": "/path/to/example.duckdb"'),
+    color("gray", "  }"),
+    color("gray", "}")
+  ].join("\n");
+}
+function color(style, text2) {
+  return styleText(style, text2, { validateStream: false });
+}
 
 // cli.ts
 await runCreate({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-graphene",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "license": "Elastic-2.0",
   "author": "Graphene Systems Inc",
   "repository": {
@@ -25,7 +25,10 @@
     "prepack": "pnpm run build"
   },
   "dependencies": {
-    "@clack/prompts": "^1.2.0"
+    "@clack/prompts": "^1.2.0",
+    "@clickhouse/client": "^1.18.2",
+    "@google-cloud/bigquery": "^8.2.0",
+    "snowflake-sdk": "2.4.0"
   },
   "devDependencies": {
     "esbuild": "^0.27.2"