@funkai/cli 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -10,7 +10,7 @@ import * as k$2 from "node:readline";
 import ot from "node:readline";
 import { ReadStream } from "node:tty";
 import fs, { existsSync, lstatSync, mkdirSync, promises, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
-import path, { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
+import path, { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { attempt, attemptAsync } from "es-toolkit";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { URL as URL$1, fileURLToPath, pathToFileURL } from "node:url";
@@ -18,13 +18,15 @@ import { homedir } from "node:os";
 import assert from "node:assert";
 import v8 from "node:v8";
 import { readFileSync as readFileSync$1, readdirSync as readdirSync$1, statSync as statSync$1, writeFile as writeFile$1 } from "fs";
-import { basename as basename$1, dirname as dirname$1, extname as extname$1, join as join$1, normalize, relative, resolve as resolve$1 } from "path";
+import { basename as basename$1, dirname as dirname$1, extname as extname$1, join as join$1, normalize, relative as relative$1, resolve as resolve$1 } from "path";
 import { createHash } from "node:crypto";
 import { parse, stringify } from "yaml";
 import { notStrictEqual, strictEqual } from "assert";
 import { format as format$1, inspect as inspect$1 } from "util";
 import { fileURLToPath as fileURLToPath$1 } from "url";
+import { configSchema } from "@funkai/config";
 import { PARTIALS_DIR, clean } from "@funkai/prompts/cli";
+import picomatch from "picomatch";
 import { Liquid } from "liquidjs";
 
 //#region \0rolldown/runtime.js
@@ -15337,7 +15339,7 @@ var init_esm = __esmMin((() => {
 			basename: basename$1,
 			dirname: dirname$1,
 			extname: extname$1,
-			relative,
+			relative: relative$1,
 			resolve: resolve$1,
 			join: join$1
 		},
@@ -18295,6 +18297,28 @@ var init_yargs = __esmMin((() => {
 	Yargs = YargsFactory(esm_default);
 }));
 
+//#endregion
+//#region src/config.ts
+/**
+* Extract the typed funkai config from a command context.
+*
+* kidd-cli's `Merge<CliConfig, TConfig>` erases augmented keys when
+* `TConfig` defaults to `Record<string, unknown>`, so we cast here.
+*
+* @param ctx - The CLI context.
+* @returns The typed funkai configuration.
+*
+* @example
+* ```ts
+* const config = getConfig(ctx);
+* const promptsConfig = config.prompts;
+* ```
+*/
+function getConfig(ctx) {
+	return ctx.config;
+}
+var init_config = __esmMin((() => {}));
+
 //#endregion
 //#region src/lib/prompts/codegen.ts
 /**
@@ -18336,6 +18360,11 @@ function formatGroupValue(group) {
 	return "undefined";
 }
 /** @private */
+function formatGroupJsdoc(group) {
+	if (group) return [" *", ` * @group ${group}`];
+	return [];
+}
+/** @private */
 function parseGroupSegments(group) {
 	if (group) return group.split("/").map(toCamelCase);
 	return [];
@@ -18353,22 +18382,70 @@ function generateSchemaExpression(vars) {
 		return `  ${v.name}: ${expr},`;
 	}).join("\n")}\n})`;
 }
+/** @private */
+function formatHeader(sourcePath) {
+	let sourceLine = "";
+	if (sourcePath) sourceLine = `//  Source:      ${sourcePath}\n`;
+	return [
+		"// ─── AUTO-GENERATED ────────────────────────────────────────",
+		`${sourceLine}//  Regenerate:  funkai prompts generate`,
+		"// ───────────────────────────────────────────────────────────"
+	].join("\n");
+}
+/**
+* Derive a unique file slug from group + name.
+*
+* Ungrouped prompts use the name alone. Grouped prompts
+* join group segments and name with hyphens.
+*
+* @param name - The prompt name (kebab-case).
+* @param group - Optional group path (e.g., 'core/agent').
+* @returns The file slug string.
+*
+* @example
+* ```ts
+* toFileSlug('system', 'core/agent')      // => 'core-agent-system'
+* toFileSlug('greeting', undefined)        // => 'greeting'
+* ```
+*/
+function toFileSlug(name, group) {
+	if (group) return `${group.replaceAll("/", "-")}-${name}`;
+	return name;
+}
+/**
+* Derive a unique import name (camelCase) from group + name.
+*
+* @param name - The prompt name (kebab-case).
+* @param group - Optional group path (e.g., 'core/agent').
+* @returns The camelCase import identifier.
+*
+* @example
+* ```ts
+* toImportName('system', 'core/agent')     // => 'coreAgentSystem'
+* toImportName('greeting', undefined)       // => 'greeting'
+* ```
+*/
+function toImportName(name, group) {
+	return toCamelCase(toFileSlug(name, group));
+}
 /**
 * Generate a per-prompt TypeScript module with a default export.
 *
-* The module contains the Zod schema, inlined template, and
-* `render` / `validate` functions.
+* The module uses `createPrompt` from `@funkai/prompts` to
+* encapsulate the Zod schema, inlined template, and render logic.
+*
+* @param prompt - The parsed prompt configuration.
+* @returns The generated TypeScript module source code.
 */
 function generatePromptModule(prompt) {
 	const escaped = escapeTemplateLiteral(prompt.template);
 	const schemaExpr = generateSchemaExpression(prompt.schema);
 	const groupValue = formatGroupValue(prompt.group);
 	return [
-		HEADER,
-		`// Source: ${prompt.sourcePath}`,
+		formatHeader(prompt.sourcePath),
 		"",
 		"import { z } from 'zod'",
-		"import { liquidEngine } from '@funkai/prompts/runtime'",
+		"import { createPrompt } from '@funkai/prompts'",
 		"",
 		`const schema = ${schemaExpr}`,
 		"",
@@ -18376,32 +18453,25 @@ function generatePromptModule(prompt) {
 		"",
 		`const template = \`${escaped}\``,
 		"",
-		"export default {",
-		`  name: '${prompt.name}' as const,`,
+		"/**",
+		` * **${prompt.name}** prompt module.`,
+		...formatGroupJsdoc(prompt.group),
+		" */",
+		"export default createPrompt<Variables>({",
+		`  name: '${prompt.name}',`,
 		`  group: ${groupValue},`,
+		"  template,",
 		"  schema,",
-		...match(prompt.schema.length).with(0, () => [
-			"  render(variables?: undefined): string {",
-			"    return liquidEngine.parseAndRenderSync(template, {})",
-			"  },",
-			"  validate(variables?: undefined): Variables {",
-			"    return schema.parse(variables ?? {})",
-			"  },"
-		]).otherwise(() => [
-			"  render(variables: Variables): string {",
-			"    return liquidEngine.parseAndRenderSync(template, schema.parse(variables))",
-			"  },",
-			"  validate(variables: unknown): Variables {",
-			"    return schema.parse(variables)",
-			"  },"
-		]),
-		"}",
+		"})",
 		""
 	].join("\n");
 }
 /**
 * Build a nested tree from sorted prompts, grouped by their `group` field.
 *
+* Leaf values are the unique import name derived from group+name,
+* so prompts with the same name in different groups do not collide.
+*
 * @param prompts - Sorted parsed prompts.
 * @returns A tree where leaves are import names and branches are group namespaces.
 * @throws If a prompt name collides with a group namespace at the same level.
@@ -18410,15 +18480,16 @@ function generatePromptModule(prompt) {
 */
 function buildTree(prompts) {
 	return prompts.reduce((root, prompt) => {
-		const importName = toCamelCase(prompt.name);
+		const leafKey = toCamelCase(prompt.name);
+		const importName = toImportName(prompt.name, prompt.group);
 		const target = parseGroupSegments(prompt.group).reduce((current, segment) => {
 			const existing = current[segment];
 			if (typeof existing === "string") throw new TypeError(`Collision: prompt "${existing}" and group namespace "${segment}" share the same key at the same level.`);
 			if (existing === null || existing === void 0) current[segment] = {};
 			return current[segment];
 		}, root);
-		if (typeof target[importName] === "object" && target[importName] !== null) throw new Error(`Collision: prompt "${importName}" conflicts with existing group namespace "${importName}" at the same level.`);
-		target[importName] = importName;
+		if (typeof target[leafKey] === "object" && target[leafKey] !== null) throw new Error(`Collision: prompt "${leafKey}" conflicts with existing group namespace "${leafKey}" at the same level.`);
+		target[leafKey] = importName;
 		return root;
 	}, {});
 }
@@ -18433,7 +18504,10 @@ function buildTree(prompts) {
 */
 function serializeTree(node, indent) {
 	const pad = "  ".repeat(indent);
-	return Object.entries(node).flatMap(([key, value]) => match(typeof value).with("string", () => [`${pad}${key},`]).otherwise(() => [
+	return Object.entries(node).flatMap(([key, value]) => match(typeof value).with("string", () => {
+		if (key === value) return [`${pad}${key},`];
+		return [`${pad}${key}: ${value},`];
+	}).otherwise(() => [
 		`${pad}${key}: {`,
 		...serializeTree(value, indent + 1),
 		`${pad}},`
@@ -18445,34 +18519,41 @@ function serializeTree(node, indent) {
 *
 * Prompts are organized into a nested object structure based on their
 * `group` field, with each `/`-separated segment becoming a nesting level.
+*
+* @param prompts - Sorted parsed prompts to include in the registry.
+* @returns The generated TypeScript source for the registry index module.
+*
+* @example
+* ```ts
+* const source = generateRegistry([
+*   { name: 'system', group: 'core/agent', schema: [], template: '...', sourcePath: 'prompts/system.prompt' },
+* ])
+* writeFileSync('index.ts', source)
+* ```
 */
 function generateRegistry(prompts) {
-	const sorted = [...prompts].toSorted((a, b) => a.name.localeCompare(b.name));
+	const sorted = [...prompts].toSorted((a, b) => {
+		const slugA = toFileSlug(a.name, a.group);
+		const slugB = toFileSlug(b.name, b.group);
+		return slugA.localeCompare(slugB);
+	});
+	const imports = sorted.map((p) => {
+		return `import ${toImportName(p.name, p.group)} from './${toFileSlug(p.name, p.group)}.js'`;
+	}).join("\n");
+	const treeLines = serializeTree(buildTree(sorted), 1);
 	return [
-		HEADER,
+		formatHeader(),
 		"",
 		"import { createPromptRegistry } from '@funkai/prompts'",
-		sorted.map((p) => `import ${toCamelCase(p.name)} from './${p.name}.js'`).join("\n"),
+		imports,
 		"",
 		"export const prompts = createPromptRegistry({",
-		...serializeTree(buildTree(sorted), 1),
+		...treeLines,
 		"})",
 		""
 	].join("\n");
 }
-var HEADER;
-var init_codegen = __esmMin((() => {
-	HEADER = [
-		"/*",
-		"|==========================================================================",
-		"| AUTO-GENERATED — DO NOT EDIT",
-		"|==========================================================================",
-		"|",
-		"| Run `funkai prompts generate` to regenerate.",
-		"|",
-		"*/"
-	].join("\n");
-}));
+var init_codegen = __esmMin((() => {}));
 
 //#endregion
 //#region src/lib/prompts/lint.ts
@@ -18791,6 +18872,31 @@ function deriveNameFromPath(filePath) {
 	return stem;
 }
 /**
+* Extract the static base directory from a glob pattern.
+*
+* Returns the longest directory prefix before any glob characters
+* (`*`, `?`, `{`, `[`). Falls back to `'.'` if the pattern starts
+* with a glob character.
+*
+* @private
+*/
+function extractBaseDir(pattern) {
+	const globChars = new Set([
+		"*",
+		"?",
+		"{",
+		"["
+	]);
+	const parts = pattern.split("/");
+	const staticParts = [];
+	for (const part of parts) {
+		if ([...part].some((ch) => globChars.has(ch))) break;
+		staticParts.push(part);
+	}
+	if (staticParts.length === 0) return ".";
+	return staticParts.join("/");
+}
+/**
 * Recursively scan a directory for `.prompt` files.
 *
 * @private
@@ -18815,21 +18921,29 @@ function scanDirectory(dir, depth) {
 	});
 }
 /**
-* Discover all `.prompt` files from the given root directories.
+* Discover all `.prompt` files matching the given include/exclude patterns.
+*
+* Extracts base directories from the include patterns, scans them
+* recursively, then filters results through picomatch.
+*
+* Name uniqueness is **not** enforced here — prompts with the same name
+* are allowed as long as they belong to different groups. Uniqueness
+* is validated downstream in the pipeline after frontmatter parsing,
+* where group information is available.
 *
-* @param roots - Directories to scan recursively.
-* @returns Sorted, deduplicated list of discovered prompts.
-* @throws If duplicate prompt names are found across roots.
+* @param options - Include and exclude glob patterns.
+* @returns Sorted list of discovered prompts.
 */
-function discoverPrompts(roots) {
-	const all = roots.flatMap((root) => scanDirectory(resolve(root), 0));
-	const duplicate = [...Map.groupBy(all, (prompt) => prompt.name).entries()].find(([, prompts]) => prompts.length > 1);
-	if (duplicate) {
-		const [name, prompts] = duplicate;
-		const paths = prompts.map((p) => p.filePath).join("\n  ");
-		throw new Error(`Duplicate prompt name "${name}" found in:\n  ${paths}`);
-	}
-	return all.toSorted((a, b) => a.name.localeCompare(b.name));
+function discoverPrompts(options) {
+	const { includes, excludes = [] } = options;
+	const all = [...new Set(includes.map((pattern) => resolve(extractBaseDir(pattern))))].flatMap((dir) => scanDirectory(dir, 0));
+	const isIncluded = picomatch(includes);
+	const isExcluded = picomatch(excludes);
+	const filtered = all.filter((prompt) => {
+		const matchPath = relative(process.cwd(), prompt.filePath).replaceAll("\\", "/");
+		return isIncluded(matchPath) && !isExcluded(matchPath);
+	});
+	return [...new Map(filtered.map((prompt) => [prompt.filePath, prompt])).values()].toSorted((a, b) => a.name.localeCompare(b.name));
 }
 var MAX_DEPTH, PROMPT_EXT;
 var init_paths = __esmMin((() => {
@@ -18841,6 +18955,42 @@ var init_paths = __esmMin((() => {
 //#endregion
 //#region src/lib/prompts/pipeline.ts
 /**
+* Validate that no two prompts share the same group+name combination.
+*
+* @param prompts - Parsed prompts with group and name fields.
+* @throws If duplicate group+name combinations are found.
+*
+* @private
+*/
+function validateUniqueness(prompts) {
+	const duplicate = [...Map.groupBy(prompts, (p) => toFileSlug(p.name, p.group)).entries()].find(([, entries]) => entries.length > 1);
+	if (duplicate) {
+		const [slug, entries] = duplicate;
+		const paths = entries.map((p) => p.sourcePath).join("\n  ");
+		throw new Error(`Duplicate prompt "${slug}" (group+name) found in:\n  ${paths}`);
+	}
+}
+/**
+* Resolve a prompt's group from config-defined group patterns.
+*
+* Matches the prompt's file path against each group's `includes`/`excludes`
+* patterns. First matching group wins.
+*
+* @param filePath - Absolute path to the prompt file.
+* @param groups - Config-defined group definitions.
+* @returns The matching group name, or undefined if no match.
+*
+* @private
+*/
+function resolveGroupFromConfig(filePath, groups) {
+	const matchPath = relative(process.cwd(), filePath).replaceAll("\\", "/");
+	for (const group of groups) {
+		const isIncluded = picomatch(group.includes);
+		const isExcluded = picomatch(group.excludes ?? []);
+		if (isIncluded(matchPath) && !isExcluded(matchPath)) return group.name;
+	}
+}
+/**
 * Resolve the list of partial directories to search.
 *
 * @private
@@ -18858,7 +19008,12 @@ function resolvePartialsDirs(customDir) {
 * @returns Lint results for all discovered prompts.
 */
 function runLintPipeline(options) {
-	const discovered = discoverPrompts([...options.roots]);
+	let excludes;
+	if (options.excludes) excludes = [...options.excludes];
+	const discovered = discoverPrompts({
+		includes: [...options.includes],
+		excludes
+	});
 	const partialsDirs = resolvePartialsDirs(resolve(options.partials ?? ".prompts/partials"));
 	const results = discovered.map((d) => {
 		const raw = readFileSync(d.filePath, "utf8");
@@ -18886,8 +19041,14 @@ function runLintPipeline(options) {
 * @returns Parsed prompts ready for code generation, along with lint results.
 */
 function runGeneratePipeline(options) {
-	const discovered = discoverPrompts([...options.roots]);
+	let excludes;
+	if (options.excludes) excludes = [...options.excludes];
+	const discovered = discoverPrompts({
+		includes: [...options.includes],
+		excludes
+	});
 	const partialsDirs = resolvePartialsDirs(resolve(options.partials ?? resolve(options.out, "../partials")));
+	const configGroups = options.groups ?? [];
 	const processed = discovered.map((d) => {
 		const raw = readFileSync(d.filePath, "utf8");
 		const frontmatter = parseFrontmatter({
@@ -18899,24 +19060,28 @@ function runGeneratePipeline(options) {
 			partialsDirs
 		});
 		const templateVars = extractVariables(template);
+		const group = frontmatter.group ?? resolveGroupFromConfig(d.filePath, configGroups);
 		return {
 			lintResult: lintPrompt(frontmatter.name, d.filePath, frontmatter.schema, templateVars),
 			prompt: {
 				name: frontmatter.name,
-				group: frontmatter.group,
+				group,
 				schema: frontmatter.schema,
 				template,
 				sourcePath: d.filePath
 			}
 		};
 	});
+	const prompts = processed.map((p) => p.prompt);
+	validateUniqueness(prompts);
 	return {
 		discovered: discovered.length,
 		lintResults: processed.map((p) => p.lintResult),
-		prompts: processed.map((p) => p.prompt)
+		prompts
 	};
 }
 var init_pipeline = __esmMin((() => {
+	init_codegen();
 	init_extract_variables();
 	init_flatten();
 	init_frontmatter();
@@ -18927,16 +19092,40 @@ var init_pipeline = __esmMin((() => {
 //#endregion
 //#region src/commands/prompts/generate.ts
 /**
+* Resolve generate args by merging CLI flags with config defaults.
+*
+* @param args - CLI arguments (take precedence).
+* @param config - Prompts config from funkai.config.ts (fallback).
+* @param fail - Error handler for missing required values.
+* @returns Resolved args with required fields guaranteed.
+*/
+function resolveGenerateArgs(args, config, fail) {
+	const out = args.out ?? (config && config.out);
+	const includes = args.includes ?? (config && config.includes) ?? ["./**"];
+	const excludes = (config && config.excludes) ?? [];
+	const partials = args.partials ?? (config && config.partials);
+	if (!out) fail("Missing --out flag. Provide it via CLI or set prompts.out in funkai.config.ts.");
+	return {
+		out,
+		includes,
+		excludes,
+		partials,
+		silent: args.silent
+	};
+}
+/**
 * Shared handler for prompts code generation.
 *
-* @param params - Handler context with args, logger, and fail callback.
+* @param params - Handler context with args, config, logger, and fail callback.
 */
-function handleGenerate({ args, logger, fail }) {
-	const { out, roots, partials, silent } = args;
+function handleGenerate({ args, config, logger, fail }) {
+	const { out, includes, excludes, partials, silent } = resolveGenerateArgs(args, config, fail);
 	const { discovered, lintResults, prompts } = runGeneratePipeline({
-		roots,
+		includes,
+		excludes,
 		out,
-		partials
+		partials,
+		groups: config && config.groups
 	});
 	if (!silent) logger.info(`Found ${discovered} prompt(s)`);
 	if (!silent) for (const prompt of prompts) {
@@ -18951,7 +19140,7 @@ function handleGenerate({ args, logger, fail }) {
 	mkdirSync(outDir, { recursive: true });
 	for (const prompt of prompts) {
 		const content = generatePromptModule(prompt);
-		writeFileSync(resolve(outDir, `${prompt.name}.ts`), content, "utf8");
+		writeFileSync(resolve(outDir, `${toFileSlug(prompt.name, prompt.group)}.ts`), content, "utf8");
 	}
 	const registryContent = generateRegistry(prompts);
 	writeFileSync(resolve(outDir, "index.ts"), registryContent, "utf8");
@@ -18965,12 +19154,13 @@ function formatVarList(schema) {
 var generateArgs, generate_default$1;
 var init_generate$1 = __esmMin((() => {
 	init_dist();
+	init_config();
 	init_codegen();
 	init_lint$1();
 	init_pipeline();
 	generateArgs = z.object({
-		out: z.string().describe("Output directory for generated files"),
-		roots: z.array(z.string()).describe("Root directories to scan for .prompt files"),
+		out: z.string().optional().describe("Output directory for generated files"),
+		includes: z.array(z.string()).optional().describe("Glob patterns to scan for .prompt files"),
 		partials: z.string().optional().describe("Custom partials directory"),
 		silent: z.boolean().default(false).describe("Suppress output except errors")
 	});
@@ -18978,8 +19168,10 @@ var init_generate$1 = __esmMin((() => {
 		description: "Generate TypeScript modules from .prompt files",
 		options: generateArgs,
 		handler(ctx) {
+			const config = getConfig(ctx);
 			handleGenerate({
 				args: ctx.args,
+				config: config.prompts,
 				logger: ctx.logger,
 				fail: ctx.fail
 			});
@@ -18993,14 +19185,17 @@ var generate_default;
 var init_generate = __esmMin((() => {
 	init_dist();
 	init_generate$1();
+	init_config();
 	generate_default = command({
 		description: "Run all code generation across the funkai SDK",
 		options: generateArgs,
 		handler(ctx) {
 			const { silent } = ctx.args;
+			const config = getConfig(ctx);
 			if (!silent) ctx.logger.info("Running prompts code generation...");
 			handleGenerate({
 				args: ctx.args,
+				config: config.prompts,
 				logger: ctx.logger,
 				fail: ctx.fail
 			});
@@ -19009,18 +19204,230 @@ var init_generate = __esmMin((() => {
 }));
 
 //#endregion
-//#region src/commands/setup.ts
-var setup_default$1;
+//#region src/commands/prompts/setup.ts
+/**
+* Shared prompts setup logic used by both `funkai prompts setup` and `funkai setup`.
+*
+* @param ctx - The CLI context with prompts and logger.
+*/
+async function setupPrompts(ctx) {
+	if (await ctx.prompts.confirm({
+		message: "Configure VSCode to treat .prompt files as Markdown with Liquid syntax?",
+		initialValue: true
+	})) {
+		const vscodeDir = resolve(VSCODE_DIR);
+		mkdirSync(vscodeDir, { recursive: true });
+		const settingsPath = resolve(vscodeDir, SETTINGS_FILE);
+		const settings = readJsonFile(settingsPath);
+		const updatedSettings = {
+			...settings,
+			"files.associations": {
+				...settings["files.associations"] ?? {},
+				"*.prompt": "markdown"
+			},
+			"liquid.engine": "standard"
+		};
+		writeFileSync(settingsPath, `${JSON.stringify(updatedSettings, null, 2)}\n`, "utf8");
+		ctx.logger.success(`Updated ${settingsPath}`);
+	}
+	if (await ctx.prompts.confirm({
+		message: "Add Shopify Liquid extension to VSCode recommendations?",
+		initialValue: true
+	})) {
+		const vscodeDir = resolve(VSCODE_DIR);
+		mkdirSync(vscodeDir, { recursive: true });
+		const extensionsPath = resolve(vscodeDir, EXTENSIONS_FILE);
+		const extensions = readJsonFile(extensionsPath);
+		const recommendations = ensureRecommendation(extensions.recommendations ?? [], "sissel.shopify-liquid");
+		const updatedExtensions = {
+			...extensions,
+			recommendations
+		};
+		writeFileSync(extensionsPath, `${JSON.stringify(updatedExtensions, null, 2)}\n`, "utf8");
+		ctx.logger.success(`Updated ${extensionsPath}`);
+	}
+	if (await ctx.prompts.confirm({
+		message: "Add .prompts/client/ to .gitignore? (generated client should not be committed)",
+		initialValue: true
+	})) {
+		const gitignorePath = resolve(GITIGNORE_FILE);
+		const existing = readFileOrEmpty(gitignorePath);
+		if (existing.includes(GITIGNORE_ENTRY)) ctx.logger.info(`${GITIGNORE_ENTRY} already in ${gitignorePath}`);
+		else {
+			writeFileSync(gitignorePath, `${existing}${`${trailingSeparator(existing)}\n# Generated prompt client (created by \`funkai prompts generate\`)\n${GITIGNORE_ENTRY}\n`}`, "utf8");
+			ctx.logger.success(`Added ${GITIGNORE_ENTRY} to ${gitignorePath}`);
+		}
+	}
+	if (await ctx.prompts.confirm({
+		message: "Add ~prompts path alias to tsconfig.json?",
+		initialValue: true
+	})) {
+		const tsconfigPath = resolve(TSCONFIG_FILE);
+		const tsconfig = readJsonFile(tsconfigPath);
+		const compilerOptions = tsconfig.compilerOptions ?? {};
+		const existingPaths = compilerOptions.paths ?? {};
+		if (existingPaths[PROMPTS_ALIAS]) ctx.logger.info(`${PROMPTS_ALIAS} alias already in ${tsconfigPath}`);
+		else {
+			const updatedTsconfig = {
+				...tsconfig,
+				compilerOptions: {
+					...compilerOptions,
+					paths: {
+						...existingPaths,
+						[PROMPTS_ALIAS]: [PROMPTS_ALIAS_PATH]
+					}
+				}
+			};
+			writeFileSync(tsconfigPath, `${JSON.stringify(updatedTsconfig, null, 2)}\n`, "utf8");
+			ctx.logger.success(`Added ${PROMPTS_ALIAS} alias to ${tsconfigPath}`);
+		}
+	}
+}
+/** @private */
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+/** @private */
+function ensureRecommendation(current, id) {
+	if (current.includes(id)) return [...current];
+	return [...current, id];
+}
+/** @private */
+function readFileOrEmpty(filePath) {
+	if (existsSync(filePath)) return readFileSync(filePath, "utf8");
+	return "";
+}
+/** @private */
+function trailingSeparator(content) {
+	if (content.length > 0 && !content.endsWith("\n")) return "\n";
+	return "";
+}
+/**
+* Read a JSON file, returning an empty object if it doesn't exist.
+* Throws if the file exists but contains invalid JSON, preventing
+* silent data loss from overwriting malformed config files.
+*
+* @private
+*/
+function readJsonFile(filePath) {
+	if (!existsSync(filePath)) return {};
+	const content = readFileSync(filePath, "utf8");
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		throw new Error(`Failed to parse ${filePath}: ${errorMessage(error)}. Fix the JSON syntax or remove the file before running setup.`, { cause: error });
+	}
+}
+var VSCODE_DIR, SETTINGS_FILE, EXTENSIONS_FILE, GITIGNORE_FILE, TSCONFIG_FILE, GITIGNORE_ENTRY, PROMPTS_ALIAS, PROMPTS_ALIAS_PATH, setup_default$1;
 var init_setup$1 = __esmMin((() => {
 	init_dist();
+	VSCODE_DIR = ".vscode";
+	SETTINGS_FILE = "settings.json";
+	EXTENSIONS_FILE = "extensions.json";
+	GITIGNORE_FILE = ".gitignore";
+	TSCONFIG_FILE = "tsconfig.json";
+	GITIGNORE_ENTRY = ".prompts/client/";
+	PROMPTS_ALIAS = "~prompts";
+	PROMPTS_ALIAS_PATH = "./.prompts/client/index.ts";
 	setup_default$1 = command({
+		description: "Configure VSCode IDE settings for .prompt files",
+		async handler(ctx) {
+			ctx.logger.intro("Prompt SDK — Project Setup");
+			await setupPrompts(ctx);
+			ctx.logger.outro("Prompts setup complete.");
+		}
+	});
+}));
+
+//#endregion
+//#region src/commands/setup.ts
+/** @private */
+function buildConfigTemplate({ hasPrompts, hasAgents, includes, out }) {
+	if (hasPrompts && hasAgents) return buildCustomTemplate(includes, out, true);
+	if (hasPrompts) return buildCustomTemplate(includes, out, false);
+	return CONFIG_TEMPLATE_AGENTS_ONLY;
+}
+/** @private */
+function buildCustomTemplate(includes, out, includeAgents) {
+	return `import { defineConfig } from "@funkai/config";
+
+export default defineConfig({
+  prompts: {
+    includes: [${includes.map((r) => `"${r}"`).join(", ")}],
+    out: "${out}",
+  },${match(includeAgents).with(true, () => "\n  agents: {},\n").with(false, () => "\n").exhaustive()}});
+`;
+}
+var CONFIG_TEMPLATE_AGENTS_ONLY, setup_default;
+var init_setup = __esmMin((() => {
+	init_dist();
+	init_setup$1();
+	CONFIG_TEMPLATE_AGENTS_ONLY = `import { defineConfig } from "@funkai/config";
+
+export default defineConfig({
+  agents: {},
+});
+`;
+	setup_default = command({
 		description: "Set up your project for the funkai SDK",
 		async handler(ctx) {
 			ctx.logger.intro("funkai — Project Setup");
-			ctx.logger.info("Run domain-specific setup commands:");
-			ctx.logger.step("funkai prompts setup  — Configure IDE and project for .prompt files");
-			ctx.logger.step("funkai agents setup   — (coming soon)");
-			ctx.logger.outro("Choose the setup command for your domain.");
+			const domains = await ctx.prompts.multiselect({
+				message: "Which domains do you want to set up?",
+				options: [{
+					value: "prompts",
+					label: "Prompts",
+					hint: "LiquidJS templating, codegen, IDE integration"
+				}, {
+					value: "agents",
+					label: "Agents",
+					hint: "Agent scaffolding and configuration"
+				}],
+				initialValues: ["prompts"],
+				required: true
+			});
+			const hasPrompts = domains.includes("prompts");
+			const hasAgents = domains.includes("agents");
+			if (await ctx.prompts.confirm({
+				message: "Create funkai.config.ts?",
+				initialValue: true
+			})) {
+				let includes = ["src/prompts/**"];
+				let out = ".prompts/client";
+				if (hasPrompts) {
+					includes = (await ctx.prompts.text({
+						message: "Prompt include patterns (comma-separated)",
+						defaultValue: "src/prompts/**",
+						placeholder: "src/prompts/**"
+					})).split(",").map((r) => r.trim());
+					out = await ctx.prompts.text({
+						message: "Output directory for generated prompt modules",
+						defaultValue: ".prompts/client",
+						placeholder: ".prompts/client"
+					});
+				}
+				const template = buildConfigTemplate({
+					hasPrompts,
+					hasAgents,
+					includes,
+					out
+				});
+				const configPath = resolve("funkai.config.ts");
+				writeFileSync(configPath, template, "utf8");
+				ctx.logger.success(`Created ${configPath}`);
+			}
+			if (hasPrompts) {
+				ctx.logger.info("");
+				ctx.logger.info("Configuring Prompts...");
+				await setupPrompts(ctx);
+			}
+			if (hasAgents) {
+				ctx.logger.info("");
+				ctx.logger.info("Agents configuration is not yet available.");
+				ctx.logger.info("The agents section has been added to your config for future use.");
+			}
+			ctx.logger.outro("Project setup complete.");
 		}
 	});
 }));
@@ -19028,14 +19435,31 @@ var init_setup$1 = __esmMin((() => {
 //#endregion
 //#region src/commands/prompts/lint.ts
 /**
+* Resolve lint args by merging CLI flags with config defaults.
+*
+* @param args - CLI arguments (take precedence).
+* @param config - Prompts config from funkai.config.ts (fallback).
+* @param fail - Error handler for missing required values.
+* @returns Resolved args with required fields guaranteed.
+*/
+function resolveLintArgs(args, config, _fail) {
+	return {
+		includes: args.includes ?? (config && config.includes) ?? ["./**"],
+		excludes: (config && config.excludes) ?? [],
+		partials: args.partials ?? (config && config.partials),
+		silent: args.silent
+	};
+}
+/**
 * Shared handler for prompts lint/validation.
 *
-* @param params - Handler context with args, logger, and fail callback.
+* @param params - Handler context with args, config, logger, and fail callback.
 */
-function handleLint({ args, logger, fail }) {
-	const { roots, partials, silent } = args;
+function handleLint({ args, config, logger, fail }) {
+	const { includes, excludes, partials, silent } = resolveLintArgs(args, config, fail);
 	const { discovered, results } = runLintPipeline({
-		roots,
+		includes,
+		excludes,
 		partials
 	});
 	if (!silent) logger.info(`Linting ${discovered} prompt(s)...`);
@@ -19055,10 +19479,11 @@ function handleLint({ args, logger, fail }) {
 var lintArgs, lint_default;
 var init_lint = __esmMin((() => {
 	init_dist();
+	init_config();
 	init_lint$1();
 	init_pipeline();
 	lintArgs = z.object({
-		roots: z.array(z.string()).describe("Root directories to scan for .prompt files"),
+		includes: z.array(z.string()).optional().describe("Glob patterns to scan for .prompt files"),
 		partials: z.string().optional().describe("Custom partials directory"),
 		silent: z.boolean().default(false).describe("Suppress output except errors")
 	});
@@ -19066,8 +19491,10 @@ var init_lint = __esmMin((() => {
 		description: "Validate .prompt files for schema/template mismatches",
 		options: lintArgs,
 		handler(ctx) {
+			const config = getConfig(ctx);
 			handleLint({
 				args: ctx.args,
+				config: config.prompts,
 				logger: ctx.logger,
 				fail: ctx.fail
 			});
@@ -19081,14 +19508,17 @@ var validate_default$1;
 var init_validate$1 = __esmMin((() => {
 	init_dist();
 	init_lint();
+	init_config();
 	validate_default$1 = command({
 		description: "Run all validations across the funkai SDK",
 		options: lintArgs,
 		handler(ctx) {
 			const { silent } = ctx.args;
+			const config = getConfig(ctx);
 			if (!silent) ctx.logger.info("Running prompts validation...");
 			handleLint({
 				args: ctx.args,
+				config: config.prompts,
 				logger: ctx.logger,
 				fail: ctx.fail
 			});
@@ -19116,6 +19546,7 @@ var init_validate = __esmMin((() => {
 var createTemplate, create_default;
 var init_create = __esmMin((() => {
 	init_dist();
+	init_config();
 	createTemplate = (name) => `---
 name: ${name}
 ---
@@ -19125,15 +19556,27 @@ name: ${name}
 		description: "Create a new .prompt file",
 		options: z.object({
 			name: z.string().describe("Prompt name (kebab-case)"),
-			out: z.string().optional().describe("Output directory (defaults to cwd)"),
+			out: z.string().optional().describe("Output directory (defaults to first root in config or cwd)"),
 			partial: z.boolean().default(false).describe("Create as a partial in .prompts/partials/")
 		}),
 		handler(ctx) {
 			const { name, out, partial } = ctx.args;
+			const promptsConfig = getConfig(ctx).prompts;
+			const firstInclude = match(promptsConfig).with({ includes: P.array(P.string).select() }, (includes) => {
+				if (includes.length > 0) {
+					const [pattern] = includes;
+					const staticParts = pattern.split("/").filter((p) => !p.includes("*") && !p.includes("?"));
+					if (staticParts.length > 0) return staticParts.join("/");
+					return;
+				}
+			}).otherwise(() => void 0);
 			const dir = match({
 				partial,
 				out
-			}).with({ partial: true }, () => resolve(".prompts/partials")).with({ out: P.string }, ({ out: outDir }) => resolve(outDir)).otherwise(() => process.cwd());
+			}).with({ partial: true }, () => resolve(".prompts/partials")).with({ out: P.string }, ({ out: outDir }) => resolve(outDir)).otherwise(() => {
+				if (firstInclude) return resolve(firstInclude);
+				return process.cwd();
+			});
 			const filePath = resolve(dir, `${name}.prompt`);
 			if (existsSync(filePath)) ctx.fail(`File already exists: ${filePath}`);
 			mkdirSync(dir, { recursive: true });
@@ -19143,135 +19586,6 @@ name: ${name}
 	});
 }));
 
-//#endregion
-//#region src/commands/prompts/setup.ts
-/** @private */
-function errorMessage(error) {
-	if (error instanceof Error) return error.message;
-	return String(error);
-}
-/** @private */
-function ensureRecommendation(current, id) {
-	if (current.includes(id)) return [...current];
-	return [...current, id];
-}
-/** @private */
-function readFileOrEmpty(filePath) {
-	if (existsSync(filePath)) return readFileSync(filePath, "utf8");
-	return "";
-}
-/** @private */
-function trailingSeparator(content) {
-	if (content.length > 0 && !content.endsWith("\n")) return "\n";
-	return "";
-}
-/**
-* Read a JSON file, returning an empty object if it doesn't exist.
-* Throws if the file exists but contains invalid JSON, preventing
-* silent data loss from overwriting malformed config files.
-*
-* @private
-*/
-function readJsonFile(filePath) {
-	if (!existsSync(filePath)) return {};
-	const content = readFileSync(filePath, "utf8");
-	try {
-		return JSON.parse(content);
-	} catch (error) {
-		throw new Error(`Failed to parse ${filePath}: ${errorMessage(error)}. Fix the JSON syntax or remove the file before running setup.`, { cause: error });
-	}
-}
-var VSCODE_DIR, SETTINGS_FILE, EXTENSIONS_FILE, GITIGNORE_FILE, TSCONFIG_FILE, GITIGNORE_ENTRY, PROMPTS_ALIAS, PROMPTS_ALIAS_PATH, setup_default;
-var init_setup = __esmMin((() => {
-	init_dist();
-	VSCODE_DIR = ".vscode";
-	SETTINGS_FILE = "settings.json";
-	EXTENSIONS_FILE = "extensions.json";
-	GITIGNORE_FILE = ".gitignore";
-	TSCONFIG_FILE = "tsconfig.json";
-	GITIGNORE_ENTRY = ".prompts/client/";
-	PROMPTS_ALIAS = "~prompts";
-	PROMPTS_ALIAS_PATH = "./.prompts/client/index.ts";
-	setup_default = command({
-		description: "Configure VSCode IDE settings for .prompt files",
-		async handler(ctx) {
-			ctx.logger.intro("Prompt SDK — Project Setup");
-			if (await ctx.prompts.confirm({
-				message: "Configure VSCode to treat .prompt files as Markdown with Liquid syntax?",
-				initialValue: true
-			})) {
-				const vscodeDir = resolve(VSCODE_DIR);
-				mkdirSync(vscodeDir, { recursive: true });
-				const settingsPath = resolve(vscodeDir, SETTINGS_FILE);
-				const settings = readJsonFile(settingsPath);
-				const updatedSettings = {
-					...settings,
-					"files.associations": {
-						...settings["files.associations"] ?? {},
-						"*.prompt": "markdown"
-					},
-					"liquid.engine": "standard"
-				};
-				writeFileSync(settingsPath, `${JSON.stringify(updatedSettings, null, 2)}\n`, "utf8");
-				ctx.logger.success(`Updated ${settingsPath}`);
-			}
-			if (await ctx.prompts.confirm({
-				message: "Add Shopify Liquid extension to VSCode recommendations?",
-				initialValue: true
-			})) {
-				const vscodeDir = resolve(VSCODE_DIR);
-				mkdirSync(vscodeDir, { recursive: true });
-				const extensionsPath = resolve(vscodeDir, EXTENSIONS_FILE);
-				const extensions = readJsonFile(extensionsPath);
-				const recommendations = ensureRecommendation(extensions.recommendations ?? [], "sissel.shopify-liquid");
-				const updatedExtensions = {
-					...extensions,
-					recommendations
-				};
-				writeFileSync(extensionsPath, `${JSON.stringify(updatedExtensions, null, 2)}\n`, "utf8");
-				ctx.logger.success(`Updated ${extensionsPath}`);
-			}
-			if (await ctx.prompts.confirm({
-				message: "Add .prompts/client/ to .gitignore? (generated client should not be committed)",
-				initialValue: true
-			})) {
-				const gitignorePath = resolve(GITIGNORE_FILE);
-				const existing = readFileOrEmpty(gitignorePath);
-				if (existing.includes(GITIGNORE_ENTRY)) ctx.logger.info(`${GITIGNORE_ENTRY} already in ${gitignorePath}`);
-				else {
-					writeFileSync(gitignorePath, `${existing}${`${trailingSeparator(existing)}\n# Generated prompt client (created by \`funkai prompts generate\`)\n${GITIGNORE_ENTRY}\n`}`, "utf8");
-					ctx.logger.success(`Added ${GITIGNORE_ENTRY} to ${gitignorePath}`);
-				}
-			}
-			if (await ctx.prompts.confirm({
-				message: "Add ~prompts path alias to tsconfig.json?",
-				initialValue: true
-			})) {
-				const tsconfigPath = resolve(TSCONFIG_FILE);
-				const tsconfig = readJsonFile(tsconfigPath);
-				const compilerOptions = tsconfig.compilerOptions ?? {};
-				const existingPaths = compilerOptions.paths ?? {};
-				if (existingPaths[PROMPTS_ALIAS]) ctx.logger.info(`${PROMPTS_ALIAS} alias already in ${tsconfigPath}`);
-				else {
-					const updatedTsconfig = {
-						...tsconfig,
-						compilerOptions: {
-							...compilerOptions,
-							paths: {
-								...existingPaths,
-								[PROMPTS_ALIAS]: [PROMPTS_ALIAS_PATH]
-							}
-						}
-					};
-					writeFileSync(tsconfigPath, `${JSON.stringify(updatedTsconfig, null, 2)}\n`, "utf8");
-					ctx.logger.success(`Added ${PROMPTS_ALIAS} alias to ${tsconfigPath}`);
-				}
-			}
-			ctx.logger.outro("Project setup complete.");
-		}
-	});
-}));
-
 //#endregion
 //#region \0virtual:kidd-static-commands
 var _virtual_kidd_static_commands_exports = /* @__PURE__ */ __exportAll$1({ autoload: () => autoload$1 });
@@ -19282,23 +19596,23 @@ var commands;
 var init__virtual_kidd_static_commands = __esmMin((() => {
 	init_tag();
 	init_generate();
-	init_setup$1();
+	init_setup();
 	init_validate$1();
 	init_validate();
 	init_create();
 	init_generate$1();
 	init_lint();
-	init_setup();
+	init_setup$1();
 	commands = {
 		"generate": generate_default,
-		"setup": setup_default$1,
+		"setup": setup_default,
 		"validate": validate_default$1,
 		"agents": withTag({ commands: { "validate": validate_default } }, "Command"),
 		"prompts": withTag({ commands: {
 			"create": create_default,
 			"generate": generate_default$1,
 			"lint": lint_default,
-			"setup": setup_default
+			"setup": setup_default$1
 		} }, "Command")
 	};
 }));
@@ -20139,7 +20453,7 @@ function resolveVersion(explicit) {
 		return err(VERSION_ERROR);
 	}
 	{
-		const parsed = VersionSchema.safeParse("0.2.0");
+		const parsed = VersionSchema.safeParse("0.3.0");
 		if (parsed.success) return ok(parsed.data);
 	}
 	return err(VERSION_ERROR);
@@ -20327,16 +20641,18 @@ init_generate();
 init_create();
 init_generate$1();
 init_lint();
-init_setup();
 init_setup$1();
+init_setup();
 init_validate$1();
+init_config();
 await cli({
 	description: "CLI for the funkai AI SDK framework",
 	name: "funkai",
 	version: createRequire(import.meta.url)("../package.json").version,
+	config: { schema: configSchema },
 	commands: {
 		generate: generate_default,
-		setup: setup_default$1,
+		setup: setup_default,
 		validate: validate_default$1,
 		agents: command({
 			description: "Agent-related commands",
@@ -20348,7 +20664,7 @@ await cli({
 				create: create_default,
 				generate: generate_default$1,
 				lint: lint_default,
-				setup: setup_default
+				setup: setup_default$1
 			}
 		})
 	}