@bonnard/cli 0.1.5 → 0.1.7

package/dist/bin/bon.mjs

@@ -5,10 +5,10 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import pc from "picocolors";
+import YAML from "yaml";
+import os from "node:os";
 import http from "node:http";
 import crypto from "node:crypto";
-import os from "node:os";
-import YAML from "yaml";
 import { execFileSync } from "node:child_process";
 import { confirm } from "@inquirer/prompts";
 import { encode } from "@toon-format/toon";
@@ -30,6 +30,462 @@ var __exportAll = (all, symbols) => {
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+//#endregion
+//#region src/lib/project.ts
+/**
+* The subdirectory name used for Bonnard model/view files.
+* Keeps Bonnard files namespaced to avoid conflicts with existing
+* project directories (e.g. dbt's models/).
+*/
+const BONNARD_DIR = "bonnard";
+/**
+* Resolve Bonnard project paths relative to the working directory.
+* All model/view operations should use these paths.
+*/
+function getProjectPaths(cwd) {
+	const bonnardRoot = path.join(cwd, BONNARD_DIR);
+	return {
+		root: bonnardRoot,
+		models: path.join(bonnardRoot, "models"),
+		views: path.join(bonnardRoot, "views"),
+		config: path.join(cwd, "bon.yaml"),
+		localState: path.join(cwd, ".bon")
+	};
+}
+
+//#endregion
+//#region src/lib/dbt/profiles.ts
+/**
+* dbt profiles.yml parser
+*
+* Parses ~/.dbt/profiles.yml and extracts connection configs.
+* Does NOT resolve env vars - they are kept as-is for deploy time resolution.
+*/
+const DBT_PROFILES_PATH = path.join(os.homedir(), ".dbt", "profiles.yml");
+/**
+* Check if dbt profiles.yml exists
+*/
+function dbtProfilesExist(profilesPath = DBT_PROFILES_PATH) {
+	return fs.existsSync(profilesPath);
+}
+/**
+* Get the default dbt profiles path
+*/
+function getDefaultProfilesPath() {
+	return DBT_PROFILES_PATH;
+}
+/**
+* Map dbt type to Bonnard warehouse type
+*/
+function mapDbtType(dbtType) {
+	return {
+		snowflake: "snowflake",
+		postgres: "postgres",
+		postgresql: "postgres",
+		bigquery: "bigquery",
+		databricks: "databricks"
+	}[dbtType.toLowerCase()] ?? null;
+}
+/**
+* Parse dbt profiles.yml and return all connections
+* Config values are kept as-is (including {{ env_var(...) }} patterns)
+*/
+function parseDbtProfiles(profilesPath = DBT_PROFILES_PATH) {
+	if (!fs.existsSync(profilesPath)) throw new Error(`dbt profiles not found at ${profilesPath}`);
+	const content = fs.readFileSync(profilesPath, "utf-8");
+	const profiles = YAML.parse(content);
+	if (!profiles || typeof profiles !== "object") throw new Error("Invalid dbt profiles.yml format");
+	const connections = [];
+	for (const [profileName, profile] of Object.entries(profiles)) {
+		if (profileName === "config") continue;
+		if (!profile.outputs || typeof profile.outputs !== "object") continue;
+		const defaultTarget = profile.target || "dev";
+		for (const [targetName, target] of Object.entries(profile.outputs)) {
+			if (!target || typeof target !== "object" || !target.type) continue;
+			const warehouseType = mapDbtType(target.type);
+			if (!warehouseType) continue;
+			connections.push({
+				profileName,
+				targetName,
+				isDefaultTarget: targetName === defaultTarget,
+				type: warehouseType,
+				config: target
+			});
+		}
+	}
+	return connections;
+}
+
+//#endregion
+//#region src/lib/detect/scanner.ts
+/**
+* Project environment scanner
+*
+* Detects data tools (dbt, dagster, etc.), warehouse connections,
+* and existing model files in the user's project directory.
+*/
+const CONFIG_FILES = {
+	"dbt_project.yml": "dbt",
+	"dagster.yaml": "dagster",
+	"prefect.yaml": "prefect",
+	"evidence.config.yaml": "evidence",
+	"cube.js": "cube",
+	"cube.py": "cube",
+	"manifest.lkml": "looker",
+	"airflow.cfg": "airflow"
+};
+const CONFIG_DIRS = {
+	dags: "airflow",
+	great_expectations: "great-expectations",
+	gx: "great-expectations"
+};
+const SCAN_DIRS = [
+	"dbt",
+	"transform",
+	"analytics",
+	"data",
+	"warehouse",
+	"data-warehouse",
+	"orchestration",
+	"dagster",
+	"airflow"
+];
+const PYTHON_PACKAGES = {
+	"dbt-core": "dbt",
+	"dbt-snowflake": "dbt",
+	"dbt-postgres": "dbt",
+	"dbt-bigquery": "dbt",
+	"dbt-databricks": "dbt",
+	dagster: "dagster",
+	sqlmesh: "sqlmesh",
+	"apache-airflow": "airflow",
+	prefect: "prefect",
+	"soda-core": "soda"
+};
+const NPM_PACKAGES = {
+	"@cubejs-backend/": "cube",
+	"@evidence-dev/": "evidence"
+};
+const SAFE_DBT_FIELDS = [
+	"account",
+	"host",
+	"database",
+	"dbname",
+	"schema",
+	"warehouse",
+	"role",
+	"port",
+	"project",
+	"dataset",
+	"location",
+	"hostname",
+	"http_path",
+	"catalog"
+];
+/**
+* Scan root and subdirs for known config files/directories
+*/
+function scanForConfigFiles(cwd) {
+	const tools = [];
+	const seen = /* @__PURE__ */ new Set();
+	function checkDir(dir, prefix) {
+		for (const [filename, toolName] of Object.entries(CONFIG_FILES)) {
+			if (seen.has(toolName)) continue;
+			const filePath = path.join(dir, filename);
+			if (fs.existsSync(filePath)) {
+				const relativePath = prefix ? `${prefix}/${filename}` : filename;
+				tools.push({
+					name: toolName,
+					configPath: relativePath
+				});
+				seen.add(toolName);
+			}
+		}
+		for (const [dirname, toolName] of Object.entries(CONFIG_DIRS)) {
+			if (seen.has(toolName)) continue;
+			const dirPath = path.join(dir, dirname);
+			try {
+				if (fs.statSync(dirPath).isDirectory()) {
+					const relativePath = prefix ? `${prefix}/${dirname}/` : `${dirname}/`;
+					tools.push({
+						name: toolName,
+						configPath: relativePath
+					});
+					seen.add(toolName);
+				}
+			} catch {}
+		}
+	}
+	checkDir(cwd, "");
+	for (const subdir of SCAN_DIRS) {
+		const subdirPath = path.join(cwd, subdir);
+		try {
+			if (fs.statSync(subdirPath).isDirectory()) checkDir(subdirPath, subdir);
+		} catch {}
+	}
+	return tools;
+}
+/**
+* Scan dependency files for known data tool packages
+*/
+function scanDependencyFiles(cwd) {
+	const tools = [];
+	const pyprojectPath = path.join(cwd, "pyproject.toml");
+	if (fs.existsSync(pyprojectPath)) try {
+		const content = fs.readFileSync(pyprojectPath, "utf-8");
+		for (const [pkg, toolName] of Object.entries(PYTHON_PACKAGES)) if (content.includes(pkg)) tools.push({
+			name: toolName,
+			configPath: "pyproject.toml"
+		});
+	} catch {}
+	const requirementsPath = path.join(cwd, "requirements.txt");
+	if (fs.existsSync(requirementsPath)) try {
+		const content = fs.readFileSync(requirementsPath, "utf-8");
+		for (const [pkg, toolName] of Object.entries(PYTHON_PACKAGES)) if (content.includes(pkg)) tools.push({
+			name: toolName,
+			configPath: "requirements.txt"
+		});
+	} catch {}
+	const packageJsonPath = path.join(cwd, "package.json");
+	if (fs.existsSync(packageJsonPath)) try {
+		const content = fs.readFileSync(packageJsonPath, "utf-8");
+		const pkg = JSON.parse(content);
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		for (const depName of Object.keys(allDeps)) for (const [prefix, toolName] of Object.entries(NPM_PACKAGES)) if (depName.startsWith(prefix)) tools.push({
+			name: toolName,
+			configPath: "package.json"
+		});
+	} catch {}
+	return tools;
+}
+/**
+* Deduplicate tools by name, keeping the first occurrence (config file > dependency)
+*/
+function deduplicateTools(tools) {
+	const seen = /* @__PURE__ */ new Set();
+	return tools.filter((tool) => {
+		if (seen.has(tool.name)) return false;
+		seen.add(tool.name);
+		return true;
+	});
+}
+/**
+* Extract safe (non-secret) fields from a config object.
+* If a value looks like a dbt env_var reference, record it as "via env: VAR_NAME".
+*/
+function extractSafeFields(config) {
+	const safe = {};
+	for (const field of SAFE_DBT_FIELDS) {
+		const value = config[field];
+		if (value === void 0 || value === null) continue;
+		const strValue = String(value);
+		const envMatch = strValue.match(/\{\{\s*env_var\s*\(\s*['"]([^'"]+)['"]/);
+		if (envMatch) safe[field] = `via env: ${envMatch[1]}`;
+		else safe[field] = strValue;
+	}
+	return safe;
+}
+/**
+* Try to extract warehouse info from dbt profiles
+*/
+function extractWarehouseFromDbt(cwd, tools) {
+	const dbtTool = tools.find((t) => t.name === "dbt");
+	if (!dbtTool) return null;
+	const dbtProjectPath = path.join(cwd, dbtTool.configPath);
+	let profileName;
+	try {
+		const content = fs.readFileSync(dbtProjectPath, "utf-8");
+		const parsed = YAML.parse(content);
+		profileName = parsed?.profile;
+		const projectName = parsed?.name;
+		if (projectName) dbtTool.metadata = {
+			...dbtTool.metadata,
+			project: projectName
+		};
+		if (profileName) dbtTool.metadata = {
+			...dbtTool.metadata,
+			profile: profileName
+		};
+	} catch {}
+	if (!dbtProfilesExist()) return null;
+	try {
+		const connections = parseDbtProfiles();
+		let connection = profileName ? connections.find((c) => c.profileName === profileName && c.isDefaultTarget) : null;
+		if (!connection && connections.length > 0) connection = connections[0];
+		if (!connection) return null;
+		return {
+			type: connection.type,
+			source: "dbt-profiles",
+			config: extractSafeFields(connection.config)
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Try to extract warehouse info from .env file
+*/
+function extractWarehouseFromEnv(cwd) {
+	const envPath = path.join(cwd, ".env");
+	if (!fs.existsSync(envPath)) return null;
+	try {
+		const content = fs.readFileSync(envPath, "utf-8");
+		const cubeDbType = content.match(/^CUBEJS_DB_TYPE=(.+)$/m);
+		if (cubeDbType) {
+			const type = {
+				snowflake: "snowflake",
+				postgres: "postgres",
+				bigquery: "bigquery",
+				databricks: "databricks"
+			}[cubeDbType[1].trim().toLowerCase()];
+			if (type) return {
+				type,
+				source: "env",
+				config: { CUBEJS_DB_TYPE: cubeDbType[1].trim() }
+			};
+		}
+		if (content.match(/^SNOWFLAKE_ACCOUNT=/m)) {
+			const account = content.match(/^SNOWFLAKE_ACCOUNT=(.+)$/m);
+			return {
+				type: "snowflake",
+				source: "env",
+				config: account ? { account: account[1].trim() } : {}
+			};
+		}
+		if (content.match(/^PGHOST=/m) || content.match(/^DATABASE_URL=postgres/m)) return {
+			type: "postgres",
+			source: "env",
+			config: {}
+		};
+	} catch {}
+	return null;
+}
+/**
+* Extract warehouse info from detected tools and environment
+*/
+function extractWarehouseInfo(cwd, tools) {
+	if (tools.some((t) => t.name === "dbt")) {
+		const fromDbt = extractWarehouseFromDbt(cwd, tools);
+		if (fromDbt) return fromDbt;
+	}
+	return extractWarehouseFromEnv(cwd);
+}
+/**
+* Collect existing model files from detected tool directories.
+* Non-recursive scan of likely model dirs, capped at 20 paths.
+*/
+function collectModelFiles(cwd, tools) {
+	const modelFiles = [];
+	const extensions = new Set([
+		".sql",
+		".yml",
+		".yaml",
+		".lkml"
+	]);
+	const modelDirSet = /* @__PURE__ */ new Set();
+	for (const tool of tools) if (tool.name === "dbt") {
+		const dbtDir = path.dirname(path.join(cwd, tool.configPath));
+		modelDirSet.add(path.join(dbtDir, "models"));
+	} else if (tool.name === "looker") {
+		const lookDir = path.dirname(path.join(cwd, tool.configPath));
+		modelDirSet.add(lookDir);
+	}
+	for (const dir of [
+		"models",
+		"marts",
+		"staging",
+		"intermediate"
+	]) modelDirSet.add(path.join(cwd, dir));
+	for (const dir of modelDirSet) {
+		if (modelFiles.length >= 20) break;
+		try {
+			if (!fs.statSync(dir).isDirectory()) continue;
+			const entries = fs.readdirSync(dir, { withFileTypes: true });
+			for (const entry of entries) {
+				if (modelFiles.length >= 20) break;
+				if (entry.isFile() && extensions.has(path.extname(entry.name))) modelFiles.push(path.relative(cwd, path.join(dir, entry.name)));
+				if (entry.isDirectory()) try {
+					const subEntries = fs.readdirSync(path.join(dir, entry.name), { withFileTypes: true });
+					for (const subEntry of subEntries) {
+						if (modelFiles.length >= 20) break;
+						if (subEntry.isFile() && extensions.has(path.extname(subEntry.name))) modelFiles.push(path.relative(cwd, path.join(dir, entry.name, subEntry.name)));
+					}
+				} catch {}
+			}
+		} catch {}
+	}
+	return modelFiles;
+}
+/**
+* Detect the project environment by scanning for data tools,
+* warehouse connections, and existing model files.
+*/
+function detectProjectEnvironment(cwd) {
+	const configTools = scanForConfigFiles(cwd);
+	const depTools = scanDependencyFiles(cwd);
+	const tools = deduplicateTools([...configTools, ...depTools]);
+	return {
+		tools,
+		warehouse: extractWarehouseInfo(cwd, tools),
+		existingModels: collectModelFiles(cwd, tools)
+	};
+}
+
+//#endregion
+//#region src/lib/detect/context.ts
+/**
+* Generate a Markdown context section from detected project environment.
+* Returns a string with "## This Project" and "## Your Role" sections.
+*/
+function generateProjectContext(env) {
+	const sections = [];
+	const projectLines = ["## This Project"];
+	if (env.tools.length > 0) {
+		projectLines.push("");
+		projectLines.push("**Detected tools:**");
+		for (const tool of env.tools) {
+			const meta = tool.metadata ? ` (${Object.entries(tool.metadata).map(([k, v]) => `${k}: ${v}`).join(", ")})` : "";
+			projectLines.push(`- ${tool.name} — found at \`${tool.configPath}\`${meta}`);
+		}
+	}
+	if (env.warehouse) {
+		projectLines.push("");
+		projectLines.push(`**Warehouse:** ${env.warehouse.type} (detected via ${env.warehouse.source})`);
+		const configEntries = Object.entries(env.warehouse.config);
+		if (configEntries.length > 0) for (const [key, value] of configEntries) projectLines.push(`- ${key}: \`${value}\``);
+	}
+	if (env.existingModels.length > 0) {
+		projectLines.push("");
+		projectLines.push(`**Existing model files:** ${env.existingModels.length} file${env.existingModels.length === 1 ? "" : "s"} found`);
+		for (const modelPath of env.existingModels.slice(0, 10)) projectLines.push(`- \`${modelPath}\``);
+		if (env.existingModels.length > 10) projectLines.push(`- ... and ${env.existingModels.length - 10} more`);
+	}
+	sections.push(projectLines.join("\n"));
+	const roleLines = ["## Your Role"];
+	roleLines.push("");
+	const hasDbt = env.tools.some((t) => t.name === "dbt");
+	const hasWarehouse = env.warehouse !== null;
+	const dbtTool = env.tools.find((t) => t.name === "dbt");
+	if (hasDbt && hasWarehouse) roleLines.push("This user has an existing dbt project with a warehouse connection. Help them create Bonnard cubes that reference their mart/staging tables. They can import their connection with `bon datasource add --from-dbt`.");
+	else if (hasDbt && !hasWarehouse) roleLines.push("This user has a dbt project but warehouse profiles were not found locally. Help them set up a datasource manually with `bon datasource add`, or ensure `~/.dbt/profiles.yml` is available and re-run `bon init`.");
+	else if (!hasDbt && hasWarehouse) roleLines.push("This user has a warehouse connection configured. Help them create cubes directly from their database tables.");
+	else roleLines.push("New project — no existing data tools detected. Help them connect a warehouse (`bon datasource add`), then create their first cube.");
+	roleLines.push("");
+	roleLines.push("**Important:**");
+	roleLines.push("- Bonnard models go in `bonnard/models/` and views in `bonnard/views/` — do NOT modify files outside these directories");
+	roleLines.push("- Use `bon docs` to look up Cube YAML syntax before writing model definitions");
+	if (hasDbt && dbtTool) {
+		const dbtDir = dbtTool.configPath.includes("/") ? dbtTool.configPath.split("/").slice(0, -1).join("/") + "/" : "";
+		const modelsPath = dbtDir ? `${dbtDir}models/` : "models/";
+		roleLines.push(`- dbt models are in \`${modelsPath}\` — these are the user's transformation layer, not Bonnard's. Do not modify them.`);
+	}
+	sections.push(roleLines.join("\n"));
+	return sections.join("\n\n");
+}
+
 //#endregion
 //#region src/commands/init.ts
 const __filename$1 = fileURLToPath(import.meta.url);
@@ -101,9 +557,10 @@ alwaysApply: ${alwaysApply}
 /**
 * Create agent templates (Claude Code, Cursor, and Codex)
 */
-function createAgentTemplates(cwd) {
+function createAgentTemplates(cwd, env) {
 	const createdFiles = [];
-	const sharedBonnard = loadTemplate("shared/bonnard.md");
+	let sharedBonnard = loadTemplate("shared/bonnard.md");
+	if (env) sharedBonnard += "\n\n" + generateProjectContext(env);
 	const claudeRulesDir = path.join(cwd, ".claude", "rules");
 	const claudeSkillsDir = path.join(cwd, ".claude", "skills");
 	fs.mkdirSync(claudeRulesDir, { recursive: true });
@@ -129,29 +586,37 @@ function createAgentTemplates(cwd) {
 async function initCommand() {
 	const cwd = process.cwd();
 	const projectName = path.basename(cwd);
-	if (fs.existsSync(path.join(cwd, "bon.yaml"))) {
+	const paths = getProjectPaths(cwd);
+	if (fs.existsSync(paths.config)) {
 		console.log(pc.red("A bon.yaml already exists in this directory."));
 		process.exit(1);
 	}
-	fs.mkdirSync(path.join(cwd, "models"), { recursive: true });
-	fs.mkdirSync(path.join(cwd, "views"), { recursive: true });
-	fs.mkdirSync(path.join(cwd, ".bon"), { recursive: true });
-	fs.writeFileSync(path.join(cwd, "bon.yaml"), BON_YAML_TEMPLATE(projectName));
+	fs.mkdirSync(paths.models, { recursive: true });
+	fs.mkdirSync(paths.views, { recursive: true });
+	fs.mkdirSync(paths.localState, { recursive: true });
+	fs.writeFileSync(paths.config, BON_YAML_TEMPLATE(projectName));
 	fs.writeFileSync(path.join(cwd, ".gitignore"), GITIGNORE_TEMPLATE);
-	const agentFiles = createAgentTemplates(cwd);
+	const env = detectProjectEnvironment(cwd);
+	const agentFiles = createAgentTemplates(cwd, env.tools.length > 0 || env.warehouse ? env : void 0);
 	console.log(pc.green(`Initialised Bonnard project "${projectName}"`));
 	console.log();
 	console.log(pc.bold("Core files:"));
-	console.log(`  ${pc.dim("bon.yaml")}        project config`);
-	console.log(`  ${pc.dim("models/")}         model definitions`);
-	console.log(`  ${pc.dim("views/")}          view definitions`);
-	console.log(`  ${pc.dim(".bon/")}           local state (gitignored)`);
-	console.log(`  ${pc.dim(".gitignore")}      git ignore rules`);
+	console.log(`  ${pc.dim("bon.yaml")}                project config`);
+	console.log(`  ${pc.dim(`${BONNARD_DIR}/models/`)}      model definitions`);
+	console.log(`  ${pc.dim(`${BONNARD_DIR}/views/`)}       view definitions`);
+	console.log(`  ${pc.dim(".bon/")}                   local state (gitignored)`);
+	console.log(`  ${pc.dim(".gitignore")}              git ignore rules`);
 	if (agentFiles.length > 0) {
 		console.log();
 		console.log(pc.bold("Agent support:"));
 		for (const file of agentFiles) console.log(`  ${pc.dim(file)}`);
 	}
+	if (env.tools.length > 0 || env.warehouse) {
+		console.log();
+		console.log(pc.bold("Detected environment:"));
+		for (const tool of env.tools) console.log(`  ${pc.cyan(tool.name)} ${pc.dim(`(${tool.configPath})`)}`);
+		if (env.warehouse) console.log(`  ${pc.cyan(env.warehouse.type)} warehouse ${pc.dim(`(via ${env.warehouse.source})`)}`);
+	}
 }
 
 //#endregion
@@ -552,69 +1017,6 @@ var local_exports = /* @__PURE__ */ __exportAll({
 	saveLocalDatasources: () => saveLocalDatasources
 });
 
-//#endregion
-//#region src/lib/dbt/profiles.ts
-/**
-* dbt profiles.yml parser
-*
-* Parses ~/.dbt/profiles.yml and extracts connection configs.
-* Does NOT resolve env vars - they are kept as-is for deploy time resolution.
-*/
-const DBT_PROFILES_PATH = path.join(os.homedir(), ".dbt", "profiles.yml");
-/**
-* Check if dbt profiles.yml exists
-*/
-function dbtProfilesExist(profilesPath = DBT_PROFILES_PATH) {
-	return fs.existsSync(profilesPath);
-}
-/**
-* Get the default dbt profiles path
-*/
-function getDefaultProfilesPath() {
-	return DBT_PROFILES_PATH;
-}
-/**
-* Map dbt type to Bonnard warehouse type
-*/
-function mapDbtType(dbtType) {
-	return {
-		snowflake: "snowflake",
-		postgres: "postgres",
-		postgresql: "postgres",
-		bigquery: "bigquery",
-		databricks: "databricks"
-	}[dbtType.toLowerCase()] ?? null;
-}
-/**
-* Parse dbt profiles.yml and return all connections
-* Config values are kept as-is (including {{ env_var(...) }} patterns)
-*/
-function parseDbtProfiles(profilesPath = DBT_PROFILES_PATH) {
-	if (!fs.existsSync(profilesPath)) throw new Error(`dbt profiles not found at ${profilesPath}`);
-	const content = fs.readFileSync(profilesPath, "utf-8");
-	const profiles = YAML.parse(content);
-	if (!profiles || typeof profiles !== "object") throw new Error("Invalid dbt profiles.yml format");
-	const connections = [];
-	for (const [profileName, profile] of Object.entries(profiles)) {
-		if (profileName === "config") continue;
-		if (!profile.outputs || typeof profile.outputs !== "object") continue;
-		const defaultTarget = profile.target || "dev";
-		for (const [targetName, target] of Object.entries(profile.outputs)) {
-			if (!target || typeof target !== "object" || !target.type) continue;
-			const warehouseType = mapDbtType(target.type);
-			if (!warehouseType) continue;
-			connections.push({
-				profileName,
-				targetName,
-				isDefaultTarget: targetName === defaultTarget,
-				type: warehouseType,
-				config: target
-			});
-		}
-	}
-	return connections;
-}
-
 //#endregion
 //#region src/lib/dbt/mapping.ts
 /**
@@ -1839,14 +2241,15 @@ async function previewCommand(datasourceName, sql, options) {
 //#region src/commands/validate.ts
 async function validateCommand(options = {}) {
 	const cwd = process.cwd();
-	if (!fs.existsSync(path.join(cwd, "bon.yaml"))) {
+	const paths = getProjectPaths(cwd);
+	if (!fs.existsSync(paths.config)) {
 		console.log(pc.red("No bon.yaml found. Are you in a Bonnard project?"));
 		process.exit(1);
 	}
-	const { validate } = await import("./validate-C4EHvJzJ.mjs");
+	const { validate } = await import("./validate-BUHevw7F.mjs");
 	const result = await validate(cwd);
 	if (result.cubes.length === 0 && result.views.length === 0 && result.valid) {
-		console.log(pc.yellow("No model or view files found in models/ or views/."));
+		console.log(pc.yellow(`No model or view files found in ${BONNARD_DIR}/models/ or ${BONNARD_DIR}/views/.`));
 		return;
 	}
 	if (!result.valid) {
@@ -1881,7 +2284,7 @@ async function validateCommand(options = {}) {
 * Lenient: warns but doesn't fail validation
 */
 async function testReferencedConnections(cwd) {
-	const { extractDatasourcesFromModels } = await import("./models-IsV2sX74.mjs");
+	const { extractDatasourcesFromModels } = await import("./models-CzOWi3fU.mjs");
 	const { loadLocalDatasources, resolveEnvVarsInCredentials } = await Promise.resolve().then(() => local_exports);
 	const { testConnection } = await Promise.resolve().then(() => connection_exports);
 	const references = extractDatasourcesFromModels(cwd);
@@ -1949,12 +2352,13 @@ function collectFiles(dir, rootDir) {
 }
 async function deployCommand(options = {}) {
 	const cwd = process.cwd();
-	if (!fs.existsSync(path.join(cwd, "bon.yaml"))) {
+	const paths = getProjectPaths(cwd);
+	if (!fs.existsSync(paths.config)) {
 		console.log(pc.red("No bon.yaml found. Are you in a Bonnard project?"));
 		process.exit(1);
 	}
 	console.log(pc.dim("Validating models..."));
-	const { validate } = await import("./validate-C4EHvJzJ.mjs");
+	const { validate } = await import("./validate-BUHevw7F.mjs");
 	const result = await validate(cwd);
 	if (!result.valid) {
 		console.log(pc.red("Validation failed:\n"));
@@ -1962,14 +2366,14 @@ async function deployCommand(options = {}) {
 		process.exit(1);
 	}
 	if (result.cubes.length === 0 && result.views.length === 0) {
-		console.log(pc.yellow("No model or view files found in models/ or views/. Nothing to deploy."));
+		console.log(pc.yellow(`No model or view files found in ${BONNARD_DIR}/models/ or ${BONNARD_DIR}/views/. Nothing to deploy.`));
 		process.exit(1);
 	}
 	console.log(pc.dim(`  Found ${result.cubes.length} cube(s) and ${result.views.length} view(s)`));
 	if (await testAndSyncDatasources(cwd, options)) process.exit(1);
 	const files = {
-		...collectFiles(path.join(cwd, "models"), cwd),
-		...collectFiles(path.join(cwd, "views"), cwd)
+		...collectFiles(paths.models, cwd),
+		...collectFiles(paths.views, cwd)
 	};
 	const fileCount = Object.keys(files).length;
 	console.log(pc.dim(`Deploying ${fileCount} file(s)...`));
@@ -1993,7 +2397,7 @@ async function deployCommand(options = {}) {
 * Returns true if any connection failed (strict mode)
 */
 async function testAndSyncDatasources(cwd, options = {}) {
-	const { extractDatasourcesFromModels } = await import("./models-IsV2sX74.mjs");
+	const { extractDatasourcesFromModels } = await import("./models-CzOWi3fU.mjs");
 	const { loadLocalDatasources, resolveEnvVarsInCredentials } = await Promise.resolve().then(() => local_exports);
 	const { testConnection } = await Promise.resolve().then(() => connection_exports);
 	const { pushDatasource } = await Promise.resolve().then(() => push_exports);
@@ -2399,7 +2803,7 @@ async function cubeQueryCommand(queryInput, options = {}) {
 //#region src/bin/bon.ts
 const { version } = createRequire(import.meta.url)("../../package.json");
 program.name("bon").description("Bonnard semantic layer CLI").version(version);
-program.command("init").description("Create bon.yaml, models/, views/, .bon/, and agent templates (.claude/, .cursor/)").action(initCommand);
+program.command("init").description("Create bon.yaml, bonnard/models/, bonnard/views/, .bon/, and agent templates (.claude/, .cursor/)").action(initCommand);
 program.command("login").description("Authenticate with Bonnard via your browser").action(loginCommand);
 program.command("logout").description("Remove stored credentials").action(logoutCommand);
 program.command("whoami").description("Show current login status").option("--verify", "Verify session is still valid with the server").action(whoamiCommand);
@@ -2410,7 +2814,7 @@ datasource.command("test").description("Test data source connectivity by connect
 datasource.command("remove").description("Remove a data source from .bon/datasources.yaml (local by default)").argument("<name>", "Data source name").option("--remote", "Remove from Bonnard server instead of local (requires login)").action(datasourceRemoveCommand);
 datasource.command("push").description("Push a local data source to Bonnard server (requires login)").argument("<name>", "Data source name from .bon/datasources.yaml").option("--force", "Overwrite if already exists on remote").action(datasourcePushCommand);
 program.command("preview").description("Preview data from a local warehouse using raw SQL (for development/exploration)").argument("<datasource>", "Data source name from .bon/datasources.yaml").argument("<sql>", "SQL query to execute").option("--schema <schema>", "Override schema").option("--database <database>", "Override database").option("--limit <limit>", "Max rows to return", "1000").option("--format <format>", "Output format: toon or json", "toon").action(previewCommand);
-program.command("validate").description("Validate YAML syntax in models/ and views/").option("--test-connection", "Also test datasource connections (warns on failure, doesn't block)").action(validateCommand);
+program.command("validate").description("Validate YAML syntax in bonnard/models/ and bonnard/views/").option("--test-connection", "Also test datasource connections (warns on failure, doesn't block)").action(validateCommand);
 program.command("deploy").description("Deploy models to Bonnard. Requires login, validates models, tests connections (fails on error)").option("--ci", "Non-interactive mode (fail if missing datasources)").option("--push-datasources", "Auto-push missing datasources without prompting").action(deployCommand);
 program.command("mcp").description("MCP connection info and setup instructions").action(mcpCommand).command("test").description("Test MCP server connectivity").action(mcpTestCommand);
 program.command("cube").description("Query the deployed Cube semantic layer").command("query").description("Execute a query against the deployed semantic layer").argument("<query>", "JSON query or SQL (with --sql flag)").option("--sql", "Use Cube SQL API instead of JSON format").option("--limit <limit>", "Max rows to return").option("--format <format>", "Output format: toon or json", "toon").action(cubeQueryCommand);
@@ -2418,4 +2822,4 @@ program.command("docs").description("Browse Cube documentation for building mode
 program.parse();
 
 //#endregion
-export {  };
+export { getProjectPaths as t };

package/dist/bin/{models-IsV2sX74.mjs → models-CzOWi3fU.mjs}

@@ -1,3 +1,4 @@
+import { t as getProjectPaths } from "./bon.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import YAML from "yaml";
@@ -48,12 +49,13 @@ function extractFromFile(filePath) {
 	return datasourceToCubes;
 }
 /**
-* Extract all unique datasource references from models/ and views/ directories
+* Extract all unique datasource references from bonnard/models/ and bonnard/views/ directories
 * Returns datasource names mapped to the cubes that use them
 */
 function extractDatasourcesFromModels(projectPath) {
-	const modelsDir = path.join(projectPath, "models");
-	const viewsDir = path.join(projectPath, "views");
+	const paths = getProjectPaths(projectPath);
+	const modelsDir = paths.models;
+	const viewsDir = paths.views;
 	const allFiles = [...collectYamlFiles(modelsDir), ...collectYamlFiles(viewsDir)];
 	const aggregated = /* @__PURE__ */ new Map();
 	for (const file of allFiles) {

package/dist/bin/{validate-C4EHvJzJ.mjs → validate-BUHevw7F.mjs}

@@ -1,3 +1,4 @@
+import { t as getProjectPaths } from "./bon.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import YAML from "yaml";
@@ -59,8 +60,9 @@ function checkMissingDescriptions(files) {
 	return missing;
 }
 function createModelRepository(projectPath) {
-	const modelsDir = path.join(projectPath, "models");
-	const viewsDir = path.join(projectPath, "views");
+	const paths = getProjectPaths(projectPath);
+	const modelsDir = paths.models;
+	const viewsDir = paths.views;
 	return {
 		localPath: () => projectPath,
 		dataSchemaFiles: () => {

package/dist/docs/topics/cubes.md

@@ -90,10 +90,10 @@ cubes:
 
 ## File Organization
 
-One cube per file in the `models/` directory:
+One cube per file in the `bonnard/models/` directory:
 
 ```
-models/
+bonnard/models/
 ├── orders.yaml
 ├── users.yaml
 ├── products.yaml

package/dist/docs/topics/views.md

@@ -113,10 +113,10 @@ views:
 
 ## File Organization
 
-Store views in the `views/` directory:
+Store views in the `bonnard/views/` directory:
 
 ```
-views/
+bonnard/views/
 ├── orders_overview.yaml
 ├── sales_dashboard.yaml
 └── customer_360.yaml

package/dist/docs/topics/workflow.deploy.md

@@ -32,9 +32,9 @@ bon deploy
 bon deploy
 
 ✓ Validating models...
-  ✓ models/orders.yaml
-  ✓ models/users.yaml
-  ✓ views/orders_overview.yaml
+  ✓ bonnard/models/orders.yaml
+  ✓ bonnard/models/users.yaml
+  ✓ bonnard/views/orders_overview.yaml
 
 ✓ Testing connections...
   ✓ datasource "default" connected
@@ -58,8 +58,8 @@ bon deploy
     ├── 2. Test all datasource connections (must succeed)
     │
     ├── 3. Upload to Bonnard API
-    │       - cubes from models/
-    │       - views from views/
+    │       - cubes from bonnard/models/
+    │       - views from bonnard/views/
     │       - datasource configs
     │
     └── 4. Activate deployment
@@ -72,7 +72,7 @@ bon deploy
 ```
 ✗ Validating models...
 
-models/orders.yaml:15:5
+bonnard/models/orders.yaml:15:5
   error: Unknown measure type "counts"
 
 Deploy aborted. Fix validation errors first.
@@ -102,8 +102,8 @@ Run: bon login
 
 | Source | Deployed |
 |--------|----------|
-| `models/*.yaml` | All cube definitions |
-| `views/*.yaml` | All view definitions |
+| `bonnard/models/*.yaml` | All cube definitions |
+| `bonnard/views/*.yaml` | All view definitions |
 | `.bon/datasources.yaml` | Connection configs (credentials encrypted) |
 | `bon.yaml` | Project settings |
 

package/dist/docs/topics/workflow.md

@@ -15,7 +15,7 @@ bon init
 # 2. Add a data source
 bon datasource add
 
-# 3. Create models in models/ and views in views/
+# 3. Create models in bonnard/models/ and views in bonnard/views/
 
 # 4. Validate your models
 bon validate
@@ -31,10 +31,11 @@ After `bon init`, your project has:
 ```
 my-project/
 ├── bon.yaml              # Project configuration
-├── models/               # Cube definitions
-│   └── orders.yaml
-├── views/                # View definitions
-│   └── orders_overview.yaml
+├── bonnard/              # Semantic layer definitions
+│   ├── models/           # Cube definitions
+│   │   └── orders.yaml
+│   └── views/            # View definitions
+│       └── orders_overview.yaml
 └── .bon/                 # Local config (gitignored)
     └── datasources.yaml  # Data source credentials
 ```
@@ -46,7 +47,7 @@ my-project/
 Create cubes that map to your database tables:
 
 ```yaml
-# models/orders.yaml
+# bonnard/models/orders.yaml
 cubes:
   - name: orders
     sql_table: public.orders
@@ -66,7 +67,7 @@ cubes:
 Create views that expose cubes to consumers:
 
 ```yaml
-# views/orders_overview.yaml
+# bonnard/views/orders_overview.yaml
 views:
   - name: orders_overview
     cubes:
@@ -98,7 +99,7 @@ bon deploy
 ### One Cube Per File
 
 ```
-models/
+bonnard/models/
 ├── orders.yaml
 ├── users.yaml
 ├── products.yaml
@@ -108,7 +109,7 @@ models/
 ### Related Cubes Together
 
 ```
-models/
+bonnard/models/
 ├── sales/
 │   ├── orders.yaml
 │   └── line_items.yaml

package/dist/docs/topics/workflow.validate.md

@@ -48,9 +48,9 @@ bon validate --test-connection
 
 ```
 ✓ Validating YAML syntax...
-✓ Checking models/orders.yaml
-✓ Checking models/users.yaml
-✓ Checking views/orders_overview.yaml
+✓ Checking bonnard/models/orders.yaml
+✓ Checking bonnard/models/users.yaml
+✓ Checking bonnard/views/orders_overview.yaml
 
 All models valid.
 ```
@@ -60,7 +60,7 @@ All models valid.
 ```
 ✗ Validating YAML syntax...
 
-models/orders.yaml:15:5
+bonnard/models/orders.yaml:15:5
   error: Unknown measure type "counts"
 
   Did you mean "count"?

package/dist/templates/claude/skills/bonnard-queries/SKILL.md

@@ -49,8 +49,8 @@ views:
 
 ## Workflow
 
-1. Define models in `models/*.yaml`
-2. Define views in `views/*.yaml`
+1. Define models in `bonnard/models/*.yaml`
+2. Define views in `bonnard/views/*.yaml`
 3. Run `bon validate` to check syntax
 4. Run `bon deploy` to publish
 

package/dist/templates/cursor/rules/bonnard-queries.mdc

@@ -43,7 +43,7 @@ views:
 
 ## Workflow
 
-1. Define models in `models/*.yaml`
-2. Define views in `views/*.yaml`
+1. Define models in `bonnard/models/*.yaml`
+2. Define views in `bonnard/views/*.yaml`
 3. Run `bon validate` to check syntax
 4. Run `bon deploy` to publish

package/dist/templates/shared/bonnard.md

@@ -29,11 +29,12 @@ Data Warehouse (Snowflake, Postgres, BigQuery, Databricks)
 ```
 my-project/
 ├── bon.yaml              # Project config
-├── models/               # Cube definitions
-│   ├── orders.yaml
-│   └── customers.yaml
-├── views/                # View definitions
-│   └── sales_overview.yaml
+├── bonnard/              # Semantic layer definitions
+│   ├── models/           # Cube definitions
+│   │   ├── orders.yaml
+│   │   └── customers.yaml
+│   └── views/            # View definitions
+│       └── sales_overview.yaml
 └── .bon/                 # Local state (gitignored)
     └── datasources.yaml  # Warehouse connections
 ```
@@ -72,8 +73,8 @@ Topics follow dot notation (e.g., `cubes.dimensions.time`). Use `--recursive` to
 ## Workflow
 
 1. **Setup datasource** — `bon datasource add --from-dbt` or manual
-2. **Create cubes** — Define measures/dimensions in `models/*.yaml`
-3. **Create views** — Compose cubes in `views/*.yaml`
+2. **Create cubes** — Define measures/dimensions in `bonnard/models/*.yaml`
+3. **Create views** — Compose cubes in `bonnard/views/*.yaml`
 4. **Validate** — `bon validate --test-connection`
 5. **Deploy** — `bon login` then `bon deploy`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonnard/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "bin": {
     "bon": "./dist/bin/bon.mjs"
@@ -9,7 +9,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsdown src/bin/bon.ts --format esm --out-dir dist/bin && cp -r src/templates dist/ && cp -r src/docs dist/",
+    "build": "tsdown src/bin/bon.ts --format esm --out-dir dist/bin && cp -r src/templates dist/ && mkdir -p dist/docs/topics dist/docs/schemas && cp ../content/index.md dist/docs/_index.md && cp ../content/modeling/*.md dist/docs/topics/",
     "dev": "tsdown src/bin/bon.ts --format esm --out-dir dist/bin --watch",
     "test": "vitest run"
   },

package/dist/docs/README.md

@@ -1,78 +0,0 @@
-# Bonnard CLI Documentation
-
-This directory contains the documentation served by `bon docs`.
-
-## Structure
-
-```
-docs/
-├── _index.md           # Index shown by `bon docs` (llms.txt style)
-├── topics/             # Individual topic files
-│   ├── cubes.md
-│   ├── cubes.measures.md
-│   ├── cubes.measures.types.md
-│   └── ...
-├── schemas/            # JSON schemas for validation
-│   ├── cube.schema.json
-│   └── view.schema.json
-└── README.md           # This file
-```
-
-## Topic Naming Convention
-
-Topic IDs use dot notation that maps directly to filenames:
-
-| Topic ID | File |
-|----------|------|
-| `cubes` | `topics/cubes.md` |
-| `cubes.measures` | `topics/cubes.measures.md` |
-| `cubes.measures.types` | `topics/cubes.measures.types.md` |
-
-## Topic File Format
-
-Each topic file should follow this structure:
-
-```markdown
-# topic.name
-
-> Brief one-line description.
-
-## Overview
-
-Short explanation (2-3 sentences).
-
-## Example
-
-```yaml
-# Minimal working example
-```
-
-## Reference
-
-| Property | Type | Description |
-|----------|------|-------------|
-| name | string | ... |
-
-## See Also
-
-- related.topic
-- another.topic
-
-```
-
-## Guidelines
-
-- Keep topics concise (~20-40 lines)
-- Lead with examples, not theory
-- Use tables for property references
-- Include "See Also" for discoverability
-
-## Commands
-
-```bash
-bon docs                    # Show index
-bon docs <topic>            # Show specific topic
-bon docs <topic> --recursive # Show topic + children
-bon docs --search <query>   # Search topics
-bon docs schema <type>      # Show JSON schema
-```

package/dist/templates/claude/rules/bonnard.md

@@ -1,15 +0,0 @@
-# Bonnard Analytics
-
-This project uses Bonnard for semantic layer analytics.
-
-## Quick Reference
-
-| Command | Purpose |
-|---------|---------|
-| `bon validate` | Validate models and views |
-| `bon deploy` | Deploy to Cube |
-| `bon query <ds> <sql>` | Run SQL query |
-| `bon datasource list` | List data sources |
-
-For detailed CLI help: `/bonnard-cli`
-For query patterns: `/bonnard-queries`

package/dist/templates/cursor/rules/bonnard.mdc

@@ -1,20 +0,0 @@
----
-description: "Bonnard analytics project context"
-alwaysApply: true
----
-
-# Bonnard Analytics
-
-This project uses Bonnard for semantic layer analytics.
-
-## Quick Reference
-
-| Command | Purpose |
-|---------|---------|
-| `bon validate` | Validate models and views |
-| `bon deploy` | Deploy to Cube |
-| `bon query <ds> <sql>` | Run SQL query |
-| `bon datasource list` | List data sources |
-
-For detailed CLI help, ask about "bonnard cli commands".
-For query patterns, ask about "bonnard queries".