@bonnard/cli 0.1.4 → 0.1.6

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)...`));
@@ -1979,6 +2383,10 @@ async function deployCommand(options = {}) {
 		console.log(pc.green("Deploy successful!"));
 		console.log(`Deployment ID: ${pc.cyan(response.deployment.id)}`);
 		console.log(`Cube API: ${pc.cyan(`${response.deployment.cubeApiUrl}/cubejs-api/v1`)}`);
+		console.log();
+		console.log(pc.bold("Connect AI agents via MCP:"));
+		console.log(`  MCP URL: ${pc.cyan("https://mcp.bonnard.dev/mcp")}`);
+		console.log(pc.dim(`  Run \`bon mcp\` for setup instructions`));
 	} catch (err) {
 		console.log(pc.red(`Deploy failed: ${err instanceof Error ? err.message : err}`));
 		process.exit(1);
@@ -1989,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);
@@ -2091,6 +2499,82 @@ async function testAndSyncDatasources(cwd, options = {}) {
 	return false;
 }
 
+//#endregion
+//#region src/commands/mcp.ts
+const MCP_URL = "https://mcp.bonnard.dev/mcp";
+function mcpCommand() {
+	console.log(pc.bold("MCP Connection Info"));
+	console.log();
+	console.log(`MCP URL: ${pc.cyan(MCP_URL)}`);
+	console.log();
+	console.log(pc.bold("Setup Instructions"));
+	console.log();
+	console.log(pc.underline("Claude Desktop"));
+	console.log(`Add to ${pc.dim("~/Library/Application Support/Claude/claude_desktop_config.json")}:`);
+	console.log();
+	console.log(pc.dim(`  {`));
+	console.log(pc.dim(`    "mcpServers": {`));
+	console.log(pc.dim(`      "bonnard": {`));
+	console.log(pc.dim(`        "url": "${MCP_URL}"`));
+	console.log(pc.dim(`      }`));
+	console.log(pc.dim(`    }`));
+	console.log(pc.dim(`  }`));
+	console.log();
+	console.log(pc.underline("Cursor"));
+	console.log(`Add to ${pc.dim(".cursor/mcp.json")} in your project:`);
+	console.log();
+	console.log(pc.dim(`  {`));
+	console.log(pc.dim(`    "mcpServers": {`));
+	console.log(pc.dim(`      "bonnard": {`));
+	console.log(pc.dim(`        "url": "${MCP_URL}"`));
+	console.log(pc.dim(`      }`));
+	console.log(pc.dim(`    }`));
+	console.log(pc.dim(`  }`));
+	console.log();
+	console.log(pc.underline("Claude Code"));
+	console.log(`Add to ${pc.dim(".mcp.json")} in your project:`);
+	console.log();
+	console.log(pc.dim(`  {`));
+	console.log(pc.dim(`    "mcpServers": {`));
+	console.log(pc.dim(`      "bonnard": {`));
+	console.log(pc.dim(`        "type": "url",`));
+	console.log(pc.dim(`        "url": "${MCP_URL}"`));
+	console.log(pc.dim(`      }`));
+	console.log(pc.dim(`    }`));
+	console.log(pc.dim(`  }`));
+	console.log();
+	console.log(pc.dim("OAuth authentication happens automatically when you first connect."));
+	console.log(pc.dim("Run `bon mcp test` to verify the MCP server is reachable."));
+}
+
+//#endregion
+//#region src/commands/mcp-test.ts
+const MCP_SERVER_BASE = "https://mcp.bonnard.dev";
+async function mcpTestCommand() {
+	console.log(pc.dim("Testing MCP server connection..."));
+	console.log();
+	const url = `${MCP_SERVER_BASE}/.well-known/oauth-authorization-server`;
+	try {
+		const res = await fetch(url);
+		if (!res.ok) {
+			console.log(pc.red(`✗ MCP server returned ${res.status}`));
+			process.exit(1);
+		}
+		const metadata = await res.json();
+		console.log(pc.green("✓ MCP server is reachable"));
+		console.log();
+		console.log(`  Issuer: ${pc.dim(metadata.issuer || "unknown")}`);
+		console.log(`  Authorization: ${pc.dim(metadata.authorization_endpoint || "unknown")}`);
+		console.log(`  Token: ${pc.dim(metadata.token_endpoint || "unknown")}`);
+		console.log(`  Registration: ${pc.dim(metadata.registration_endpoint || "unknown")}`);
+		console.log();
+		console.log(pc.dim("OAuth endpoints are healthy. Agents can connect."));
+	} catch (err) {
+		console.log(pc.red(`✗ Failed to reach MCP server: ${err instanceof Error ? err.message : err}`));
+		process.exit(1);
+	}
+}
+
 //#endregion
 //#region src/commands/docs.ts
 const __filename = fileURLToPath(import.meta.url);
@@ -2319,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);
@@ -2330,11 +2814,12 @@ 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);
 program.command("docs").description("Browse Cube documentation for building models and views").argument("[topic]", "Topic to display (e.g., cubes, cubes.measures)").option("-r, --recursive", "Show topic and all child topics").option("-s, --search <query>", "Search topics for a keyword").option("-f, --format <format>", "Output format: markdown or json", "markdown").action(docsCommand).command("schema").description("Show JSON schema for a type (cube, view, measure, etc.)").argument("<type>", "Schema type to display").action(docsSchemaCommand);
 program.parse();
 
 //#endregion
-export {  };
+export { getProjectPaths as t };