@funkai/cli 0.1.4 → 0.3.0

package/src/commands/prompts/setup.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 
+import type { Context } from "@kidd-cli/core";
 import { command } from "@kidd-cli/core";
 
 const VSCODE_DIR = ".vscode";
@@ -12,138 +13,167 @@ const GITIGNORE_ENTRY = ".prompts/client/";
 const PROMPTS_ALIAS = "~prompts";
 const PROMPTS_ALIAS_PATH = "./.prompts/client/index.ts";
 
-export default command({
-  description: "Configure VSCode IDE settings for .prompt files",
-  async handler(ctx) {
-    ctx.logger.intro("Prompt SDK — Project Setup");
+/**
+ * Shared prompts setup logic used by both `funkai prompts setup` and `funkai setup`.
+ *
+ * @param ctx - The CLI context with prompts and logger.
+ */
+export async function setupPrompts(ctx: Pick<Context, "prompts" | "logger">): Promise<void> {
+  const shouldConfigure = await ctx.prompts.confirm({
+    message: "Configure VSCode to treat .prompt files as Markdown with Liquid syntax?",
+    initialValue: true,
+  });
+
+  if (shouldConfigure) {
+    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"] ?? {}) as Record<string, string>),
+        "*.prompt": "markdown",
+      },
+      "liquid.engine": "standard",
+    };
+
+    writeFileSync(settingsPath, `${JSON.stringify(updatedSettings, null, 2)}\n`, "utf8");
+    ctx.logger.success(`Updated ${settingsPath}`);
+  }
 
-    const shouldConfigure = await ctx.prompts.confirm({
-      message: "Configure VSCode to treat .prompt files as Markdown with Liquid syntax?",
-      initialValue: true,
-    });
+  const shouldRecommend = await ctx.prompts.confirm({
+    message: "Add Shopify Liquid extension to VSCode recommendations?",
+    initialValue: true,
+  });
 
-    if (shouldConfigure) {
-      const vscodeDir = resolve(VSCODE_DIR);
-      mkdirSync(vscodeDir, { recursive: true });
+  if (shouldRecommend) {
+    const vscodeDir = resolve(VSCODE_DIR);
+    mkdirSync(vscodeDir, { recursive: true });
 
-      const settingsPath = resolve(vscodeDir, SETTINGS_FILE);
-      const settings = readJsonFile(settingsPath);
+    const extensionsPath = resolve(vscodeDir, EXTENSIONS_FILE);
+    const extensions = readJsonFile(extensionsPath);
 
-      const updatedSettings = {
-        ...settings,
-        "files.associations": {
-          ...((settings["files.associations"] ?? {}) as Record<string, string>),
-          "*.prompt": "markdown",
-        },
-        "liquid.engine": "standard",
-      };
+    const currentRecs = (extensions.recommendations ?? []) as string[];
+    const extensionId = "sissel.shopify-liquid";
 
-      writeFileSync(settingsPath, `${JSON.stringify(updatedSettings, null, 2)}\n`, "utf8");
-      ctx.logger.success(`Updated ${settingsPath}`);
-    }
+    const recommendations = ensureRecommendation(currentRecs, extensionId);
+    const updatedExtensions = {
+      ...extensions,
+      recommendations,
+    };
 
-    const shouldRecommend = await ctx.prompts.confirm({
-      message: "Add Shopify Liquid extension to VSCode recommendations?",
-      initialValue: true,
-    });
-
-    if (shouldRecommend) {
-      const vscodeDir = resolve(VSCODE_DIR);
-      mkdirSync(vscodeDir, { recursive: true });
-
-      const extensionsPath = resolve(vscodeDir, EXTENSIONS_FILE);
-      const extensions = readJsonFile(extensionsPath);
-
-      const currentRecs = (extensions.recommendations ?? []) as string[];
-      const extensionId = "sissel.shopify-liquid";
-
-      // oxlint-disable-next-line unicorn/prefer-ternary -- no-ternary rule forbids ternaries
-      const recommendations: string[] = (() => {
-        if (currentRecs.includes(extensionId)) {
-          return currentRecs;
-        }
-        return [...currentRecs, extensionId];
-      })();
-      const updatedExtensions = {
-        ...extensions,
-        recommendations,
-      };
-
-      writeFileSync(extensionsPath, `${JSON.stringify(updatedExtensions, null, 2)}\n`, "utf8");
-      ctx.logger.success(`Updated ${extensionsPath}`);
-    }
+    writeFileSync(extensionsPath, `${JSON.stringify(updatedExtensions, null, 2)}\n`, "utf8");
+    ctx.logger.success(`Updated ${extensionsPath}`);
+  }
 
-    const shouldGitignore = await ctx.prompts.confirm({
-      message: "Add .prompts/client/ to .gitignore? (generated client should not be committed)",
-      initialValue: true,
-    });
-
-    if (shouldGitignore) {
-      const gitignorePath = resolve(GITIGNORE_FILE);
-      // oxlint-disable-next-line unicorn/prefer-ternary -- no-ternary rule forbids ternaries
-      const existing: string = (() => {
-        if (existsSync(gitignorePath)) {
-          return readFileSync(gitignorePath, "utf8");
-        }
-        return "";
-      })();
-
-      if (existing.includes(GITIGNORE_ENTRY)) {
-        ctx.logger.info(`${GITIGNORE_ENTRY} already in ${gitignorePath}`);
-      } else {
-        // oxlint-disable-next-line unicorn/prefer-ternary -- no-ternary rule forbids ternaries
-        const separator: string = (() => {
-          if (existing.length > 0 && !existing.endsWith("\n")) {
-            return "\n";
-          }
-          return "";
-        })();
-        const block = `${separator}\n# Generated prompt client (created by \`funkai prompts generate\`)\n${GITIGNORE_ENTRY}\n`;
-        writeFileSync(gitignorePath, `${existing}${block}`, "utf8");
-        ctx.logger.success(`Added ${GITIGNORE_ENTRY} to ${gitignorePath}`);
-      }
+  const shouldGitignore = await ctx.prompts.confirm({
+    message: "Add .prompts/client/ to .gitignore? (generated client should not be committed)",
+    initialValue: true,
+  });
+
+  if (shouldGitignore) {
+    const gitignorePath = resolve(GITIGNORE_FILE);
+    const existing = readFileOrEmpty(gitignorePath);
+
+    if (existing.includes(GITIGNORE_ENTRY)) {
+      ctx.logger.info(`${GITIGNORE_ENTRY} already in ${gitignorePath}`);
+    } else {
+      const separator = trailingSeparator(existing);
+      const block = `${separator}\n# Generated prompt client (created by \`funkai prompts generate\`)\n${GITIGNORE_ENTRY}\n`;
+      writeFileSync(gitignorePath, `${existing}${block}`, "utf8");
+      ctx.logger.success(`Added ${GITIGNORE_ENTRY} to ${gitignorePath}`);
     }
+  }
 
-    const shouldTsconfig = await ctx.prompts.confirm({
-      message: "Add ~prompts path alias to tsconfig.json?",
-      initialValue: true,
-    });
-
-    if (shouldTsconfig) {
-      const tsconfigPath = resolve(TSCONFIG_FILE);
-      const tsconfig = readJsonFile(tsconfigPath);
-
-      const compilerOptions = (tsconfig.compilerOptions ?? {}) as Record<string, unknown>;
-      const existingPaths = (compilerOptions.paths ?? {}) as Record<string, string[]>;
-
-      // oxlint-disable-next-line security/detect-object-injection -- safe: PROMPTS_ALIAS is a known constant string
-      if (existingPaths[PROMPTS_ALIAS]) {
-        ctx.logger.info(`${PROMPTS_ALIAS} alias already in ${tsconfigPath}`);
-      } else {
-        const updatedTsconfig = {
-          ...tsconfig,
-          compilerOptions: {
-            ...compilerOptions,
-            paths: {
-              ...existingPaths,
-              // oxlint-disable-next-line security/detect-object-injection -- safe: PROMPTS_ALIAS is a known constant string
-              [PROMPTS_ALIAS]: [PROMPTS_ALIAS_PATH],
-            },
+  const shouldTsconfig = await ctx.prompts.confirm({
+    message: "Add ~prompts path alias to tsconfig.json?",
+    initialValue: true,
+  });
+
+  if (shouldTsconfig) {
+    const tsconfigPath = resolve(TSCONFIG_FILE);
+    const tsconfig = readJsonFile(tsconfigPath);
+
+    const compilerOptions = (tsconfig.compilerOptions ?? {}) as Record<string, unknown>;
+    const existingPaths = (compilerOptions.paths ?? {}) as Record<string, string[]>;
+
+    // oxlint-disable-next-line security/detect-object-injection -- safe: PROMPTS_ALIAS is a known constant string
+    if (existingPaths[PROMPTS_ALIAS]) {
+      ctx.logger.info(`${PROMPTS_ALIAS} alias already in ${tsconfigPath}`);
+    } else {
+      const updatedTsconfig = {
+        ...tsconfig,
+        compilerOptions: {
+          ...compilerOptions,
+          paths: {
+            ...existingPaths,
+            // oxlint-disable-next-line security/detect-object-injection -- safe: PROMPTS_ALIAS is a known constant string
+            [PROMPTS_ALIAS]: [PROMPTS_ALIAS_PATH],
           },
-        };
+        },
+      };
 
-        writeFileSync(tsconfigPath, `${JSON.stringify(updatedTsconfig, null, 2)}\n`, "utf8");
-        ctx.logger.success(`Added ${PROMPTS_ALIAS} alias to ${tsconfigPath}`);
-      }
+      writeFileSync(tsconfigPath, `${JSON.stringify(updatedTsconfig, null, 2)}\n`, "utf8");
+      ctx.logger.success(`Added ${PROMPTS_ALIAS} alias to ${tsconfigPath}`);
     }
+  }
+}
 
-    ctx.logger.outro("Project setup complete.");
+export default 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.");
   },
 });
 
+// ---------------------------------------------------------------------------
+// Private
+// ---------------------------------------------------------------------------
+
+/** @private */
+function errorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+/** @private */
+function ensureRecommendation(current: readonly string[], id: string): string[] {
+  if (current.includes(id)) {
+    return [...current];
+  }
+  return [...current, id];
+}
+
+/** @private */
+function readFileOrEmpty(filePath: string): string {
+  // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: reading file from CLI discovery
+  if (existsSync(filePath)) {
+    return readFileSync(filePath, "utf8");
+  }
+  return "";
+}
+
+/** @private */
+function trailingSeparator(content: string): string {
+  if (content.length > 0 && !content.endsWith("\n")) {
+    return "\n";
+  }
+  return "";
+}
+
 /**
- * Read a JSON file, returning an empty object if it doesn't exist
- * or contains invalid JSON.
+ * 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: string): Record<string, unknown> {
   // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: tsconfig path from CLI discovery
@@ -151,11 +181,15 @@ function readJsonFile(filePath: string): Record<string, unknown> {
     return {};
   }
 
+  // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: reading tsconfig file
+  const content = readFileSync(filePath, "utf8");
   try {
-    // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: reading tsconfig file
-    const content = readFileSync(filePath, "utf8");
     return JSON.parse(content) as Record<string, unknown>;
-  } catch {
-    return {};
+  } catch (error) {
+    throw new Error(
+      `Failed to parse ${filePath}: ${errorMessage(error)}. ` +
+        "Fix the JSON syntax or remove the file before running setup.",
+      { cause: error },
+    );
   }
 }

package/src/commands/setup.ts

@@ -1,12 +1,137 @@
+import { writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
 import { command } from "@kidd-cli/core";
+import { match } from "ts-pattern";
+
+import { setupPrompts } from "@/commands/prompts/setup.js";
+
+/** @private */
+const CONFIG_TEMPLATE_AGENTS_ONLY = `import { defineConfig } from "@funkai/config";
+
+export default defineConfig({
+  agents: {},
+});
+`;
 
 export 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.");
+
+    // --- Domain selection ---
+    const domains = await ctx.prompts.multiselect({
+      message: "Which domains do you want to set up?",
+      options: [
+        {
+          value: "prompts" as const,
+          label: "Prompts",
+          hint: "LiquidJS templating, codegen, IDE integration",
+        },
+        { value: "agents" as const, label: "Agents", hint: "Agent scaffolding and configuration" },
+      ],
+      initialValues: ["prompts" as const],
+      required: true,
+    });
+
+    const hasPrompts = domains.includes("prompts");
+    const hasAgents = domains.includes("agents");
+
+    // --- Create funkai.config.ts ---
+    const shouldCreateConfig = await ctx.prompts.confirm({
+      message: "Create funkai.config.ts?",
+      initialValue: true,
+    });
+
+    if (shouldCreateConfig) {
+      let includes = ["src/prompts/**"];
+      let out = ".prompts/client";
+
+      if (hasPrompts) {
+        const includesInput = await ctx.prompts.text({
+          message: "Prompt include patterns (comma-separated)",
+          defaultValue: "src/prompts/**",
+          placeholder: "src/prompts/**",
+        });
+        includes = includesInput.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");
+      // oxlint-disable-next-line security/detect-non-literal-fs-filename -- safe: writing config file to project root
+      writeFileSync(configPath, template, "utf8");
+      ctx.logger.success(`Created ${configPath}`);
+    }
+
+    // --- Run domain-specific setup ---
+    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.");
   },
 });
+
+// ---------------------------------------------------------------------------
+// Private
+// ---------------------------------------------------------------------------
+
+/** @private */
+interface ConfigTemplateOptions {
+  readonly hasPrompts: boolean;
+  readonly hasAgents: boolean;
+  readonly includes: readonly string[];
+  readonly out: string;
+}
+
+/** @private */
+function buildConfigTemplate({
+  hasPrompts,
+  hasAgents,
+  includes,
+  out,
+}: ConfigTemplateOptions): string {
+  if (hasPrompts && hasAgents) {
+    return buildCustomTemplate(includes, out, true);
+  }
+  if (hasPrompts) {
+    return buildCustomTemplate(includes, out, false);
+  }
+  return CONFIG_TEMPLATE_AGENTS_ONLY;
+}
+
+/** @private */
+function buildCustomTemplate(
+  includes: readonly string[],
+  out: string,
+  includeAgents: boolean,
+): string {
+  const includesStr = includes.map((r) => `"${r}"`).join(", ");
+  const agentsBlock = match(includeAgents)
+    .with(true, () => "\n  agents: {},\n")
+    .with(false, () => "\n")
+    .exhaustive();
+
+  return `import { defineConfig } from "@funkai/config";
+
+export default defineConfig({
+  prompts: {
+    includes: [${includesStr}],
+    out: "${out}",
+  },${agentsBlock}});
+`;
+}

package/src/commands/validate.ts

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

package/src/config.ts

@@ -0,0 +1,28 @@
+import type { FunkaiConfig } from "@funkai/config";
+import { configSchema } from "@funkai/config";
+import type { ConfigType, Context } from "@kidd-cli/core";
+
+export { configSchema };
+
+/**
+ * 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;
+ * ```
+ */
+export function getConfig(ctx: Pick<Context, "config">): Readonly<FunkaiConfig> {
+  return ctx.config as unknown as Readonly<FunkaiConfig>;
+}
+
+declare module "@kidd-cli/core" {
+  interface CliConfig extends ConfigType<typeof configSchema> {}
+}

package/src/index.ts

@@ -10,6 +10,7 @@ import promptsLint from "@/commands/prompts/lint.js";
 import promptsSetup from "@/commands/prompts/setup.js";
 import setup from "@/commands/setup.js";
 import validate from "@/commands/validate.js";
+import { configSchema } from "@/config.js";
 
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json") as { readonly version: string };
@@ -18,6 +19,9 @@ await cli({
   description: "CLI for the funkai AI SDK framework",
   name: "funkai",
   version: packageJson.version,
+  config: {
+    schema: configSchema,
+  },
   commands: {
     generate,
     setup,