clivly 0.1.0 → 0.2.0

package/README.md

@@ -7,10 +7,21 @@ Scaffold [Clivly](https://clivly.com) — the CRM that lives inside your app.
 ```bash
 npx clivly init          # detect your stack and print the scaffold plan
 npx clivly init --write  # write clivly.config.ts
+npx clivly ping          # verify CLIVLY_API_KEY + reachability
 ```
 
 `clivly init` detects your framework (Next.js, TanStack Start, SvelteKit, Remix, Nuxt) and ORM (Drizzle, Prisma, Kysely) from `package.json`, then reports the routes and schema fragment it will scaffold.
 
+`clivly ping` reads `CLIVLY_API_KEY` from the environment, sends one heartbeat, and prints a clear ✅/❌ with the resolved org or the failure reason — so you can confirm a connection from the terminal without writing any code. Point it at a non-default backend with `--api-url <url>` (or `CLIVLY_API_URL`).
+
+```bash
+CLIVLY_API_KEY=sk_live_… npx clivly ping
+#
+# Clivly ping
+#   ✅ Connected to Clivly
+#      Org: Acme (org_1)
+```
+
 ## License
 
 MIT

package/dist/index.mjs

@@ -1,6 +1,11 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createJiti } from "jiti";
+import { createClivlySDK } from "@clivly/sdk";
+import { CANONICAL_FIELDS } from "@clivly/core/entity-config";
+import { matchesConcept, requiredFieldsFor, suggestCursorField, suggestFieldMap, suggestRelationships } from "@clivly/core/entity-heuristics";
 //#region src/detect.ts
 const FRAMEWORK_MARKERS = [
 	{
@@ -55,79 +60,354 @@ function detectOrm(deps) {
 	return "unknown";
 }
 //#endregion
-//#region src/scaffold.ts
-const FRAMEWORK_ROUTES = {
-	nextjs: [{
-		path: "app/crm/[[...slug]]/page.tsx",
-		description: "Mounts the Clivly SPA at /crm",
-		owned: true
-	}, {
-		path: "app/api/clivly/[...path]/route.ts",
-		description: "Clivly API handler",
-		owned: true
-	}],
-	"tanstack-start": [{
-		path: "src/routes/crm/$.tsx",
-		description: "Mounts the Clivly SPA at /crm",
-		owned: true
-	}, {
-		path: "src/routes/api/clivly/$.ts",
-		description: "Clivly API handler",
-		owned: true
-	}],
-	sveltekit: [{
-		path: "src/routes/crm/[...slug]/+page.svelte",
-		description: "Mounts the Clivly SPA at /crm",
-		owned: true
-	}, {
-		path: "src/routes/api/clivly/[...path]/+server.ts",
-		description: "Clivly API handler",
-		owned: true
-	}],
-	remix: [{
-		path: "app/routes/crm.$.tsx",
-		description: "Mounts the Clivly SPA at /crm",
-		owned: true
-	}, {
-		path: "app/routes/api.clivly.$.ts",
-		description: "Clivly API handler",
-		owned: true
-	}],
-	nuxt: [{
-		path: "pages/crm/[...slug].vue",
-		description: "Mounts the Clivly SPA at /crm",
-		owned: true
-	}, {
-		path: "server/api/clivly/[...path].ts",
-		description: "Clivly API handler",
-		owned: true
-	}],
-	unknown: []
+//#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 discoverSchema(opts) {
+	const load = opts.load ?? defaultLoader(opts.cwd);
+	const mod = await loadSchemaModule(opts.schemaPath, load);
+	const drizzle = await load("drizzle-orm");
+	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 columns = Object.entries(drizzle.getTableColumns(value)).map(([key, col]) => ({
+				key,
+				dbName: col.name,
+				isPrimary: Boolean(col.primary)
+			}));
+			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/render.ts
+function checkLine(ok, label, detail) {
+	return `  ${ok ? "✅" : "❌"} ${label}${detail ? ` — ${detail}` : ""}\n`;
+}
+//#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/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 COMMON_FILES = [{
-	path: "drizzle/schema/clivly.ts",
-	description: "crm_* schema fragment — merge into your schema",
-	owned: false
-}, {
-	path: "clivly.config.ts",
-	description: "Your Clivly configuration",
-	owned: false
-}];
-function planScaffold(framework) {
-	return [...FRAMEWORK_ROUTES[framework] ?? [], ...COMMON_FILES];
-}
-function renderConfigTemplate(contactEntity) {
-	return `import { defineClivlyConfig } from "clivly";
+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 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 = suggestFieldMap(concept, table.columns.map((c) => c.dbName));
+	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 suggestions = suggestRelationships({
+			name: contactTable.tableName,
+			columns: contactTable.columns.map((c) => c.dbName)
+		}, schema.tables.map((t) => ({
+			name: t.tableName,
+			columns: t.columns.map((c) => c.dbName)
+		})));
+		const only = suggestions[0];
+		if (suggestions.length === 1 && only) contact.relationship = {
+			name: only.name,
+			via: only.via
+		};
+	}
+	return {
+		importPath: schema.importPath,
+		db: schema.db,
+		contact,
+		company,
+		todos,
+		contactDetected
+	};
+}
+//#endregion
+//#region src/render-config.ts
+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) {
+	const opts = entity.idField === null ? `{ entity: "${entity.tableName}", cursorField: "${entity.cursorField}" }` : `{ entity: "${entity.tableName}", cursorField: "${entity.cursorField}", idField: "${entity.idField}" }`;
+	return `    ${role}: fromDrizzle(db, ${entity.moduleKey}, ${opts})`;
+}
+function renderTableImport(plan) {
+	const tableKeys = [plan.contact.moduleKey, plan.company?.moduleKey].filter(Boolean);
+	if (plan.db) return `import { db, ${tableKeys.join(", ")} } from "${plan.importPath}";`;
+	return `import { ${tableKeys.join(", ")} } from "${plan.importPath}";
+import { db } from "./db"; // TODO: point at your Drizzle instance`;
+}
+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 entities = [renderEntity(plan.contact.moduleKey, plan.contact)];
+	if (plan.company) entities.push(renderEntity(plan.company.moduleKey, plan.company));
+	const sources = [renderSource("contacts", plan.contact)];
+	if (plan.company) sources.push(renderSource("companies", plan.company));
+	return `${renderTodoHeader(plan.todos)}import { createClivlySDK } from "@clivly/sdk";
+import { fromDrizzle } from "@clivly/sdk/drizzle";
+import { defineClivlyConfig } from "@clivly/core";
+${renderTableImport(plan)}
+
+const entities = defineClivlyConfig({
+  entities: {
+${entities.join(",\n")},
+  },
+});
 
-export default defineClivlyConfig({
-  // The host table Clivly treats as the contact entity.
-  contactEntity: "${contactEntity}",
-  contactFields: ["id", "email", "name", "created_at"],
+export default createClivlySDK({
+  apiKey: process.env.CLIVLY_API_KEY!,
+  entities,
+  source: {
+${sources.join(",\n")},
+  },
 });
 `;
 }
 //#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/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 {};
@@ -141,53 +421,122 @@ function readDeps(cwd) {
 		return {};
 	}
 }
-function runInit(cwd, write) {
-	const deps = readDeps(cwd);
-	if (Object.keys(deps).length === 0) {
-		process.stdout.write("No package.json found here. Run `clivly init` from your app root.\n");
-		return 1;
+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) => writeFileSync(path, contents, "utf8"))
+	};
+}
+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(deps);
-	const orm = detectOrm(deps);
-	process.stdout.write("\nClivly init\n");
-	process.stdout.write(`  Framework: ${FRAMEWORK_LABELS[framework]}\n`);
-	process.stdout.write(`  ORM:       ${orm}\n\n`);
-	if (framework === "unknown") {
-		process.stdout.write("Could not detect a supported framework. Supported: Next.js, TanStack Start, SvelteKit, Remix, Nuxt.\n");
-		return 1;
+	const framework = detectFramework(appDeps);
+	const orm = detectOrm(appDeps);
+	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 };
 	}
-	const files = planScaffold(framework);
-	process.stdout.write("Will scaffold:\n");
-	for (const file of files) {
-		const tag = file.owned ? "generated" : "yours";
-		process.stdout.write(`  ${file.path}  (${tag}) — ${file.description}\n`);
-	}
-	process.stdout.write("\n");
-	if (write) {
-		const configPath = join(cwd, "clivly.config.ts");
-		if (existsSync(configPath)) process.stdout.write("clivly.config.ts already exists — skipped.\n");
-		else {
-			writeFileSync(configPath, renderConfigTemplate("users"), "utf8");
-			process.stdout.write("Created clivly.config.ts\n");
+	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 };
 		}
-	} else process.stdout.write("Dry run. Re-run with --write to scaffold.\n");
-	return 0;
+		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 writePlan(options, deps, plan) {
+	const { out } = deps;
+	const configPath = join(options.cwd, "clivly.config.ts");
+	if (!options.write) {
+		out("Dry run. Re-run with --write to scaffold clivly.config.ts.\n");
+		return plan.contactDetected ? 0 : 1;
+	}
+	if (deps.configExists(configPath) && !options.force) {
+		out("clivly.config.ts already exists — pass --force to overwrite.\n");
+		return 0;
+	}
+	deps.writeConfig(configPath, renderInitConfig(plan));
+	out("Created clivly.config.ts\n");
+	out("Next: set CLIVLY_API_KEY, address any TODOs above, then run `clivly doctor`.\n");
+	return plan.contactDetected ? 0 : 1;
 }
-function main(argv) {
+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 writePlan(options, deps, plan);
+}
+async function main(argv) {
 	const [command, ...rest] = argv;
 	const write = rest.includes("--write");
 	switch (command) {
-		case "init": return runInit(process.cwd(), write);
+		case "init": return await runInit({
+			cwd: process.cwd(),
+			write,
+			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 void 0:
 		case "help":
 		case "--help":
-			process.stdout.write("clivly — embed a CRM in your app\n\nUsage:\n  clivly init [--write]   Detect your stack and scaffold Clivly\n");
+			process.stdout.write("clivly — embed a CRM in your app\n\nUsage:\n  clivly init [--write] [--force] [--schema <path>]   Detect your Drizzle schema and generate clivly.config.ts\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");
 			return 0;
 		default:
 			process.stdout.write(`Unknown command: ${command}\n`);
 			return 1;
 	}
 }
-process.exitCode = main(process.argv.slice(2));
+if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(2)).then((code) => {
+	process.exitCode = code;
+});
 //#endregion
-export {};
+export { runInit };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clivly",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "description": "Clivly CLI — scaffold a CRM into your app (clivly init).",
@@ -16,6 +16,11 @@
   "files": [
     "dist"
   ],
+  "dependencies": {
+    "jiti": "^2.7.0",
+    "@clivly/core": "0.2.0",
+    "@clivly/sdk": "0.2.0"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -23,11 +28,12 @@
     "@types/node": "^25.9.1",
     "tsdown": "^0.21.9",
     "typescript": "^6",
-    "@clivly.com/config": "0.0.0"
+    "vitest": "^3.2.4"
   },
   "scripts": {
     "build": "tsdown",
-    "check-types": "tsc --noEmit"
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
   },
   "main": "./dist/index.mjs"
 }