@funkai/cli 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funkai/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "description": "CLI for the funkai AI SDK framework",
   "keywords": [
@@ -26,18 +26,18 @@
   },
   "type": "module",
   "dependencies": {
-    "@kidd-cli/core": "^0.4.0",
+    "@kidd-cli/core": "^0.5.0",
     "liquidjs": "^10.25.0",
     "ts-pattern": "^5.9.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@funkai/prompts": "0.1.0"
+    "@funkai/prompts": "0.1.2"
   },
   "devDependencies": {
-    "@kidd-cli/cli": "^0.2.0",
+    "@kidd-cli/cli": "^0.3.0",
     "@types/node": "^25.5.0",
     "@vitest/coverage-v8": "^4.1.0",
-    "tsdown": "^0.21.2",
+    "tsdown": "^0.21.3",
     "typescript": "^5.9.3",
     "vitest": "^4.1.0"
   },

package/src/commands/generate.ts

@@ -1,78 +1,20 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-
 import { command } from "@kidd-cli/core";
-import { match } from "ts-pattern";
-import { z } from "zod";
 
-import { generatePromptModule, generateRegistry } from "@/lib/prompts/codegen.js";
-import { hasLintErrors } from "@/lib/prompts/lint.js";
-import { runGeneratePipeline } from "@/lib/prompts/pipeline.js";
+import { generateArgs, handleGenerate } from "./prompts/generate.js";
 
 export default command({
   description: "Run all code generation across the funkai SDK",
-  args: z.object({
-    out: z.string().describe("Output directory for generated files"),
-    roots: z.array(z.string()).describe("Root directories to scan for .prompt files"),
-    partials: z.string().optional().describe("Custom partials directory"),
-    silent: z.boolean().default(false).describe("Suppress output except errors"),
-  }),
+  args: generateArgs,
   handler(ctx) {
-    const { out, roots, partials, silent } = ctx.args;
+    const { silent } = ctx.args;
 
     // --- Prompts codegen ---
     if (!silent) {
       ctx.logger.info("Running prompts code generation...");
     }
 
-    const { discovered, lintResults, prompts } = runGeneratePipeline({ roots, out, partials });
-
-    if (!silent) {
-      ctx.logger.info(`Found ${discovered} prompt(s)`);
-    }
-
-    for (const prompt of prompts) {
-      if (!silent) {
-        const varCount = prompt.schema.length;
-        const varList = match(varCount > 0)
-          .with(true, () => ` (${prompt.schema.map((v) => v.name).join(", ")})`)
-          .otherwise(() => "");
-        ctx.logger.step(`${prompt.name}${varList}`);
-      }
-    }
-
-    for (const result of lintResults) {
-      for (const diag of result.diagnostics) {
-        if (diag.level === "error") {
-          ctx.logger.error(diag.message);
-        } else {
-          ctx.logger.warn(diag.message);
-        }
-      }
-    }
-
-    if (hasLintErrors([...lintResults])) {
-      ctx.fail("Lint errors found. Fix them before generating.");
-    }
-
-    const outDir = resolve(out);
-    // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: output directory from CLI config
-    mkdirSync(outDir, { recursive: true });
-
-    for (const prompt of prompts) {
-      const content = generatePromptModule(prompt);
-      // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: writing generated module to output directory
-      writeFileSync(resolve(outDir, `${prompt.name}.ts`), content, "utf-8");
-    }
-
-    const registryContent = generateRegistry([...prompts]);
-    // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: writing generated registry to output directory
-    writeFileSync(resolve(outDir, "index.ts"), registryContent, "utf-8");
+    handleGenerate(ctx.args, ctx.logger, ctx.fail);
 
     // --- Future: agents codegen ---
-
-    if (!silent) {
-      ctx.logger.success(`Generated ${prompts.length} prompt module(s) + registry → ${outDir}`);
-    }
   },
 });

package/src/commands/prompts/generate.ts

@@ -2,70 +2,97 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 
 import { command } from "@kidd-cli/core";
-import { match } from "ts-pattern";
 import { z } from "zod";
 
 import { generatePromptModule, generateRegistry } from "@/lib/prompts/codegen.js";
 import { hasLintErrors } from "@/lib/prompts/lint.js";
 import { runGeneratePipeline } from "@/lib/prompts/pipeline.js";
 
-export default command({
-  description: "Generate TypeScript modules from .prompt files",
-  args: z.object({
-    out: z.string().describe("Output directory for generated files"),
-    roots: z.array(z.string()).describe("Root directories to scan for .prompt files"),
-    partials: z.string().optional().describe("Custom partials directory"),
-    silent: z.boolean().default(false).describe("Suppress output except errors"),
-  }),
-  handler(ctx) {
-    const { out, roots, partials, silent } = ctx.args;
+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"),
+  partials: z.string().optional().describe("Custom partials directory"),
+  silent: z.boolean().default(false).describe("Suppress output except errors"),
+});
+
+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.
+ */
+export function handleGenerate(
+  args: {
+    readonly out: string;
+    readonly roots: readonly string[];
+    readonly partials?: string;
+    readonly silent: boolean;
+  },
+  logger: {
+    info: (msg: string) => void;
+    step: (msg: string) => void;
+    error: (msg: string) => void;
+    warn: (msg: string) => void;
+    success: (msg: string) => void;
+  },
+  fail: (msg: string) => never,
+): void {
+  const { out, roots, partials, silent } = args;
+
+  const { discovered, lintResults, prompts } = runGeneratePipeline({ roots, out, partials });
 
-    const { discovered, lintResults, prompts } = runGeneratePipeline({ roots, out, partials });
+  if (!silent) {
+    logger.info(`Found ${discovered} prompt(s)`);
+  }
 
-    if (!silent) {
-      ctx.logger.info(`Found ${discovered} prompt(s)`);
+  if (!silent) {
+    for (const prompt of prompts) {
+      const varList =
+        prompt.schema.length > 0 ? ` (${prompt.schema.map((v) => v.name).join(", ")})` : "";
+      logger.step(`${prompt.name}${varList}`);
     }
+  }
 
-    if (!silent) {
-      prompts.forEach((prompt) => {
-        const varCount = prompt.schema.length;
-        const varList = match(varCount > 0)
-          .with(true, () => ` (${prompt.schema.map((v) => v.name).join(", ")})`)
-          .otherwise(() => "");
-        ctx.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);
+      }
     }
+  }
 
-    lintResults
-      .flatMap((result) => result.diagnostics)
-      .forEach((diag) => {
-        if (diag.level === "error") {
-          ctx.logger.error(diag.message);
-        } else {
-          ctx.logger.warn(diag.message);
-        }
-      });
+  if (hasLintErrors(lintResults)) {
+    fail("Lint errors found. Fix them before generating.");
+  }
 
-    if (hasLintErrors([...lintResults])) {
-      ctx.fail("Lint errors found. Fix them before generating.");
-    }
+  const outDir = resolve(out);
+  // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: output directory from CLI config
+  mkdirSync(outDir, { recursive: true });
 
-    const outDir = resolve(out);
-    // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: output directory from CLI config
-    mkdirSync(outDir, { recursive: true });
+  for (const prompt of prompts) {
+    const content = generatePromptModule(prompt);
+    // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: writing generated module to output directory
+    writeFileSync(resolve(outDir, `${prompt.name}.ts`), content, "utf-8");
+  }
 
-    prompts.forEach((prompt) => {
-      const content = generatePromptModule(prompt);
-      // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: writing generated module to output directory
-      writeFileSync(resolve(outDir, `${prompt.name}.ts`), content, "utf-8");
-    });
+  const registryContent = generateRegistry(prompts);
+  // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: writing generated registry to output directory
+  writeFileSync(resolve(outDir, "index.ts"), registryContent, "utf-8");
 
-    const registryContent = generateRegistry([...prompts]);
-    // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: writing generated registry to output directory
-    writeFileSync(resolve(outDir, "index.ts"), registryContent, "utf-8");
+  if (!silent) {
+    logger.success(`Generated ${prompts.length} prompt module(s) + registry → ${outDir}`);
+  }
+}
 
-    if (!silent) {
-      ctx.logger.success(`Generated ${prompts.length} prompt module(s) + registry → ${outDir}`);
-    }
+export default command({
+  description: "Generate TypeScript modules from .prompt files",
+  args: generateArgs,
+  handler(ctx) {
+    handleGenerate(ctx.args, ctx.logger, ctx.fail);
   },
 });

package/src/commands/prompts/lint.ts

@@ -1,57 +1,75 @@
 import { command } from "@kidd-cli/core";
-import { match } from "ts-pattern";
 import { z } from "zod";
 
 import { hasLintErrors } from "@/lib/prompts/lint.js";
 import { runLintPipeline } from "@/lib/prompts/pipeline.js";
 
-export default command({
-  description: "Validate .prompt files for schema/template mismatches",
-  args: z.object({
-    roots: z.array(z.string()).describe("Root directories to scan for .prompt files"),
-    partials: z.string().optional().describe("Custom partials directory"),
-    silent: z.boolean().default(false).describe("Suppress output except errors"),
-  }),
-  handler(ctx) {
-    const { roots, partials, silent } = ctx.args;
+export const lintArgs = z.object({
+  roots: z.array(z.string()).describe("Root directories to scan for .prompt files"),
+  partials: z.string().optional().describe("Custom partials directory"),
+  silent: z.boolean().default(false).describe("Suppress output except errors"),
+});
 
-    const { discovered, results } = runLintPipeline({ roots, partials });
+export type LintArgs = z.infer<typeof lintArgs>;
 
-    if (!silent) {
-      ctx.logger.info(`Linting ${discovered} prompt(s)...`);
-    }
+/**
+ * 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.
+ */
+export function handleLint(
+  args: { readonly roots: readonly string[]; readonly partials?: string; readonly silent: boolean },
+  logger: {
+    info: (msg: string) => void;
+    error: (msg: string) => void;
+    warn: (msg: string) => void;
+  },
+  fail: (msg: string) => never,
+): void {
+  const { roots, partials, silent } = args;
 
-    const diagnostics = results.flatMap((result) => result.diagnostics);
-
-    diagnostics.forEach((diag) => {
-      if (diag.level === "error") {
-        ctx.logger.error(diag.message);
-      } else {
-        ctx.logger.warn(diag.message);
-      }
-    });
-
-    const errorCount = diagnostics.filter((d) => d.level === "error").length;
-    const warnCount = diagnostics.filter((d) => d.level !== "error").length;
-
-    if (!silent) {
-      const summary = [
-        `${discovered} prompt(s) linted`,
-        match(errorCount > 0)
-          .with(true, () => `${errorCount} error(s)`)
-          .otherwise(() => undefined),
-        match(warnCount > 0)
-          .with(true, () => `${warnCount} warning(s)`)
-          .otherwise(() => undefined),
-      ]
-        .filter(Boolean)
-        .join(", ");
-
-      ctx.logger.info(summary);
-    }
+  const { discovered, results } = runLintPipeline({ roots, partials });
+
+  if (!silent) {
+    logger.info(`Linting ${discovered} prompt(s)...`);
+  }
+
+  const diagnostics = results.flatMap((result) => result.diagnostics);
 
-    if (hasLintErrors([...results])) {
-      ctx.fail("Lint errors found.");
+  for (const diag of diagnostics) {
+    if (diag.level === "error") {
+      logger.error(diag.message);
+    } else {
+      logger.warn(diag.message);
     }
+  }
+
+  const errorCount = diagnostics.filter((d) => d.level === "error").length;
+  const warnCount = diagnostics.filter((d) => d.level !== "error").length;
+
+  if (!silent) {
+    const summary = [
+      `${discovered} prompt(s) linted`,
+      errorCount > 0 ? `${errorCount} error(s)` : undefined,
+      warnCount > 0 ? `${warnCount} warning(s)` : undefined,
+    ]
+      .filter(Boolean)
+      .join(", ");
+
+    logger.info(summary);
+  }
+
+  if (hasLintErrors(results)) {
+    fail("Lint errors found.");
+  }
+}
+
+export default command({
+  description: "Validate .prompt files for schema/template mismatches",
+  args: lintArgs,
+  handler(ctx) {
+    handleLint(ctx.args, ctx.logger, ctx.fail);
   },
 });

package/src/commands/prompts/setup.ts

@@ -2,7 +2,6 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 
 import { command } from "@kidd-cli/core";
-import { match } from "ts-pattern";
 
 const VSCODE_DIR = ".vscode";
 const SETTINGS_FILE = "settings.json";
@@ -76,14 +75,10 @@ export default command({
 
     if (shouldGitignore) {
       const gitignorePath = resolve(GITIGNORE_FILE);
-      const existing = match(existsSync(gitignorePath))
-        .with(true, () => readFileSync(gitignorePath, "utf-8"))
-        .otherwise(() => "");
+      const existing = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
 
       if (!existing.includes(GITIGNORE_ENTRY)) {
-        const separator = match(existing.length > 0 && !existing.endsWith("\n"))
-          .with(true, () => "\n")
-          .otherwise(() => "");
+        const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
         const block = `${separator}\n# Generated prompt client (created by \`funkai prompts generate\`)\n${GITIGNORE_ENTRY}\n`;
         writeFileSync(gitignorePath, existing + block, "utf-8");
         ctx.logger.success(`Added ${GITIGNORE_ENTRY} to ${gitignorePath}`);

package/src/commands/validate.ts

@@ -1,45 +1,22 @@
 import { command } from "@kidd-cli/core";
-import { match } from "ts-pattern";
-import { z } from "zod";
 
-import { hasLintErrors } from "@/lib/prompts/lint.js";
-import { runLintPipeline } from "@/lib/prompts/pipeline.js";
+import { handleLint, lintArgs } from "./prompts/lint.js";
 
 export default command({
   description: "Run all validations across the funkai SDK",
-  args: z.object({
-    roots: z.array(z.string()).describe("Root directories to scan for .prompt files"),
-    partials: z.string().optional().describe("Custom partials directory"),
-    silent: z.boolean().default(false).describe("Suppress output except errors"),
-  }),
+  args: lintArgs,
   handler(ctx) {
-    const { roots, partials, silent } = ctx.args;
+    const { silent } = ctx.args;
 
     // --- Prompts validation ---
     if (!silent) {
       ctx.logger.info("Running prompts validation...");
     }
 
-    const { discovered, results } = runLintPipeline({ roots, partials });
-
-    if (!silent) {
-      ctx.logger.info(`Found ${discovered} prompt(s)`);
-    }
-
-    const diagnostics = results.flatMap((result) => result.diagnostics);
-
-    for (const diag of diagnostics) {
-      match(diag.level)
-        .with("error", () => ctx.logger.error(diag.message))
-        .otherwise(() => ctx.logger.warn(diag.message));
-    }
+    handleLint(ctx.args, ctx.logger, ctx.fail);
 
     // --- Future: agents validation ---
 
-    if (hasLintErrors([...results])) {
-      ctx.fail("Validation errors found.");
-    }
-
     if (!silent) {
       ctx.logger.success("All validations passed.");
     }

package/src/index.ts

@@ -1,7 +1,12 @@
+import { createRequire } from "node:module";
+
 import { cli } from "@kidd-cli/core";
 
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json") as { readonly version: string };
+
 await cli({
   description: "CLI for the funkai AI SDK framework",
   name: "funkai",
-  version: "0.4.0",
+  version: packageJson.version,
 });

package/src/lib/prompts/codegen.ts

@@ -6,11 +6,11 @@ import type { SchemaVariable } from "./frontmatter.js";
  * Fully parsed prompt ready for code generation.
  */
 export interface ParsedPrompt {
-  name: string;
-  group?: string;
-  schema: SchemaVariable[];
-  template: string;
-  sourcePath: string;
+  readonly name: string;
+  readonly group?: string;
+  readonly schema: readonly SchemaVariable[];
+  readonly template: string;
+  readonly sourcePath: string;
 }
 
 /**
@@ -57,7 +57,7 @@ function escapeTemplateLiteral(str: string): string {
  *
  * @private
  */
-function generateSchemaExpression(vars: SchemaVariable[]): string {
+function generateSchemaExpression(vars: readonly SchemaVariable[]): string {
   if (vars.length === 0) {
     return "z.object({})";
   }
@@ -65,9 +65,7 @@ function generateSchemaExpression(vars: SchemaVariable[]): string {
   const fields = vars
     .map((v) => {
       const base = "z.string()";
-      const expr = match(v.required)
-        .with(true, () => base)
-        .otherwise(() => `${base}.optional()`);
+      const expr = v.required ? base : `${base}.optional()`;
       return `  ${v.name}: ${expr},`;
     })
     .join("\n");
@@ -95,16 +93,14 @@ const HEADER = [
 export function generatePromptModule(prompt: ParsedPrompt): string {
   const escaped = escapeTemplateLiteral(prompt.template);
   const schemaExpr = generateSchemaExpression(prompt.schema);
-  const groupValue = match(prompt.group != null)
-    .with(true, () => `'${prompt.group}' as const`)
-    .otherwise(() => "undefined");
+  const groupValue = prompt.group != null ? `'${prompt.group}' as const` : "undefined";
 
   const lines: string[] = [
     HEADER,
     `// Source: ${prompt.sourcePath}`,
     "",
     "import { z } from 'zod'",
-    "import { engine } from '@funkai/prompts'",
+    "import { liquidEngine } from '@funkai/prompts'",
     "",
     `const schema = ${schemaExpr}`,
     "",
@@ -119,7 +115,7 @@ export function generatePromptModule(prompt: ParsedPrompt): string {
     ...match(prompt.schema.length)
       .with(0, () => [
         "  render(variables?: undefined): string {",
-        "    return engine.parseAndRenderSync(template, {})",
+        "    return liquidEngine.parseAndRenderSync(template, {})",
         "  },",
         "  validate(variables?: undefined): Variables {",
         "    return schema.parse(variables ?? {})",
@@ -127,7 +123,7 @@ export function generatePromptModule(prompt: ParsedPrompt): string {
       ])
       .otherwise(() => [
         "  render(variables: Variables): string {",
-        "    return engine.parseAndRenderSync(template, schema.parse(variables))",
+        "    return liquidEngine.parseAndRenderSync(template, schema.parse(variables))",
         "  },",
         "  validate(variables: unknown): Variables {",
         "    return schema.parse(variables)",
@@ -214,7 +210,7 @@ function serializeTree(node: TreeNode, indent: number): string[] {
  * Prompts are organized into a nested object structure based on their
  * `group` field, with each `/`-separated segment becoming a nesting level.
  */
-export function generateRegistry(prompts: ParsedPrompt[]): string {
+export function generateRegistry(prompts: readonly ParsedPrompt[]): string {
   const sorted = [...prompts].toSorted((a, b) => a.name.localeCompare(b.name));
 
   const imports = sorted

package/src/lib/prompts/flatten.ts

@@ -1,5 +1,4 @@
 import { Liquid } from "liquidjs";
-import { match } from "ts-pattern";
 
 // oxlint-disable-next-line security/detect-unsafe-regex -- template parsing, not adversarial input
 const RENDER_TAG_RE = /\{%-?\s*render\s+'([^']+)'(?:\s*,\s*(.*?))?\s*-?%\}/g;
@@ -40,12 +39,8 @@ function parseParams(raw: string, partialName: string): Record<string, string> {
  */
 function parseRenderTags(template: string): RenderTag[] {
   return [...template.matchAll(RENDER_TAG_RE)].map((m) => {
-    const rawParams = match(m[2] != null)
-      .with(true, () => m[2].trim())
-      .otherwise(() => "");
-    const params = match(rawParams.length > 0)
-      .with(true, () => parseParams(rawParams, m[1]))
-      .otherwise(() => ({}));
+    const rawParams = m[2] != null ? m[2].trim() : "";
+    const params = rawParams.length > 0 ? parseParams(rawParams, m[1]) : {};
 
     return { fullMatch: m[0], partialName: m[1], params };
   });