create-graphene 0.0.16

package/README.md

@@ -0,0 +1,7 @@
+# `create-graphene`
+
+Scaffolds a new Graphene project.
+
+```bash
+npm create graphene
+```

package/bin.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import {access} from 'node:fs/promises'
+import {dirname, join} from 'node:path'
+import {fileURLToPath} from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const devCli = join(__dirname, 'cli.ts')
+
+let hasDevCli = await access(devCli).then(
+  () => true,
+  () => false,
+)
+if (hasDevCli) {
+  await import('./cli.ts')
+} else {
+  await import('./dist/cli.js')
+}

package/dist/cli.js

@@ -0,0 +1,526 @@
+// cli.ts
+import process from "node:process";
+
+// create.ts
+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";
+
+// ../cli/package.json
+var package_default = {
+  name: "@graphenedata/cli",
+  version: "0.0.16",
+  private: true,
+  license: "Elastic-2.0",
+  author: "Graphene Systems Inc",
+  bin: {
+    graphene: "./bin.js"
+  },
+  files: [
+    "dist",
+    "bin.js",
+    "package.json",
+    "LICENSE.md",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  type: "module",
+  main: "bin.js",
+  types: "dist/index.d.ts",
+  exports: {
+    "./ui": {
+      browser: "./dist/ui/web.js"
+    }
+  },
+  scripts: {
+    build: "rm -rf dist && rm -f *.tgz && node ./esbuild.mjs",
+    test: "vitest run cli --root ..",
+    "test-one": "node ../scripts/turboTest.js",
+    prepack: "pnpm run build"
+  },
+  dependencies: {
+    "@graphenedata/lang": "workspace:*",
+    "@graphenedata/ui": "workspace:*",
+    "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    chalk: "^5.3.0",
+    "ci-info": "^4.4.0",
+    "cli-table3": "^0.6.3",
+    commander: "^11.0.0",
+    dotenv: "^17.2.3",
+    entities: "^4.5.0",
+    "fs-extra": "11.2.0",
+    "js-yaml": "^3.14.2",
+    json5: "^2.2.3",
+    mdsvex: "^0.12.6",
+    "sanitize-html": "^2.17.0",
+    unified: "^11.0.5",
+    "unist-util-visit": "4.1.2",
+    vite: "7.3.2",
+    ws: "^8.18.0"
+  },
+  devDependencies: {
+    "@clickhouse/client": "^1.18.2",
+    "@duckdb/node-api": "1.3.2-alpha.26",
+    "@google-cloud/bigquery": "^8.2.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.0.0",
+    "@types/sanitize-html": "^2.16.0",
+    "@types/ws": "^8.18.1",
+    esbuild: "^0.27.2",
+    "snowflake-sdk": "2.4.0",
+    vitest: "4.0.18",
+    "vscode-languageserver-types": "^3.17.0"
+  },
+  peerDependencies: {
+    "@clickhouse/client": "^1.18.2",
+    "@duckdb/node-api": "1.3.2-alpha.26",
+    "@google-cloud/bigquery": "^8.2.0",
+    "snowflake-sdk": "2.4.0"
+  },
+  peerDependenciesMeta: {
+    "@clickhouse/client": {
+      optional: true
+    },
+    "@duckdb/node-api": {
+      optional: true
+    },
+    "@google-cloud/bigquery": {
+      optional: true
+    },
+    "snowflake-sdk": {
+      optional: true
+    }
+  },
+  engines: {
+    node: ">=20"
+  }
+};
+
+// create.ts
+var packageJson = await readCreatePackageJson();
+var cliManifest = package_default;
+async function readCreatePackageJson() {
+  try {
+    return JSON.parse(await readFile(new URL("./package.json", import.meta.url), "utf8"));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    return JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+  }
+}
+var CreateCancelled = class extends Error {
+  constructor() {
+    super("Create canceled");
+  }
+};
+function parseArgs(argv) {
+  let options = { yes: false, install: true, 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") {
+      options.yes = true;
+      continue;
+    }
+    if (arg === "--no-install") {
+      options.install = false;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+    if (arg === "--name") {
+      if (!argv[i + 1]) throw new Error("--name requires a value");
+      options.name = argv[++i];
+      continue;
+    }
+    if (arg.startsWith("--name=")) {
+      options.name = arg.slice("--name=".length);
+      continue;
+    }
+    if (!options.targetDir && !arg.startsWith("-")) {
+      options.targetDir = arg;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  return options;
+}
+function defaultProjectName(targetDir) {
+  let raw = path2.basename(targetDir || "graphene-app");
+  let normalized = raw.toLowerCase().trim().replaceAll(/[^a-z0-9._-]+/g, "-").replaceAll(/^-+|-+$/g, "");
+  return normalized || "graphene-app";
+}
+function detectPackageManager(env = {}) {
+  let userAgent = env.npm_config_user_agent || env.NPM_CONFIG_USER_AGENT || "";
+  let userAgentMatch = userAgent.match(/(?:^|\s)(npm|pnpm|yarn|bun)\/([^\s]+)/);
+  if (userAgentMatch) return { name: userAgentMatch[1], version: userAgentMatch[2] };
+  let execPath = path2.basename(env.npm_execpath || env.NPM_EXEC_PATH || "").toLowerCase();
+  if (execPath.includes("pnpm")) return { name: "pnpm" };
+  if (execPath.includes("yarn")) return { name: "yarn" };
+  if (execPath.includes("bun")) return { name: "bun" };
+  return { name: "npm" };
+}
+function renderTemplate({ answers, cliVersion }) {
+  let graphene = { dialect: answers.database };
+  if (answers.defaultNamespace) graphene.defaultNamespace = answers.defaultNamespace;
+  if (answers.database === "duckdb") {
+    if (answers.duckdbPath) graphene.duckdb = { path: answers.duckdbPath };
+  } else if (answers.database === "snowflake") {
+    graphene.snowflake = { account: answers.snowflakeAccount || "", username: answers.snowflakeUsername || "" };
+  } else {
+    graphene.bigquery = { projectId: answers.bigqueryProjectId || "" };
+  }
+  let pkg = {
+    name: answers.projectName,
+    version: "0.0.1",
+    packageManager: answers.packageManager?.version ? `${answers.packageManager.name}@${answers.packageManager.version}` : void 0,
+    scripts: {
+      graphene: "graphene",
+      serve: "graphene serve",
+      compile: "graphene compile",
+      run: "graphene run"
+    },
+    dependencies: {
+      "@graphenedata/cli": cliVersion
+    },
+    graphene
+  };
+  if (!pkg.packageManager) delete pkg.packageManager;
+  let warehouseClient = getWarehouseClient(answers.database);
+  pkg.dependencies[warehouseClient] = getWarehouseClientVersion(warehouseClient);
+  let files = {
+    "package.json": JSON.stringify(pkg, null, 2) + "\n",
+    ".gitignore": ["node_modules", ".env", "*.duckdb"].join("\n") + "\n",
+    "AGENTS.md": renderAgents(answers),
+    "index.md": renderIndex(answers)
+  };
+  if (answers.packageManager?.name === "yarn") files[".yarnrc.yml"] = "nodeLinker: node-modules\n";
+  let envFile = renderEnvFile(answers);
+  if (envFile) files[".env"] = envFile;
+  return files;
+}
+function grapheneCommand(packageManager, args) {
+  if (packageManager?.name === "pnpm") return `pnpm graphene ${args}`;
+  if (packageManager?.name === "yarn") return `yarn graphene ${args}`;
+  if (packageManager?.name === "bun") return `bun run graphene ${args}`;
+  return `npx graphene ${args}`;
+}
+function renderAgents(answers) {
+  return [
+    "## Graphene Reference",
+    "",
+    `Assume all ${databaseLabel(answers.database)} functions are available when writing GSQL.`,
+    "",
+    "Common commands:",
+    "",
+    `- ${grapheneCommand(answers.packageManager, "check")} - check the project for syntax and analysis errors`,
+    `- ${grapheneCommand(answers.packageManager, "run index.md")} - execute the index page`,
+    `- ${grapheneCommand(answers.packageManager, "serve --bg")} - start or restart the local dev server`
+  ].join("\n") + "\n";
+}
+function databaseLabel(database) {
+  if (database === "snowflake") return "Snowflake";
+  if (database === "bigquery") return "BigQuery";
+  return "DuckDB";
+}
+function renderIndex(answers) {
+  return [`# ${answers.projectName}`, "", `This Graphene project is configured for ${databaseLabel(answers.database)}.`, "", "Start by adding models and queries to this project."].join("\n") + "\n";
+}
+function renderEnvFile(answers) {
+  let lines = [];
+  if (answers.database === "snowflake") {
+    lines.push(`SNOWFLAKE_PRI_KEY_PATH=${answers.snowflakeKeyPath || ""}`);
+    if (answers.snowflakePassphrase) lines.push(`SNOWFLAKE_PRI_PASSPHRASE=${answers.snowflakePassphrase}`);
+  } else if (answers.database === "bigquery") {
+    lines.push(`GOOGLE_APPLICATION_CREDENTIALS=${answers.bigqueryKeyPath || ""}`);
+  }
+  return lines.length ? lines.join("\n") + "\n" : null;
+}
+async function ensureEmptyDir(targetDir) {
+  let entries = await readdir(targetDir).catch((err) => {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  });
+  if (entries === null) return;
+  if (entries.length > 0) throw new Error(`Target directory is not empty: ${targetDir}`);
+}
+async function writeTemplate(targetDir, files) {
+  await mkdir(targetDir, { recursive: true });
+  for (let [relativePath, contents] of Object.entries(files)) {
+    let filePath = path2.join(targetDir, relativePath);
+    await mkdir(path2.dirname(filePath), { recursive: true });
+    await writeFile(filePath, contents);
+  }
+}
+function printHelp(stdout) {
+  stdout.write(
+    [
+      "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"
+    ].join("\n") + "\n"
+  );
+}
+function promptOptions(input, output) {
+  return { input, output };
+}
+function unwrapPrompt(value) {
+  if (clack.isCancel(value)) throw new CreateCancelled();
+  return value;
+}
+function validateRequired(message) {
+  return (value) => {
+    if (typeof value !== "string" || !value.trim()) return message;
+  };
+}
+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 }) {
+  while (true) {
+    let filePath = unwrapPrompt(
+      await clack.path({
+        message,
+        validate: (value) => validateFileExtension(value, expectedExtension),
+        ...promptOptions(input, output)
+      })
+    );
+    try {
+      await access(filePath);
+      return filePath;
+    } catch {
+      clack.log.error(`File not found: ${filePath}`, { output });
+    }
+  }
+}
+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";
+  return "@duckdb/node-api";
+}
+function getWarehouseClientVersion(packageName) {
+  let version = cliManifest.peerDependencies?.[packageName];
+  if (!version) throw new Error(`Missing ${packageName} peerDependency in cli/package.json`);
+  return version;
+}
+async function collectAnswers({ options, packageManager, input, output }) {
+  if (options.yes) {
+    let targetDir2 = options.targetDir || "graphene-app";
+    return {
+      targetDir: targetDir2,
+      projectName: options.name || defaultProjectName(targetDir2),
+      packageManager,
+      database: "duckdb",
+      skillLinkTarget: "none"
+    };
+  }
+  let targetDir = options.targetDir;
+  if (!targetDir) {
+    targetDir = unwrapPrompt(
+      await clack.text({
+        message: "Project name",
+        placeholder: "my-analytics",
+        initialValue: "graphene-app",
+        validate: validateRequired("Project name is required"),
+        ...promptOptions(input, output)
+      })
+    );
+  }
+  let projectName = options.name || defaultProjectName(targetDir);
+  let database = unwrapPrompt(
+    await clack.select({
+      message: "Database",
+      options: [
+        { value: "duckdb", label: "DuckDB (local file)" },
+        { value: "snowflake", label: "Snowflake" },
+        { value: "bigquery", label: "BigQuery" }
+      ],
+      ...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 (options.install) {
+    answers.skillLinkTarget = unwrapPrompt(
+      await clack.select({
+        message: "Add the Graphene skill for agents?",
+        options: [
+          { value: ".agents", label: ".agents/skills/graphene" },
+          { value: ".claude", label: ".claude/skills/graphene" },
+          { value: "none", label: "Skip" }
+        ],
+        ...promptOptions(input, output)
+      })
+    );
+  }
+  return answers;
+}
+function installCommand(packageManager) {
+  if (packageManager.name === "npm") return ["npm", ["install", "--no-fund"]];
+  return [packageManager.name, ["install"]];
+}
+async function installDeps(targetDir, packageManager, env) {
+  let [command, args] = installCommand(packageManager);
+  let task = clack.taskLog({ title: `Installing dependencies with ${packageManager.name}...`, retainLog: true });
+  let child = spawn(command, args, {
+    cwd: targetDir,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...env, FORCE_COLOR: "1", npm_config_color: "always" }
+  });
+  if (!child.stdout || !child.stderr) throw new Error(`${command} install pipes were not created`);
+  let stderr = "";
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  let buffers = { stdout: "", stderr: "" };
+  let forward = (chunk, stream) => {
+    let next = buffers[stream] + chunk;
+    let lines = next.split(/\r?\n/);
+    buffers[stream] = lines.pop() || "";
+    for (let line of lines) {
+      if (!line.trim()) continue;
+      task.message(line);
+    }
+  };
+  let flush = (stream) => {
+    let line = buffers[stream];
+    if (!line.trim()) return;
+    task.message(line);
+  };
+  child.stdout.on("data", (chunk) => forward(String(chunk), "stdout"));
+  child.stderr.on("data", (chunk) => {
+    let text2 = String(chunk);
+    stderr += text2;
+    forward(text2, "stderr");
+  });
+  let code = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (exitCode) => resolve(exitCode ?? 1));
+  });
+  flush("stdout");
+  flush("stderr");
+  if (code === 0) task.success("Dependencies installed", { showLog: true });
+  else task.error(`${command} install failed`, { showLog: true });
+  return { code, stderr };
+}
+async function symlinkGrapheneSkill(targetDir, skillLinkTarget) {
+  if (skillLinkTarget === "none") return;
+  let sourcePath = path2.join(targetDir, "node_modules/@graphenedata/cli/dist/skills/graphene");
+  let linkPath = path2.join(targetDir, skillLinkTarget, "skills/graphene");
+  let relativeSourcePath = path2.relative(path2.dirname(linkPath), sourcePath);
+  await mkdir(path2.dirname(linkPath), { recursive: true });
+  try {
+    await symlink(relativeSourcePath, linkPath, "dir");
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+    let existingTarget = await readlink(linkPath).catch(() => null);
+    if (existingTarget === relativeSourcePath) return;
+    throw new Error(`Cannot link Graphene skill because ${linkPath} already exists`, { cause: err });
+  }
+}
+async function runCreate({ argv, cwd, env = {}, stdin, stdout }) {
+  let options = parseArgs(argv);
+  if (options.help) {
+    printHelp(stdout);
+    return;
+  }
+  clack.intro("Create a new Graphene project", { output: stdout });
+  try {
+    let packageManager = detectPackageManager(env);
+    let answers = await collectAnswers({ options, packageManager, input: stdin, output: stdout });
+    let targetDir = path2.resolve(cwd, answers.targetDir);
+    await ensureEmptyDir(targetDir);
+    let cliVersion = packageJson.version || "0.0.15";
+    await writeTemplate(targetDir, renderTemplate({ answers, cliVersion }));
+    if (options.install) {
+      let install = await installDeps(targetDir, packageManager, env);
+      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 });
+  } catch (err) {
+    if (err instanceof CreateCancelled) {
+      clack.cancel("Operation cancelled.", { output: stdout });
+      return;
+    }
+    throw err;
+  }
+}
+
+// cli.ts
+await runCreate({
+  argv: process.argv.slice(2),
+  cwd: process.cwd(),
+  env: process.env,
+  stdin: process.stdin,
+  stdout: process.stdout,
+  stderr: process.stderr
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "create-graphene",
+  "version": "0.0.16",
+  "license": "Elastic-2.0",
+  "author": "Graphene Systems Inc",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/graphene-data/graphene.git",
+    "directory": "create"
+  },
+  "bin": {
+    "create-graphene": "./bin.js"
+  },
+  "files": [
+    "bin.js",
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf dist && node ./esbuild.mjs",
+    "test": "vitest run create --root ..",
+    "test-one": "node ../scripts/turboTest.js",
+    "prepack": "pnpm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.2.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.27.2"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  }
+}