@funkai/cli 0.1.4 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funkai/cli",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "private": false,
   "description": "CLI for the funkai AI SDK framework",
   "keywords": [
@@ -30,15 +30,19 @@
   },
   "dependencies": {
     "@kidd-cli/core": "^0.10.0",
+    "es-toolkit": "^1.45.1",
     "liquidjs": "^10.25.0",
+    "picomatch": "^4.0.3",
     "ts-pattern": "^5.9.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@funkai/prompts": "0.2.0"
+    "@funkai/config": "0.2.0",
+    "@funkai/prompts": "0.4.0"
   },
   "devDependencies": {
     "@kidd-cli/cli": "^0.4.9",
     "@types/node": "^25.5.0",
+    "@types/picomatch": "^4.0.2",
     "@vitest/coverage-v8": "^4.1.0",
     "tsdown": "^0.21.4",
     "typescript": "^5.9.3",

package/src/commands/generate.ts

@@ -1,19 +1,26 @@
 import { command } from "@kidd-cli/core";
 
 import { generateArgs, handleGenerate } from "./prompts/generate.js";
+import { getConfig } from "@/config.js";
 
 export default command({
   description: "Run all code generation across the funkai SDK",
   options: generateArgs,
   handler(ctx) {
     const { silent } = ctx.args;
+    const config = getConfig(ctx);
 
     // --- Prompts codegen ---
     if (!silent) {
       ctx.logger.info("Running prompts code generation...");
     }
 
-    handleGenerate(ctx.args, ctx.logger, ctx.fail);
+    handleGenerate({
+      args: ctx.args,
+      config: config.prompts,
+      logger: ctx.logger,
+      fail: ctx.fail,
+    });
 
     // --- Future: agents codegen ---
   },

package/src/commands/prompts/create.ts

@@ -5,6 +5,9 @@ import { command } from "@kidd-cli/core";
 import { match, P } from "ts-pattern";
 import { z } from "zod";
 
+import { getConfig } from "@/config.js";
+
+/** @private */
 const createTemplate = (name: string) => `---
 name: ${name}
 ---
@@ -15,15 +18,41 @@ export default command({
   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 config = getConfig(ctx);
+    const promptsConfig = config.prompts;
+    const firstInclude = match(promptsConfig)
+      .with({ includes: P.array(P.string).select() }, (includes) => {
+        if (includes.length > 0) {
+          // Extract the static base directory from the first include pattern
+          const [pattern] = includes;
+          const parts = pattern.split("/");
+          const staticParts = parts.filter((p) => !p.includes("*") && !p.includes("?"));
+          if (staticParts.length > 0) {
+            return staticParts.join("/");
+          }
+          return undefined;
+        }
+        return undefined;
+      })
+      .otherwise(() => undefined);
+
     const dir = match({ partial, out })
       .with({ partial: true }, () => resolve(".prompts/partials"))
       .with({ out: P.string }, ({ out: outDir }) => resolve(outDir))
-      .otherwise(() => process.cwd());
+      .otherwise(() => {
+        if (firstInclude) {
+          return resolve(firstInclude);
+        }
+        return process.cwd();
+      });
     const filePath = resolve(dir, `${name}.prompt`);
 
     // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: user-provided CLI argument for prompt file creation

package/src/commands/prompts/generate.ts

@@ -1,48 +1,94 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 
+import type { FunkaiConfig } from "@funkai/config";
 import { command } from "@kidd-cli/core";
+import { match } from "ts-pattern";
 import { z } from "zod";
 
-import { generatePromptModule, generateRegistry } from "@/lib/prompts/codegen.js";
+import { getConfig } from "@/config.js";
+import { generatePromptModule, generateRegistry, toFileSlug } from "@/lib/prompts/codegen.js";
 import { hasLintErrors } from "@/lib/prompts/lint.js";
 import { runGeneratePipeline } from "@/lib/prompts/pipeline.js";
 
+/** Zod schema for the `prompts generate` CLI arguments. */
 export const 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"),
 });
 
+/** Inferred type of the `prompts generate` CLI arguments. */
 export type GenerateArgs = z.infer<typeof generateArgs>;
 
 /**
- * Shared handler for prompts code generation.
- *
- * @param args - Parsed CLI arguments.
- * @param logger - Logger instance from the command context.
- * @param fail - Failure callback from the command context.
+ * Parameters for the shared generate handler.
  */
-export function handleGenerate(
-  args: {
-    readonly out: string;
-    readonly roots: readonly string[];
+export interface HandleGenerateParams {
+  readonly args: {
+    readonly out?: string;
+    readonly includes?: readonly string[];
     readonly partials?: string;
     readonly silent: boolean;
-  },
-  logger: {
+  };
+  readonly config?: FunkaiConfig["prompts"];
+  readonly logger: {
     info: (msg: string) => void;
     step: (msg: string) => void;
     error: (msg: string) => void;
     warn: (msg: string) => void;
     success: (msg: string) => void;
-  },
+  };
+  readonly fail: (msg: string) => never;
+}
+
+/**
+ * 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: HandleGenerateParams["args"],
+  config: FunkaiConfig["prompts"],
   fail: (msg: string) => never,
-): void {
-  const { out, roots, partials, silent } = args;
+): {
+  readonly out: string;
+  readonly includes: readonly string[];
+  readonly excludes: readonly string[];
+  readonly partials?: string;
+  readonly silent: boolean;
+} {
+  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, config, logger, and fail callback.
+ */
+export function handleGenerate({ args, config, logger, fail }: HandleGenerateParams): void {
+  const { out, includes, excludes, partials, silent } = resolveGenerateArgs(args, config, fail);
 
-  const { discovered, lintResults, prompts } = runGeneratePipeline({ roots, out, partials });
+  const { discovered, lintResults, prompts } = runGeneratePipeline({
+    includes,
+    excludes,
+    out,
+    partials,
+    groups: config && config.groups,
+  });
 
   if (!silent) {
     logger.info(`Found ${discovered} prompt(s)`);
@@ -50,25 +96,20 @@ export function handleGenerate(
 
   if (!silent) {
     for (const prompt of prompts) {
-      // oxlint-disable-next-line unicorn/prefer-ternary -- no-ternary rule forbids ternaries
-      const varList: string = (() => {
-        if (prompt.schema.length > 0) {
-          return ` (${prompt.schema.map((v) => v.name).join(", ")})`;
-        }
-        return "";
-      })();
+      const varList = formatVarList(prompt.schema);
       logger.step(`${prompt.name}${varList}`);
     }
   }
 
-  for (const result of lintResults) {
-    for (const diag of result.diagnostics) {
-      if (diag.level === "error") {
-        logger.error(diag.message);
-      } else {
-        logger.warn(diag.message);
-      }
-    }
+  for (const diag of lintResults.flatMap((result) => result.diagnostics)) {
+    match(diag.level)
+      .with("error", () => logger.error(diag.message))
+      .with("warn", () => {
+        if (!silent) {
+          logger.warn(diag.message);
+        }
+      })
+      .exhaustive();
   }
 
   if (hasLintErrors(lintResults)) {
@@ -81,8 +122,9 @@ export function handleGenerate(
 
   for (const prompt of prompts) {
     const content = generatePromptModule(prompt);
+    const fileSlug = toFileSlug(prompt.name, prompt.group);
     // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: writing generated module to output directory
-    writeFileSync(resolve(outDir, `${prompt.name}.ts`), content, "utf8");
+    writeFileSync(resolve(outDir, `${fileSlug}.ts`), content, "utf8");
   }
 
   const registryContent = generateRegistry(prompts);
@@ -94,10 +136,24 @@ export function handleGenerate(
   }
 }
 
+/** @private */
+function formatVarList(schema: readonly { readonly name: string }[]): string {
+  if (schema.length > 0) {
+    return ` (${schema.map((v) => v.name).join(", ")})`;
+  }
+  return "";
+}
+
 export default command({
   description: "Generate TypeScript modules from .prompt files",
   options: generateArgs,
   handler(ctx) {
-    handleGenerate(ctx.args, ctx.logger, ctx.fail);
+    const config = getConfig(ctx);
+    handleGenerate({
+      args: ctx.args,
+      config: config.prompts,
+      logger: ctx.logger,
+      fail: ctx.fail,
+    });
   },
 });

package/src/commands/prompts/lint.ts

@@ -1,36 +1,74 @@
+import type { FunkaiConfig } from "@funkai/config";
 import { command } from "@kidd-cli/core";
+import { match } from "ts-pattern";
 import { z } from "zod";
 
+import { getConfig } from "@/config.js";
 import { hasLintErrors } from "@/lib/prompts/lint.js";
 import { runLintPipeline } from "@/lib/prompts/pipeline.js";
 
+/** Zod schema for the `prompts lint` CLI arguments. */
 export const 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"),
 });
 
+/** Inferred type of the `prompts lint` CLI arguments. */
 export type LintArgs = z.infer<typeof lintArgs>;
 
 /**
- * Shared handler for prompts lint/validation.
- *
- * @param args - Parsed CLI arguments.
- * @param logger - Logger instance from the command context.
- * @param fail - Failure callback from the command context.
+ * Parameters for the shared lint handler.
  */
-export function handleLint(
-  args: { readonly roots: readonly string[]; readonly partials?: string; readonly silent: boolean },
-  logger: {
+export interface HandleLintParams {
+  readonly args: {
+    readonly includes?: readonly string[];
+    readonly partials?: string;
+    readonly silent: boolean;
+  };
+  readonly config?: FunkaiConfig["prompts"];
+  readonly logger: {
     info: (msg: string) => void;
     error: (msg: string) => void;
     warn: (msg: string) => void;
-  },
-  fail: (msg: string) => never,
-): void {
-  const { roots, partials, silent } = args;
+  };
+  readonly fail: (msg: string) => never;
+}
+
+/**
+ * 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: HandleLintParams["args"],
+  config: FunkaiConfig["prompts"],
+  _fail: (msg: string) => never,
+): {
+  readonly includes: readonly string[];
+  readonly excludes: readonly string[];
+  readonly partials?: string;
+  readonly silent: boolean;
+} {
+  const includes = args.includes ?? (config && config.includes) ?? ["./**"];
+  const excludes = (config && config.excludes) ?? [];
+  const partials = args.partials ?? (config && config.partials);
 
-  const { discovered, results } = runLintPipeline({ roots, partials });
+  return { includes, excludes, partials, silent: args.silent };
+}
+
+/**
+ * Shared handler for prompts lint/validation.
+ *
+ * @param params - Handler context with args, config, logger, and fail callback.
+ */
+export function handleLint({ args, config, logger, fail }: HandleLintParams): void {
+  const { includes, excludes, partials, silent } = resolveLintArgs(args, config, fail);
+
+  const { discovered, results } = runLintPipeline({ includes, excludes, partials });
 
   if (!silent) {
     logger.info(`Linting ${discovered} prompt(s)...`);
@@ -39,11 +77,10 @@ export function handleLint(
   const diagnostics = results.flatMap((result) => result.diagnostics);
 
   for (const diag of diagnostics) {
-    if (diag.level === "error") {
-      logger.error(diag.message);
-    } else {
-      logger.warn(diag.message);
-    }
+    match(diag.level)
+      .with("error", () => logger.error(diag.message))
+      .with("warn", () => logger.warn(diag.message))
+      .exhaustive();
   }
 
   const errorCount = diagnostics.filter((d) => d.level === "error").length;
@@ -71,6 +108,12 @@ export default command({
   description: "Validate .prompt files for schema/template mismatches",
   options: lintArgs,
   handler(ctx) {
-    handleLint(ctx.args, ctx.logger, ctx.fail);
+    const config = getConfig(ctx);
+    handleLint({
+      args: ctx.args,
+      config: config.prompts,
+      logger: ctx.logger,
+      fail: ctx.fail,
+    });
   },
 });