clivly 0.2.0 → 0.2.2

package/index.mjs

@@ -0,0 +1,960 @@
+#!/usr/bin/env node
+import { t as createClivlySDK } from "./sdk-BZUn6wzs.mjs";
+import { t as CANONICAL_FIELDS } from "./entity-config-DoR0khce.mjs";
+import "./mapping-score-BJNe0lFn.mjs";
+import { matchesConcept, requiredFieldsFor, scoreFieldMap, scoreRelationships, suggestCursorField, toFieldMap } from "./core-entity-heuristics.mjs";
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { createJiti } from "jiti";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { spawn } from "node:child_process";
+//#region src/render.ts
+function checkLine(ok, label, detail) {
+	return `  ${ok ? "✅" : "❌"} ${label}${detail ? ` — ${detail}` : ""}\n`;
+}
+//#endregion
+//#region src/connect.ts
+const REASON_HINT$1 = {
+	ok: "",
+	invalid_api_key: "The key was rejected (401). Check CLIVLY_API_KEY.",
+	forbidden: "The key lacks access (403).",
+	rate_limited: "Rate limited (429) — retry shortly.",
+	server_error: "Clivly returned a 5xx — retry shortly.",
+	client_error: "The request was rejected (4xx).",
+	network_error: "No response — check the network / apiUrl."
+};
+const defaultConnect$1 = (apiKey, apiUrl) => createClivlySDK({
+	apiKey,
+	apiUrl,
+	retry: { maxAttempts: 1 }
+}).connect();
+const defaultLoadConfig = async (path) => {
+	const mod = await createJiti(import.meta.url).import(path);
+	return mod.default ?? mod;
+};
+/**
+* `clivly connect` — a read-only pass/fail report: API key present → heartbeat
+* (real SDK connect, proving the cloud saw it) → config schema loadable →
+* trigger-URL note. Exit 0 iff the first three pass; a missing trigger URL warns
+* but does not fail (push-only setups are valid). Deps injectable for tests.
+*/
+async function runConnect(options) {
+	const out = options.out ?? ((line) => process.stdout.write(line));
+	out("\nClivly connect\n");
+	if (!options.apiKey) {
+		out(checkLine(false, "CLIVLY_API_KEY is not set."));
+		out("     Set it to your sk_live_… key from Settings → API keys.\n");
+		return 1;
+	}
+	const result = await (options.connectFn ?? defaultConnect$1)(options.apiKey, options.apiUrl);
+	if (result.ok) out(checkLine(true, `Heartbeat reached Clivly — org: ${result.org?.name ?? "(unnamed org)"}${result.org?.id ? ` (${result.org.id})` : ""}`));
+	else {
+		const status = result.status === null ? "no response" : `HTTP ${result.status}`;
+		out(checkLine(false, `Heartbeat failed (${result.reason}, ${status})`));
+		out(`     ${REASON_HINT$1[result.reason]}\n`);
+		return 1;
+	}
+	const path = resolve(options.cwd, options.configPath ?? "clivly.config.ts");
+	const loadConfig = options.loadConfigFn ?? defaultLoadConfig;
+	let config;
+	try {
+		config = await loadConfig(path);
+	} catch (error) {
+		out(checkLine(false, "Load clivly.config", error.message));
+		return 1;
+	}
+	const tables = Object.values(config.entities?.entities ?? {}).map((e) => e.source).filter((s) => Boolean(s));
+	if (tables.length === 0) {
+		out(checkLine(false, "No entities configured in clivly.config"));
+		return 1;
+	}
+	out(checkLine(true, `Schema: ${tables.length} entity table(s) — ${tables.join(", ")}`));
+	const triggerUrl = config.syncTrigger?.url;
+	if (triggerUrl) out(checkLine(true, `Trigger route configured — ${triggerUrl}`));
+	else {
+		out(checkLine(false, "No trigger URL — dashboard-triggered sync is not wired"));
+		out("     Set syncTrigger.url (CLIVLY_SYNC_TRIGGER_URL) to your public tick route.\n");
+	}
+	return 0;
+}
+//#endregion
+//#region src/detect.ts
+const FRAMEWORK_MARKERS = [
+	{
+		framework: "nextjs",
+		deps: ["next"]
+	},
+	{
+		framework: "tanstack-start",
+		deps: ["@tanstack/react-start"]
+	},
+	{
+		framework: "sveltekit",
+		deps: ["@sveltejs/kit"]
+	},
+	{
+		framework: "remix",
+		deps: ["@remix-run/react", "@remix-run/node"]
+	},
+	{
+		framework: "nuxt",
+		deps: ["nuxt"]
+	}
+];
+const ORM_MARKERS = [
+	{
+		orm: "drizzle",
+		deps: ["drizzle-orm"]
+	},
+	{
+		orm: "prisma",
+		deps: ["@prisma/client", "prisma"]
+	},
+	{
+		orm: "kysely",
+		deps: ["kysely"]
+	}
+];
+const FRAMEWORK_LABELS = {
+	nextjs: "Next.js",
+	"tanstack-start": "TanStack Start",
+	sveltekit: "SvelteKit",
+	remix: "Remix",
+	nuxt: "Nuxt",
+	unknown: "Unknown"
+};
+function detectFramework(deps) {
+	for (const { framework, deps: markers } of FRAMEWORK_MARKERS) if (markers.some((dep) => dep in deps)) return framework;
+	return "unknown";
+}
+function detectOrm(deps) {
+	for (const { orm, deps: markers } of ORM_MARKERS) if (markers.some((dep) => dep in deps)) return orm;
+	return "unknown";
+}
+const LOCKFILES = [
+	{
+		file: "pnpm-lock.yaml",
+		pm: "pnpm"
+	},
+	{
+		file: "bun.lockb",
+		pm: "bun"
+	},
+	{
+		file: "yarn.lock",
+		pm: "yarn"
+	},
+	{
+		file: "package-lock.json",
+		pm: "npm"
+	}
+];
+function detectPackageManager(cwd, fileExists = existsSync) {
+	for (const { file, pm } of LOCKFILES) if (fileExists(join(cwd, file))) return pm;
+	return "npm";
+}
+function addCommand(pm, packages) {
+	return {
+		command: pm,
+		args: [pm === "npm" ? "install" : "add", ...packages]
+	};
+}
+//#endregion
+//#region src/discover-schema.ts
+const WINDOWS_SEP = /\\/g;
+const MODULE_EXT = /\.(ts|js|mjs|cts|mts)$/;
+function toImportPath(schemaPath, cwd) {
+	const rel = relative(cwd, schemaPath).replace(WINDOWS_SEP, "/").replace(MODULE_EXT, "");
+	return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function loadSchemaModule(schemaPath, load) {
+	return load(isDirectory(schemaPath) ? join(schemaPath, "index.ts") : schemaPath);
+}
+function defaultLoader(cwd) {
+	const jiti = createJiti(pathToFileURL(join(cwd, "clivly.config.ts")).href);
+	return (specifier) => jiti.import(specifier);
+}
+async function loadPgCoreRuntime(load) {
+	try {
+		return await load("drizzle-orm/pg-core");
+	} catch {
+		return null;
+	}
+}
+function buildFkByColumn(pgCore, drizzle, table) {
+	const fkByColumn = /* @__PURE__ */ new Map();
+	if (!pgCore) return fkByColumn;
+	try {
+		for (const fk of pgCore.getTableConfig(table).foreignKeys) {
+			const ref = fk.reference();
+			const foreignTable = drizzle.getTableName(ref.foreignTable);
+			ref.columns.forEach((col, i) => {
+				const foreignCol = ref.foreignColumns[i];
+				if (foreignCol) fkByColumn.set(col.name, {
+					table: foreignTable,
+					column: foreignCol.name
+				});
+			});
+		}
+	} catch {}
+	return fkByColumn;
+}
+function toDiscoveredColumn(key, col, fkByColumn) {
+	let type;
+	try {
+		type = col.getSQLType?.();
+	} catch {
+		type = void 0;
+	}
+	const references = fkByColumn.get(col.name);
+	return {
+		key,
+		dbName: col.name,
+		isPrimary: Boolean(col.primary),
+		type,
+		nullable: !col.notNull,
+		...references ? { references } : {}
+	};
+}
+async function discoverSchema(opts) {
+	const load = opts.load ?? defaultLoader(opts.cwd);
+	const mod = await loadSchemaModule(opts.schemaPath, load);
+	const drizzle = await load("drizzle-orm");
+	const pgCore = await loadPgCoreRuntime(load);
+	const importPath = toImportPath(opts.schemaPath, opts.cwd);
+	const tables = [];
+	let db = null;
+	for (const [moduleKey, value] of Object.entries(mod)) {
+		if (drizzle.is(value, drizzle.Table)) {
+			const fkByColumn = buildFkByColumn(pgCore, drizzle, value);
+			const columns = Object.entries(drizzle.getTableColumns(value)).map(([key, col]) => toDiscoveredColumn(key, col, fkByColumn));
+			tables.push({
+				moduleKey,
+				tableName: drizzle.getTableName(value),
+				columns
+			});
+			continue;
+		}
+		if (db === null && value && typeof value.select === "function") db = {
+			moduleKey,
+			importPath
+		};
+	}
+	return {
+		tables,
+		importPath,
+		db
+	};
+}
+//#endregion
+//#region src/doctor.ts
+async function loadSdkFromConfig(path) {
+	const mod = await createJiti(import.meta.url).import(path);
+	const sdk = mod.default ?? mod;
+	if (typeof sdk.doctor !== "function") throw new Error("default export is not a Clivly SDK instance");
+	return sdk;
+}
+/**
+* `clivly doctor` — load the app's clivly.config, run the SDK's read-only setup
+* checks, and print a ✅/❌ checklist. Exit 0 when every check passes. `loadSdk`
+* and `out` are injectable for tests.
+*/
+async function runDoctor(options) {
+	const out = options.out ?? ((line) => process.stdout.write(line));
+	const path = resolve(options.cwd, options.configPath ?? "clivly.config.ts");
+	const loadSdk = options.loadSdk ?? loadSdkFromConfig;
+	out("\nClivly doctor\n");
+	let sdk;
+	try {
+		sdk = await loadSdk(path);
+	} catch (error) {
+		out(checkLine(false, "Load clivly.config", error.message));
+		out("     Expected clivly.config.ts at your app root with `export default createClivlySDK({...})`.\n");
+		return 1;
+	}
+	const report = await sdk.doctor();
+	for (const check of report.checks) {
+		if (check.skipped) {
+			out(`  ⚠️  ${check.name} — ${check.detail}\n`);
+			continue;
+		}
+		out(checkLine(check.ok, check.name, check.detail));
+	}
+	return report.ok ? 0 : 1;
+}
+//#endregion
+//#region src/env-file.ts
+function hasKey(content, key) {
+	return new RegExp(`^\\s*${key}=`, "m").test(content);
+}
+/**
+* Append only the `entries` whose key is absent, each preceded by its comment.
+* Existing keys/values are left exactly as-is. Returns the full new content.
+*/
+function appendEnvKeys(existing, entries) {
+	const missing = entries.filter((e) => !hasKey(existing, e.key));
+	if (missing.length === 0) return existing;
+	const block = missing.map((e) => `${e.comment ? `# ${e.comment}\n` : ""}${e.key}=`).join("\n");
+	return `${existing}${existing.length > 0 && !existing.endsWith("\n") ? "\n" : ""}${existing.length > 0 ? "\n" : ""}# Clivly\n${block}\n`;
+}
+//#endregion
+//#region src/install.ts
+const defaultRun = (command, args, cwd) => new Promise((resolvePromise, reject) => {
+	const child = spawn(command, args, {
+		cwd,
+		stdio: "inherit"
+	});
+	child.on("error", reject);
+	child.on("close", (code) => resolvePromise(code ?? 0));
+});
+const QUIET_FLAGS = {
+	npm: [
+		"--no-audit",
+		"--no-fund",
+		"--loglevel=error"
+	],
+	pnpm: ["--reporter=silent"],
+	yarn: [],
+	bun: []
+};
+/**
+* Best-effort install: run `<pm> add <packages>`. Never throws — returns
+* `{ ok, command }` so the caller can print the exact command on failure and
+* continue scaffolding.
+*/
+async function installPackages(options) {
+	const { command, args } = addCommand(options.pm, options.packages);
+	const fullArgs = [...args, ...QUIET_FLAGS[options.pm]];
+	const printable = `${command} ${fullArgs.join(" ")}`;
+	const run = options.run ?? defaultRun;
+	try {
+		return {
+			ok: await run(command, fullArgs, options.cwd) === 0,
+			command: printable
+		};
+	} catch {
+		return {
+			ok: false,
+			command: printable
+		};
+	}
+}
+//#endregion
+//#region src/is-entry.ts
+function isEntrypoint(argv1, moduleUrl, realpath = realpathSync) {
+	if (!argv1) return false;
+	const modulePath = fileURLToPath(moduleUrl);
+	const resolve = (path) => {
+		try {
+			return realpath(path);
+		} catch {
+			return path;
+		}
+	};
+	return resolve(argv1) === resolve(modulePath);
+}
+//#endregion
+//#region src/ping.ts
+const REASON_HINT = {
+	ok: "",
+	invalid_api_key: "The key was rejected (401). Check CLIVLY_API_KEY.",
+	forbidden: "The key is valid but lacks access to this org (403).",
+	rate_limited: "Rate limited (429). Wait a moment and retry.",
+	server_error: "Clivly returned a server error (5xx). Retry shortly.",
+	client_error: "The request was rejected (4xx). Check your configuration.",
+	network_error: "Could not reach Clivly. Check your network or --api-url."
+};
+const defaultConnect = (apiKey, apiUrl) => createClivlySDK({
+	apiKey,
+	apiUrl,
+	retry: { maxAttempts: 1 }
+}).connect();
+function resultLines(result) {
+	if (result.ok) {
+		const lines = [checkLine(true, "Connected to Clivly")];
+		if (result.org) {
+			const name = result.org.name ?? "(unnamed org)";
+			const id = result.org.id ? ` (${result.org.id})` : "";
+			lines.push(`     Org: ${name}${id}\n`);
+		}
+		return lines;
+	}
+	const status = result.status === null ? "no response" : `HTTP ${result.status}`;
+	return [checkLine(false, `Could not connect (${result.reason}, ${status})`), `     ${REASON_HINT[result.reason]}\n`];
+}
+/**
+* `clivly ping` — send one heartbeat with the configured key and print a clear
+* ✅/❌ with the resolved org or the failure reason. Verifies key + reachability
+* from the terminal with zero code. `connect`/`out` are injectable for tests.
+*/
+async function runPing(options) {
+	const out = options.out ?? ((line) => process.stdout.write(line));
+	out("\nClivly ping\n");
+	if (!options.apiKey) {
+		out(checkLine(false, "CLIVLY_API_KEY is not set."));
+		out("     Set it to your sk_live_… key from Settings → API keys.\n");
+		return 1;
+	}
+	const result = await (options.connect ?? defaultConnect)(options.apiKey, options.apiUrl);
+	for (const line of resultLines(result)) out(line);
+	return result.ok ? 0 : 1;
+}
+//#endregion
+//#region src/plan-init.ts
+function toScoredTable(table) {
+	return {
+		name: table.tableName,
+		columns: table.columns.map((c) => c.dbName),
+		columnsMeta: table.columns.map((c) => ({
+			name: c.dbName,
+			type: c.type,
+			nullable: c.nullable,
+			isPrimaryKey: c.isPrimary,
+			isForeignKey: c.references !== void 0,
+			...c.references ? { references: c.references } : {}
+		}))
+	};
+}
+function rankCandidates(tables, concept) {
+	return tables.map((t) => ({
+		t,
+		m: matchesConcept(t.tableName, concept)
+	})).filter((c) => Boolean(c.m)).sort((a, b) => Number(b.m.exact) - Number(a.m.exact)).map((c) => c.t);
+}
+function selectEntities(tables) {
+	const contactCands = rankCandidates(tables, "contact");
+	const companyCands = rankCandidates(tables, "company");
+	const contactNames = new Set(contactCands.map((t) => t.tableName));
+	const companyNames = new Set(companyCands.map((t) => t.tableName));
+	const contactExclusive = contactCands.filter((t) => !companyNames.has(t.tableName));
+	const companyExclusive = companyCands.filter((t) => !contactNames.has(t.tableName));
+	const contact = contactExclusive[0] ?? contactCands[0] ?? null;
+	const companyPreferred = companyExclusive[0] ?? companyCands[0] ?? null;
+	return {
+		contact,
+		company: companyPreferred && companyPreferred.tableName !== contact?.tableName ? companyPreferred : companyCands.find((t) => t.tableName !== contact?.tableName) ?? null
+	};
+}
+function chooseSyncFields(table, todos) {
+	const columnKeys = table.columns.map((c) => c.key);
+	let cursorField = suggestCursorField(columnKeys);
+	if (!cursorField) {
+		cursorField = table.columns.find((c) => c.isPrimary)?.key ?? columnKeys[0] ?? "id";
+		todos.push(`No updated_at-like column on "${table.tableName}" — using "${cursorField}" as the sync cursor. Confirm it is monotonic.`);
+	}
+	const pkCols = table.columns.filter((c) => c.isPrimary);
+	if (pkCols.length === 1) return {
+		cursorField,
+		idField: null
+	};
+	const idField = pkCols[0]?.key ?? columnKeys[0] ?? "id";
+	todos.push(`Table "${table.tableName}" has ${pkCols.length === 0 ? "no" : "a composite"} primary key — set idField (guessed "${idField}").`);
+	return {
+		cursorField,
+		idField
+	};
+}
+function buildEntity(table, concept, todos) {
+	const canonical = CANONICAL_FIELDS[concept];
+	const suggested = toFieldMap(scoreFieldMap(concept, toScoredTable(table)));
+	const fields = {};
+	for (const [key, column] of Object.entries(suggested)) if (canonical.includes(key)) fields[key] = column;
+	for (const required of requiredFieldsFor(concept)) if (!fields[required]) todos.push(`Could not map required ${concept} field "${required}" on "${table.tableName}" — add it manually.`);
+	const { cursorField, idField } = chooseSyncFields(table, todos);
+	return {
+		moduleKey: table.moduleKey,
+		tableName: table.tableName,
+		concept,
+		fields,
+		cursorField,
+		idField
+	};
+}
+function placeholderContact(todos) {
+	todos.push("No contact table detected. Filled in a placeholder — set `source`, `fields`, and the fromDrizzle table below, then run `clivly doctor`.");
+	return {
+		moduleKey: "contacts",
+		tableName: "contacts",
+		concept: "contact",
+		fields: {
+			name: "name",
+			email: "email"
+		},
+		cursorField: "updatedAt",
+		idField: null
+	};
+}
+function planInit(schema) {
+	const todos = [];
+	const { contact: contactTable, company: companyTable } = selectEntities(schema.tables);
+	const contactDetected = contactTable !== null;
+	const contact = contactTable ? buildEntity(contactTable, "contact", todos) : placeholderContact(todos);
+	let company = null;
+	if (companyTable) {
+		company = buildEntity(companyTable, "company", todos);
+		if (matchesConcept(companyTable.tableName, "contact")) todos.push(`"${companyTable.tableName}" matches both contact and company naming — assigned to company. Swap it to your contact entity if that's wrong.`);
+	}
+	if (contactTable) {
+		const scored = scoreRelationships(toScoredTable(contactTable), schema.tables.map(toScoredTable));
+		const top = scored[0];
+		const runnerUp = scored[1];
+		const isClearWinner = top !== void 0 && (runnerUp === void 0 || top.score - runnerUp.score >= 15);
+		if (top && isClearWinner) contact.relationship = {
+			name: top.value.name,
+			via: top.value.via
+		};
+	}
+	return {
+		importPath: schema.importPath,
+		db: schema.db,
+		contact,
+		company,
+		todos,
+		contactDetected
+	};
+}
+//#endregion
+//#region src/render-config.ts
+const CLIVLY_ENV_KEYS = [
+	{
+		key: "CLIVLY_API_KEY",
+		comment: "Org API key — Settings → API keys"
+	},
+	{
+		key: "CLIVLY_SYNC_TRIGGER_URL",
+		comment: "Public URL of your mounted tick route (e.g. https://app.example.com/api/clivly/tick)"
+	},
+	{
+		key: "CLIVLY_SYNC_TRIGGER_SECRET",
+		comment: "Signing secret — Integrations → Remote sync"
+	},
+	{
+		key: "CLIVLY_VERIFY_TOKEN",
+		comment: "Bearer token Clivly presents to /clivly/auth/verify"
+	}
+];
+function renderFields(fields) {
+	return `{ ${Object.entries(fields).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ")} }`;
+}
+function renderRelationships(entity) {
+	if (!entity.relationship) return "";
+	const { name, via } = entity.relationship;
+	return `,\n      relationships: { ${name}: { entity: "${name}", via: ${JSON.stringify(via)} } }`;
+}
+function renderEntity(key, entity) {
+	return `    ${key}: {
+      concept: "${entity.concept}",
+      source: "${entity.tableName}",
+      fields: ${renderFields(entity.fields)}${renderRelationships(entity)},
+    }`;
+}
+function renderSource(role, entity, dbExpr) {
+	const opts = entity.idField === null ? `{ entity: "${entity.tableName}", cursorField: "${entity.cursorField}" }` : `{ entity: "${entity.tableName}", cursorField: "${entity.cursorField}", idField: "${entity.idField}" }`;
+	return `    ${role}: fromDrizzle(${dbExpr}, schema.${entity.moduleKey}, ${opts})`;
+}
+function fallbackDbImportPath(schemaImportPath) {
+	const slash = schemaImportPath.lastIndexOf("/");
+	return `${slash >= 0 ? schemaImportPath.slice(0, slash) : "."}/db`;
+}
+function renderDbExpr(plan) {
+	return plan.db ? `schema.${plan.db.moduleKey}` : "db";
+}
+function renderImports(plan) {
+	const lines = [
+		"import { createClivlySDK } from \"clivly/sdk\";",
+		"import { fromDrizzle } from \"clivly/drizzle\";",
+		"import { defineClivlyConfig } from \"clivly/core\";",
+		"import { discoverFromDrizzle } from \"clivly/core/drizzle\";",
+		`import * as schema from "${plan.importPath}";`
+	];
+	if (!plan.db) lines.push(`import { db } from "${fallbackDbImportPath(plan.importPath)}"; // TODO: point at your Drizzle instance`);
+	return lines.join("\n");
+}
+function renderTodoHeader(todos) {
+	if (todos.length === 0) return "";
+	return `// TODO(clivly): review before running \`clivly doctor\`:\n${todos.map((t) => `//   - ${t}`).join("\n")}\n\n`;
+}
+function renderInitConfig(plan) {
+	const dbExpr = renderDbExpr(plan);
+	const entities = [renderEntity(plan.contact.moduleKey, plan.contact)];
+	if (plan.company) entities.push(renderEntity(plan.company.moduleKey, plan.company));
+	const sources = [renderSource("contacts", plan.contact, dbExpr)];
+	if (plan.company) sources.push(renderSource("companies", plan.company, dbExpr));
+	return `${renderTodoHeader(plan.todos)}${renderImports(plan)}
+
+const entities = defineClivlyConfig({
+  entities: {
+${entities.join(",\n")},
+  },
+});
+
+export default createClivlySDK({
+  apiKey: process.env.CLIVLY_API_KEY!,
+  entities,
+  // Every table in your Drizzle schema, so the Clivly dashboard can offer them
+  // all when you add a mapping — not just the ones wired up as sources below.
+  schema: discoverFromDrizzle(schema),
+  source: {
+${sources.join(",\n")},
+  },
+  syncTrigger: {
+    // The public URL Clivly Cloud calls to trigger a sync — your mounted tick route.
+    url: process.env.CLIVLY_SYNC_TRIGGER_URL,
+    secret: process.env.CLIVLY_SYNC_TRIGGER_SECRET,
+  },
+  verifyToken: process.env.CLIVLY_VERIFY_TOKEN,
+});
+`;
+}
+//#endregion
+//#region src/resolve-schema-path.ts
+const COMMON_PATHS = [
+	"src/db/schema.ts",
+	"src/db/schema",
+	"db/schema.ts",
+	"db/schema",
+	"src/schema.ts",
+	"src/schema",
+	"drizzle/schema.ts",
+	"drizzle/schema"
+];
+const DRIZZLE_CONFIG_NAMES = [
+	"drizzle.config.ts",
+	"drizzle.config.js",
+	"drizzle.config.mjs"
+];
+function defaultReadDrizzleConfigSchema(cwd) {
+	for (const name of DRIZZLE_CONFIG_NAMES) {
+		const path = resolve(cwd, name);
+		if (!existsSync(path)) continue;
+		try {
+			const schema = createJiti(pathToFileURL(path).href)(path).default?.schema;
+			const first = Array.isArray(schema) ? schema[0] : schema;
+			if (typeof first === "string") return first;
+		} catch {}
+	}
+	return null;
+}
+function resolveSchemaPath(opts) {
+	const exists = opts.deps?.exists ?? existsSync;
+	const readSchema = opts.deps?.readDrizzleConfigSchema ?? defaultReadDrizzleConfigSchema;
+	const toAbs = (p) => isAbsolute(p) ? p : resolve(opts.cwd, p);
+	if (opts.flag) return toAbs(opts.flag);
+	const fromConfig = readSchema(opts.cwd);
+	if (fromConfig) return toAbs(fromConfig);
+	for (const candidate of COMMON_PATHS) {
+		const abs = toAbs(candidate);
+		if (exists(abs)) return abs;
+	}
+	return null;
+}
+//#endregion
+//#region src/scaffold.ts
+const TANSTACK_ROUTE_PREFIX = /^src\/routes\//;
+const TS_EXTENSION = /\.ts$/;
+const ROUTE_PATHS = {
+	nextjs: {
+		tick: "app/api/clivly/tick/route.ts",
+		verify: "app/api/clivly/auth/verify/route.ts"
+	},
+	"tanstack-start": {
+		tick: "src/routes/api/clivly/tick.ts",
+		verify: "src/routes/api/clivly/auth/verify.ts"
+	},
+	sveltekit: {
+		tick: "src/routes/api/clivly/tick/+server.ts",
+		verify: "src/routes/api/clivly/auth/verify/+server.ts"
+	},
+	remix: {
+		tick: "app/routes/api.clivly.tick.ts",
+		verify: "app/routes/api.clivly.auth.verify.ts"
+	},
+	nuxt: {
+		tick: "server/api/clivly/tick.ts",
+		verify: "server/api/clivly/auth/verify.ts"
+	},
+	unknown: null
+};
+function routePath(framework, kind) {
+	const paths = ROUTE_PATHS[framework];
+	if (!paths) throw new Error(`No route path for framework: ${framework}`);
+	return paths[kind];
+}
+function configImport(routeFilePath) {
+	const rel = relative(dirname(routeFilePath), "clivly.config").replace(/\\/g, "/");
+	return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function renderBody(framework, importPath, verify) {
+	const preamble = verify ? `import clivly from "${importPath}";
+
+// TODO(clivly): resolve the signed-in host user from the request (your auth stack).
+const resolveUser = (_req: Request) => null;
+const handler = clivly.createAuthVerifyHandler(resolveUser);
+` : `import clivly from "${importPath}";
+
+const handler = clivly.createClivlyHandler();
+`;
+	switch (framework) {
+		case "nextjs": return `${preamble}
+export const POST = (request: Request) => handler(request);
+`;
+		case "tanstack-start": return `import { createAPIFileRoute } from "@tanstack/react-start/api";
+${preamble}
+export const APIRoute = createAPIFileRoute("__ROUTE__")({
+  POST: ({ request }) => handler(request),
+});
+`;
+		case "sveltekit": return `import type { RequestHandler } from "./$types";
+${preamble}
+export const POST: RequestHandler = ({ request }) => handler(request);
+`;
+		case "remix": return `import type { ActionFunctionArgs } from "@remix-run/node";
+${preamble}
+export const action = ({ request }: ActionFunctionArgs) => handler(request);
+`;
+		case "nuxt": return `import { toWebRequest } from "h3";
+${preamble}
+export default defineEventHandler((event) => handler(toWebRequest(event)));
+`;
+		default: throw new Error(`No route template for framework: ${framework}`);
+	}
+}
+function renderRouteFile(framework, kind) {
+	const path = routePath(framework, kind);
+	let body = renderBody(framework, configImport(path), kind === "verify");
+	if (framework === "tanstack-start") {
+		const url = `/${path.replace(TANSTACK_ROUTE_PREFIX, "").replace(TS_EXTENSION, "")}`;
+		body = body.replace("__ROUTE__", url);
+	}
+	return body;
+}
+const COMMON_FILES = [{
+	path: "clivly.config.ts",
+	description: "Your Clivly configuration",
+	owned: false
+}];
+function planScaffold(framework) {
+	const paths = ROUTE_PATHS[framework];
+	if (!paths) return [];
+	return [
+		{
+			path: paths.tick,
+			description: "Clivly sync-trigger route (createClivlyHandler)",
+			owned: true
+		},
+		{
+			path: paths.verify,
+			description: "Clivly auth-verify route (createAuthVerifyHandler) — finish resolveUser",
+			owned: true
+		},
+		...COMMON_FILES
+	];
+}
+//#endregion
+//#region src/index.ts
+function flagValue(argv, flag) {
+	const index = argv.indexOf(flag);
+	return index >= 0 ? argv[index + 1] : void 0;
+}
+function readDeps(cwd) {
+	const pkgPath = join(cwd, "package.json");
+	if (!existsSync(pkgPath)) return {};
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+		return {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+	} catch {
+		return {};
+	}
+}
+function readOwnVersion() {
+	const req = createRequire(import.meta.url);
+	for (const rel of ["./package.json", "../package.json"]) try {
+		const pkg = req(rel);
+		if (pkg.name === "clivly" && pkg.version) return pkg.version;
+	} catch {}
+}
+function defaultReadEnv(cwd) {
+	const path = join(cwd, ".env");
+	return existsSync(path) ? readFileSync(path, "utf8") : "";
+}
+function defaultWriteEnv(cwd, contents) {
+	writeFileSync(join(cwd, ".env"), contents, "utf8");
+}
+function resolveInitDeps(options) {
+	return {
+		out: options.out ?? ((line) => process.stdout.write(line)),
+		readDepsFn: options.readDeps ?? readDeps,
+		resolvePath: options.resolveSchemaPath ?? ((cwd) => resolveSchemaPath({
+			cwd,
+			flag: options.schemaFlag
+		})),
+		discover: options.discoverSchema ?? ((schemaPath, cwd) => discoverSchema({
+			schemaPath,
+			cwd
+		})),
+		configExists: options.configExists ?? existsSync,
+		writeConfig: options.writeConfig ?? ((path, contents) => {
+			mkdirSync(dirname(path), { recursive: true });
+			writeFileSync(path, contents, "utf8");
+		}),
+		detectPackageManager: options.detectPackageManager ?? detectPackageManager,
+		install: options.installPackages ?? installPackages,
+		readEnv: options.readEnv ?? defaultReadEnv,
+		readOwnVersion: options.readOwnVersion ?? readOwnVersion,
+		writeEnv: options.writeEnv ?? defaultWriteEnv,
+		framework: "unknown"
+	};
+}
+async function acquireSchema(options, deps) {
+	const { out } = deps;
+	const appDeps = deps.readDepsFn(options.cwd);
+	if (Object.keys(appDeps).length === 0) {
+		out("No package.json found here. Run `clivly init` from your app root.\n");
+		return { code: 1 };
+	}
+	const framework = detectFramework(appDeps);
+	const orm = detectOrm(appDeps);
+	deps.framework = framework;
+	out("\nClivly init\n");
+	out(`  Framework: ${FRAMEWORK_LABELS[framework]}\n`);
+	out(`  ORM:       ${orm}\n\n`);
+	if (orm !== "drizzle") {
+		out(`clivly init currently generates config for Drizzle only. Detected ORM: ${orm}\n`);
+		return { code: 1 };
+	}
+	if (framework === "unknown") {
+		out("clivly init doesn't recognise your framework yet (looked for Next.js, TanStack Start, SvelteKit, Remix, Nuxt). Route file generation needs one of these.\n");
+		return { code: 1 };
+	}
+	const schemaPath = deps.resolvePath(options.cwd);
+	if (!schemaPath) {
+		out("Could not locate your Drizzle schema. Pass --schema <path>, or add a `schema` field to drizzle.config.ts.\n");
+		return { code: 1 };
+	}
+	out(`  Schema:    ${schemaPath}\n\n`);
+	try {
+		const schema = await deps.discover(schemaPath, options.cwd);
+		if (schema.tables.length === 0) {
+			out(`No Drizzle tables found in ${schemaPath}. Is this the right path?\n`);
+			return { code: 1 };
+		}
+		return schema;
+	} catch (error) {
+		out(`Failed to load the schema module: ${error.message}\n`);
+		out("The schema must import cleanly without a live DB connection.\n");
+		return { code: 1 };
+	}
+}
+function printPlan(out, plan) {
+	out("Detected:\n");
+	out(`  contact  ← ${plan.contact.tableName}  fields ${JSON.stringify(plan.contact.fields)}\n`);
+	if (plan.company) out(`  company  ← ${plan.company.tableName}  fields ${JSON.stringify(plan.company.fields)}\n`);
+	out("\n");
+	if (plan.todos.length > 0) {
+		out("Review after generation:\n");
+		for (const todo of plan.todos) out(`  • ${todo}\n`);
+		out("\n");
+	}
+}
+function writeOwnedFile(options, deps, path, contents) {
+	const full = join(options.cwd, path);
+	if (deps.configExists(full) && !options.force) {
+		deps.out(`  • ${path} exists — skipped (pass --force to overwrite)\n`);
+		return;
+	}
+	deps.writeConfig(full, contents);
+	deps.out(`  ✓ ${path}\n`);
+}
+function writeScaffoldFiles(options, deps, plan) {
+	writeOwnedFile(options, deps, "clivly.config.ts", renderInitConfig(plan));
+	for (const file of planScaffold(deps.framework)) {
+		if (file.path === "clivly.config.ts") continue;
+		const kind = file.path.includes("verify") ? "verify" : "tick";
+		writeOwnedFile(options, deps, file.path, renderRouteFile(deps.framework, kind));
+	}
+}
+function writeEnvFile(options, deps) {
+	const nextEnv = appendEnvKeys(deps.readEnv(options.cwd), CLIVLY_ENV_KEYS);
+	deps.writeEnv(options.cwd, nextEnv);
+	deps.out("  ✓ .env placeholders\n");
+}
+function printNextSteps(out) {
+	out("\nNext steps:\n");
+	out("  1. Set the CLIVLY_* values in .env\n");
+	out("  2. Set CLIVLY_SYNC_TRIGGER_URL to your public tick route\n");
+	out("  3. Finish resolveUser in the auth/verify route\n");
+	out("  4. Run `clivly connect` to verify\n");
+}
+async function scaffold(options, deps, plan) {
+	const { out } = deps;
+	const pm = deps.detectPackageManager(options.cwd);
+	const version = deps.readOwnVersion();
+	const spec = version ? `clivly@${version}` : "clivly";
+	const result = await deps.install({
+		cwd: options.cwd,
+		pm,
+		packages: [spec]
+	});
+	if (result.ok) out(`Installed clivly (${pm})\n`);
+	else out(`Could not install automatically — run:\n  ${result.command}\n`);
+	writeScaffoldFiles(options, deps, plan);
+	writeEnvFile(options, deps);
+	printNextSteps(out);
+	return plan.contactDetected ? 0 : 1;
+}
+async function runInit(options) {
+	const deps = resolveInitDeps(options);
+	const acquired = await acquireSchema(options, deps);
+	if ("code" in acquired) return acquired.code;
+	const plan = planInit(acquired);
+	printPlan(deps.out, plan);
+	return scaffold(options, deps, plan);
+}
+async function main(argv) {
+	const [command, ...rest] = argv;
+	switch (command) {
+		case "init": return await runInit({
+			cwd: process.cwd(),
+			force: rest.includes("--force"),
+			schemaFlag: flagValue(rest, "--schema")
+		});
+		case "ping": return await runPing({
+			apiKey: process.env.CLIVLY_API_KEY,
+			apiUrl: flagValue(rest, "--api-url") ?? process.env.CLIVLY_API_URL
+		});
+		case "doctor": return await runDoctor({
+			cwd: process.cwd(),
+			configPath: flagValue(rest, "--config")
+		});
+		case "connect": return await runConnect({
+			cwd: process.cwd(),
+			apiKey: process.env.CLIVLY_API_KEY,
+			apiUrl: flagValue(rest, "--api-url") ?? process.env.CLIVLY_API_URL,
+			configPath: flagValue(rest, "--config")
+		});
+		case void 0:
+		case "help":
+		case "--help":
+			process.stdout.write("clivly — embed a CRM in your app\n\nUsage:\n  clivly init [--force] [--schema <path>]   Scaffold Clivly (config, routes, .env) for your app\n  clivly ping [--api-url <url>]   Verify CLIVLY_API_KEY + reachability\n  clivly doctor [--config <path>]   Verify your clivly.config setup end-to-end\n  clivly connect [--config <path>]   One pass/fail check that setup is wired\n");
+			return 0;
+		default:
+			process.stdout.write(`Unknown command: ${command}\n`);
+			return 1;
+	}
+}
+if (isEntrypoint(process.argv[1], import.meta.url)) main(process.argv.slice(2)).then((code) => {
+	process.exitCode = code;
+});
+//#endregion
+export { runInit };