clivly 0.2.0 → 0.2.2

package/dist/index.mjs

@@ -1,542 +0,0 @@
-#!/usr/bin/env node
-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 = [
-	{
-		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";
-}
-//#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 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 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 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 {};
-	try {
-		const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-		return {
-			...pkg.dependencies,
-			...pkg.devDependencies
-		};
-	} catch {
-		return {};
-	}
-}
-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(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 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 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;
-}
-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 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] [--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;
-	}
-}
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(2)).then((code) => {
-	process.exitCode = code;
-});
-//#endregion
-export { runInit };