copilotkit 0.0.40 → 0.0.41

package/dist/lib/init/index.js

@@ -51,6 +51,7 @@ var ApiKeySchema = z.preprocess(
   (val) => sanitizers.apiKey(String(val)),
   z.string().min(1, "API key is required")
 );
+var LLMApiKeySchema = z.preprocess((val) => sanitizers.apiKey(String(val)), z.string().optional());
 var NameSchema = z.preprocess((val) => sanitizers.trim(String(val)), z.string().min(1, "Name is required"));
 var ConfigSchema = z.object({
   // Core fields
@@ -74,7 +75,10 @@ var ConfigSchema = z.object({
   // API keys and tokens
   copilotCloudPublicApiKey: z.string().optional(),
   langSmithApiKey: ApiKeySchema.optional(),
-  llmToken: ApiKeySchema.optional()
+  llmToken: LLMApiKeySchema.optional(),
+  // IDE Documentation setup fields
+  setupIDEDocs: YesNoSchema.optional(),
+  selectedIDE: z.union([z.enum(["cursor", "windsurf"]), z.literal("skip")]).optional()
 }).refine(
   (data) => {
     if (data.mode === "CrewAI") {
@@ -109,7 +113,12 @@ var ConfigFlags = {
   "crew-url": Flags.string({ description: "URL endpoint for your CrewAI agent" }),
   "crew-bearer-token": Flags.string({ description: "Bearer token for CrewAI authentication" }),
   "langsmith-api-key": Flags.string({ description: "LangSmith API key for LangGraph observability" }),
-  "llm-token": Flags.string({ description: "API key for your preferred LLM provider" })
+  "llm-token": Flags.string({ description: "API key for your preferred LLM provider" }),
+  "setup-ide-docs": Flags.string({ description: "Setup IDE documentation rules for AI assistance", options: YES_NO }),
+  "selected-ide": Flags.string({
+    description: "IDE to configure with documentation rules",
+    options: ["cursor", "windsurf", "skip"]
+  })
 };
 
 // src/lib/init/types/templates.ts
@@ -132,6 +141,156 @@ var templateMapping = {
   McpRuntime: `${BASE_URL}/mcp-starter-runtime.json`
 };
 
+// src/lib/init/ide-docs.ts
+import path from "path";
+import { existsSync } from "fs";
+import * as fs from "fs/promises";
+import chalk from "chalk";
+var COPILOTKIT_DOC_RULE_TEMPLATE = `---
+description: CopilotKit Documentation - Complete CopilotKit framework documentation for AI assistance
+alwaysApply: false
+---
+
+# CopilotKit Documentation
+
+For ANY question about CopilotKit, use the comprehensive documentation available at:
+@https://docs.copilotkit.ai/llms-full.txt
+
+This contains the complete CopilotKit documentation including:
+- API references and hooks (useCopilotChat, useCopilotAction, etc.)
+- Component library documentation (CopilotKit, CopilotChat, etc.)
+- Integration guides and examples
+- Best practices and patterns
+- Troubleshooting and FAQs
+
+Always reference this documentation when working with CopilotKit to provide accurate, up-to-date information.
+`;
+var IDE_DOCS_CONFIGS = {
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    rulesDir: ".cursor/rules",
+    ruleFileName: "00-copilotkit-docs.mdc",
+    createRuleContent: () => COPILOTKIT_DOC_RULE_TEMPLATE
+  },
+  windsurf: {
+    name: "windsurf",
+    displayName: "Windsurf",
+    rulesDir: ".windsurf/rules",
+    ruleFileName: "00-copilotkit-docs.md",
+    createRuleContent: () => COPILOTKIT_DOC_RULE_TEMPLATE
+  }
+};
+async function ensureDir(dirPath) {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    if (!existsSync(dirPath)) {
+      throw error;
+    }
+  }
+}
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkIDEInstallation(ide) {
+  try {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    let configPath;
+    switch (ide) {
+      case "cursor":
+        configPath = path.join(homeDir, ".cursor");
+        break;
+      case "windsurf":
+        configPath = path.join(homeDir, ".codeium", "windsurf");
+        break;
+      default:
+        return false;
+    }
+    return existsSync(configPath);
+  } catch {
+    return false;
+  }
+}
+async function detectInstalledIDEs() {
+  const allIDEs = ["cursor", "windsurf"];
+  const installedIDEs = [];
+  for (const ide of allIDEs) {
+    if (await checkIDEInstallation(ide)) {
+      installedIDEs.push(ide);
+    }
+  }
+  return installedIDEs;
+}
+async function setupIDEDocs(ide, projectDir) {
+  const config = IDE_DOCS_CONFIGS[ide];
+  const rulesDir = path.join(projectDir, config.rulesDir);
+  const ruleFilePath = path.join(rulesDir, config.ruleFileName);
+  await ensureDir(rulesDir);
+  if (await pathExists(ruleFilePath)) {
+    console.log(chalk.yellow(`\u26A0\uFE0F  CopilotKit documentation rule already exists for ${config.displayName}`));
+    return;
+  }
+  const ruleContent = config.createRuleContent();
+  await fs.writeFile(ruleFilePath, ruleContent, "utf8");
+}
+function getIDEInstructions(ide) {
+  const config = IDE_DOCS_CONFIGS[ide];
+  const instructions = [
+    chalk.cyan(`\u{1F4DA} CopilotKit documentation configured for ${config.displayName}!`),
+    "",
+    chalk.bold("What this does:"),
+    "  \u2022 Adds CopilotKit documentation context to your IDE AI assistant",
+    "  \u2022 Provides accurate, up-to-date information about CopilotKit APIs",
+    "  \u2022 Improves code suggestions and help responses",
+    "",
+    chalk.bold("Location:"),
+    `  \u2022 Rule file: ${chalk.gray(path.join(config.rulesDir, config.ruleFileName))}`,
+    "",
+    chalk.bold("Usage:"),
+    "  \u2022 Your IDE AI assistant now has access to CopilotKit documentation",
+    "  \u2022 Ask questions about CopilotKit APIs, components, and patterns",
+    "  \u2022 The AI will reference official documentation for accurate answers"
+  ];
+  if (ide === "cursor") {
+    instructions.push(
+      "",
+      chalk.bold("Next steps for Cursor:"),
+      "  \u2022 Restart Cursor if currently open",
+      "  \u2022 The rule will be automatically available in your AI context",
+      "  \u2022 Start a new chat to use the documentation context"
+    );
+  } else if (ide === "windsurf") {
+    instructions.push(
+      "",
+      chalk.bold("Next steps for Windsurf:"),
+      "  \u2022 Restart Windsurf if currently open",
+      "  \u2022 The rule will be automatically available in your AI context",
+      "  \u2022 Start a new chat to use the documentation context"
+    );
+  }
+  return instructions;
+}
+async function handleIDEDocsSetup(selectedIDE, projectDir, spinner) {
+  try {
+    spinner.text = chalk.cyan(`Setting up CopilotKit documentation for ${IDE_DOCS_CONFIGS[selectedIDE].displayName}...`);
+    await setupIDEDocs(selectedIDE, projectDir);
+    spinner.succeed(chalk.green(`CopilotKit documentation configured for ${IDE_DOCS_CONFIGS[selectedIDE].displayName}`));
+    const instructions = getIDEInstructions(selectedIDE);
+    console.log("\n" + instructions.join("\n"));
+  } catch (error) {
+    spinner.fail(
+      chalk.red(`Failed to setup IDE documentation: ${error instanceof Error ? error.message : "Unknown error"}`)
+    );
+    throw error;
+  }
+}
+
 // src/lib/init/questions.ts
 var linkToDocs = ["Mastra", "AG2", "LlamaIndex", "Agno"];
 var validateUrl = (input) => {
@@ -282,6 +441,39 @@ var questions = [
     when: (answers) => answers.mode === "LangGraph" && answers.alreadyDeployed === "No" || answers.mode === "Standard" && answers.useCopilotCloud !== "Yes" || answers.mode === "MCP" && answers.useCopilotCloud !== "Yes",
     sensitive: true,
     sanitize: sanitizers.apiKey
+  },
+  // IDE Documentation Setup Questions
+  {
+    type: "yes/no",
+    name: "setupIDEDocs",
+    message: "\u{1F4DA} Would you like to add CopilotKit documentation to your IDE? (Provides AI assistant with CopilotKit context)",
+    when: async () => {
+      const installedIDEs = await detectInstalledIDEs();
+      return installedIDEs.length > 0;
+    },
+    validate: (input) => {
+      try {
+        YesNoSchema.parse(input);
+        return true;
+      } catch (error) {
+        return "Please select Yes or No";
+      }
+    }
+  },
+  {
+    type: "select",
+    name: "selectedIDE",
+    message: "\u{1F4BB} Which IDE would you like to configure with CopilotKit documentation?",
+    choices: async () => {
+      const installedIDEs = await detectInstalledIDEs();
+      const choices = installedIDEs.map((ide) => ({
+        name: IDE_DOCS_CONFIGS[ide].displayName,
+        value: ide
+      }));
+      choices.push({ name: "Skip", value: "skip" });
+      return choices;
+    },
+    when: (answers) => answers.setupIDEDocs === "Yes"
   }
 ];
 
@@ -347,8 +539,8 @@ async function scaffoldShadCN(flags, userAnswers) {
 }
 
 // src/lib/init/scaffold/env.ts
-import path from "path";
-import fs from "fs";
+import path2 from "path";
+import fs2 from "fs";
 
 // src/lib/init/scaffold/langgraph-assistants.ts
 async function getLangGraphAgents(url, langSmithApiKey) {
@@ -374,9 +566,9 @@ async function getLangGraphAgents(url, langSmithApiKey) {
 import inquirer from "inquirer";
 async function scaffoldEnv(flags, userAnswers) {
   try {
-    const envFile = path.join(process.cwd(), ".env");
-    if (!fs.existsSync(envFile)) {
-      fs.writeFileSync(envFile, "", "utf8");
+    const envFile = path2.join(process.cwd(), ".env");
+    if (!fs2.existsSync(envFile)) {
+      fs2.writeFileSync(envFile, "", "utf8");
     } else {
     }
     let newEnvValues = "";
@@ -440,7 +632,7 @@ async function scaffoldEnv(flags, userAnswers) {
 `;
     }
     if (newEnvValues) {
-      fs.appendFileSync(envFile, newEnvValues);
+      fs2.appendFileSync(envFile, newEnvValues);
     }
   } catch (error) {
     throw error;
@@ -449,59 +641,59 @@ async function scaffoldEnv(flags, userAnswers) {
 
 // src/lib/init/scaffold/github.ts
 import { execSync } from "child_process";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import * as os from "os";
-import chalk from "chalk";
+import chalk2 from "chalk";
 async function cloneGitHubSubdirectory(githubUrl, destinationPath, spinner) {
   try {
     const { owner, repo, branch, subdirectoryPath } = parseGitHubUrl(githubUrl);
-    spinner.text = chalk.cyan(`Cloning from ${owner}/${repo}...`);
+    spinner.text = chalk2.cyan(`Cloning from ${owner}/${repo}...`);
     return await sparseCheckout(owner, repo, branch, subdirectoryPath, destinationPath, spinner);
   } catch (error) {
-    spinner.text = chalk.red(`Failed to clone from GitHub: ${error}`);
+    spinner.text = chalk2.red(`Failed to clone from GitHub: ${error}`);
     return false;
   }
 }
 async function sparseCheckout(owner, repo, branch, subdirectoryPath, destinationPath, spinner) {
-  const tempDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "copilotkit-sparse-"));
+  const tempDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "copilotkit-sparse-"));
   try {
-    spinner.text = chalk.cyan("Creating temporary workspace...");
+    spinner.text = chalk2.cyan("Creating temporary workspace...");
     execSync("git init", { cwd: tempDir, stdio: "pipe" });
-    spinner.text = chalk.cyan("Connecting to repository...");
+    spinner.text = chalk2.cyan("Connecting to repository...");
     execSync(`git remote add origin https://github.com/${owner}/${repo}.git`, { cwd: tempDir, stdio: "pipe" });
     execSync("git config core.sparseCheckout true", { cwd: tempDir, stdio: "pipe" });
-    fs2.writeFileSync(path2.join(tempDir, ".git/info/sparse-checkout"), subdirectoryPath);
-    spinner.text = chalk.cyan("Downloading agent files...");
+    fs3.writeFileSync(path3.join(tempDir, ".git/info/sparse-checkout"), subdirectoryPath);
+    spinner.text = chalk2.cyan("Downloading agent files...");
     execSync(`git pull origin ${branch} --depth=1`, { cwd: tempDir, stdio: "pipe" });
-    const sourcePath = path2.join(tempDir, subdirectoryPath);
-    if (!fs2.existsSync(sourcePath)) {
+    const sourcePath = path3.join(tempDir, subdirectoryPath);
+    if (!fs3.existsSync(sourcePath)) {
       throw new Error(`Subdirectory '${subdirectoryPath}' not found in the repository.`);
     }
-    fs2.mkdirSync(destinationPath, { recursive: true });
-    spinner.text = chalk.cyan("Installing agent files...");
+    fs3.mkdirSync(destinationPath, { recursive: true });
+    spinner.text = chalk2.cyan("Installing agent files...");
     await copyDirectoryAsync(sourcePath, destinationPath);
     return true;
   } finally {
     try {
-      fs2.rmSync(tempDir, { recursive: true, force: true });
+      fs3.rmSync(tempDir, { recursive: true, force: true });
     } catch (error) {
       console.warn(`Failed to clean up temporary directory: ${error}`);
     }
   }
 }
 async function copyDirectoryAsync(source, destination) {
-  if (!fs2.existsSync(destination)) {
-    fs2.mkdirSync(destination, { recursive: true });
+  if (!fs3.existsSync(destination)) {
+    fs3.mkdirSync(destination, { recursive: true });
   }
-  const entries = fs2.readdirSync(source, { withFileTypes: true });
+  const entries = fs3.readdirSync(source, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path2.join(source, entry.name);
-    const destPath = path2.join(destination, entry.name);
+    const srcPath = path3.join(source, entry.name);
+    const destPath = path3.join(destination, entry.name);
     if (entry.isDirectory()) {
       await copyDirectoryAsync(srcPath, destPath);
     } else {
-      fs2.copyFileSync(srcPath, destPath);
+      fs3.copyFileSync(srcPath, destPath);
     }
     if (entries.length > 10) {
       await new Promise((resolve) => setTimeout(resolve, 1));
@@ -538,12 +730,12 @@ function isValidGitHubUrl(url) {
 
 // src/lib/init/scaffold/packages.ts
 import spawn2 from "cross-spawn";
-import chalk2 from "chalk";
-import fs3 from "fs";
+import chalk3 from "chalk";
+import fs4 from "fs";
 import ora from "ora";
 async function scaffoldPackages(userAnswers) {
   const spinner = ora({
-    text: chalk2.cyan("Preparing to install packages..."),
+    text: chalk3.cyan("Preparing to install packages..."),
     color: "cyan"
   }).start();
   try {
@@ -555,9 +747,9 @@ async function scaffoldPackages(userAnswers) {
     await new Promise((resolve) => setTimeout(resolve, 50));
     const packageManager = detectPackageManager();
     const installCommand = detectInstallCommand(packageManager);
-    spinner.text = chalk2.cyan(`Using ${packageManager} to install packages...`);
+    spinner.text = chalk3.cyan(`Using ${packageManager} to install packages...`);
     spinner.stop();
-    console.log(chalk2.cyan("\n\u2699\uFE0F  Installing packages...\n"));
+    console.log(chalk3.cyan("\n\u2699\uFE0F  Installing packages...\n"));
     const result = spawn2.sync(packageManager, [installCommand, ...packages], {
       stdio: "inherit"
       // This ensures stdin/stdout/stderr are all passed through
@@ -566,17 +758,17 @@ async function scaffoldPackages(userAnswers) {
       throw new Error(`Package installation process exited with code ${result.status}`);
     }
     spinner.start();
-    spinner.succeed(chalk2.green("CopilotKit packages installed successfully"));
+    spinner.succeed(chalk3.green("CopilotKit packages installed successfully"));
   } catch (error) {
     if (!spinner.isSpinning) {
       spinner.start();
     }
-    spinner.fail(chalk2.red("Failed to install CopilotKit packages"));
+    spinner.fail(chalk3.red("Failed to install CopilotKit packages"));
     throw error;
   }
 }
 function detectPackageManager() {
-  const files = fs3.readdirSync(process.cwd());
+  const files = fs4.readdirSync(process.cwd());
   if (files.includes("bun.lockb")) return "bun";
   if (files.includes("pnpm-lock.yaml")) return "pnpm";
   if (files.includes("yarn.lock")) return "yarn";
@@ -595,15 +787,15 @@ function detectInstallCommand(packageManager) {
 
 // src/lib/init/scaffold/agent.ts
 import ora2 from "ora";
-import chalk3 from "chalk";
-import path3 from "path";
-import fs4 from "fs";
+import chalk4 from "chalk";
+import path4 from "path";
+import fs5 from "fs";
 async function scaffoldAgent(userAnswers) {
   if (userAnswers.mode === "CrewAI" || userAnswers.mode === "LangGraph" && !userAnswers.langGraphAgent || userAnswers.mode === "Standard" || userAnswers.mode === "MCP") {
     return;
   }
   const spinner = ora2({
-    text: chalk3.cyan("Setting up AI agent..."),
+    text: chalk4.cyan("Setting up AI agent..."),
     color: "cyan"
   }).start();
   let template = "";
@@ -617,13 +809,13 @@ async function scaffoldAgent(userAnswers) {
       break;
   }
   if (!template) {
-    spinner.fail(chalk3.red("Failed to determine agent template"));
+    spinner.fail(chalk4.red("Failed to determine agent template"));
     throw new Error("Failed to determine agent template");
   }
-  const agentDir = path3.join(process.cwd(), "agent");
+  const agentDir = path4.join(process.cwd(), "agent");
   try {
     await cloneGitHubSubdirectory(template, agentDir, spinner);
-    spinner.text = chalk3.cyan("Creating agent environment variables...");
+    spinner.text = chalk4.cyan("Creating agent environment variables...");
     let envContent = "";
     if (userAnswers.llmToken) {
       envContent += `OPENAI_API_KEY=${userAnswers.llmToken}
@@ -634,26 +826,26 @@ async function scaffoldAgent(userAnswers) {
 `;
     }
     if (envContent) {
-      const agentEnvFile = path3.join(agentDir, ".env");
-      fs4.writeFileSync(agentEnvFile, envContent, "utf8");
-      spinner.text = chalk3.cyan("Added API keys to agent .env file");
+      const agentEnvFile = path4.join(agentDir, ".env");
+      fs5.writeFileSync(agentEnvFile, envContent, "utf8");
+      spinner.text = chalk4.cyan("Added API keys to agent .env file");
     }
     if (userAnswers.mode === "LangGraph" && userAnswers.langSmithApiKey) {
       envContent += `LANGSMITH_API_KEY=${userAnswers.langSmithApiKey}
 `;
     }
     if (envContent) {
-      const agentEnvFile = path3.join(agentDir, ".env");
-      fs4.writeFileSync(agentEnvFile, envContent, "utf8");
-      spinner.text = chalk3.cyan("Added API keys to agent .env file");
+      const agentEnvFile = path4.join(agentDir, ".env");
+      fs5.writeFileSync(agentEnvFile, envContent, "utf8");
+      spinner.text = chalk4.cyan("Added API keys to agent .env file");
     }
     if (envContent) {
-      const agentEnvFile = path3.join(agentDir, ".env");
-      fs4.writeFileSync(agentEnvFile, envContent, "utf8");
-      spinner.text = chalk3.cyan("Added API keys to agent .env file");
+      const agentEnvFile = path4.join(agentDir, ".env");
+      fs5.writeFileSync(agentEnvFile, envContent, "utf8");
+      spinner.text = chalk4.cyan("Added API keys to agent .env file");
     }
   } catch (error) {
-    spinner.fail(chalk3.red("Failed to clone agent template"));
+    spinner.fail(chalk4.red("Failed to clone agent template"));
     throw error;
   }
   spinner.succeed(`${userAnswers.mode} agent cloned successfully`);
@@ -673,29 +865,29 @@ var AgentTemplates = {
 };
 
 // src/lib/init/scaffold/crew-inputs.ts
-import * as fs5 from "fs/promises";
+import * as fs6 from "fs/promises";
 import ora3 from "ora";
-import * as path4 from "path";
+import * as path5 from "path";
 async function addCrewInputs(url, token) {
   try {
     const spinner = ora3("Analyzing crew inputs...").start();
     const inputs = await getCrewInputs(url, token);
     spinner.text = "Adding inputs to app/copilotkit/page.tsx...";
-    let filePath = path4.join(process.cwd(), "app", "copilotkit", "page.tsx");
+    let filePath = path5.join(process.cwd(), "app", "copilotkit", "page.tsx");
     try {
-      await fs5.access(filePath);
+      await fs6.access(filePath);
     } catch {
-      filePath = path4.join(process.cwd(), "src", "app", "copilotkit", "page.tsx");
+      filePath = path5.join(process.cwd(), "src", "app", "copilotkit", "page.tsx");
     }
     try {
-      await fs5.access(filePath);
+      await fs6.access(filePath);
     } catch {
       throw new Error("app/copilotkit/page.tsx and src/app/copilotkit/page.tsx not found");
     }
-    let fileContent = await fs5.readFile(filePath, "utf8");
+    let fileContent = await fs6.readFile(filePath, "utf8");
     const inputsString = JSON.stringify(inputs);
     fileContent = fileContent.replace(/\[["']YOUR_INPUTS_HERE["']\]/g, inputsString);
-    await fs5.writeFile(filePath, fileContent, "utf8");
+    await fs6.writeFile(filePath, fileContent, "utf8");
     spinner.succeed("Successfully added crew inputs to app/copilotkit/page.tsx");
   } catch (error) {
     console.error("Error updating crew inputs:", error);
@@ -725,7 +917,9 @@ export {
   ConfigSchema,
   CrewFlowTemplateSchema,
   CrewTypeSchema,
+  IDE_DOCS_CONFIGS,
   LANGGRAPH_AGENTS,
+  LLMApiKeySchema,
   LangGraphAgentSchema,
   MODES,
   ModeSchema,
@@ -736,6 +930,9 @@ export {
   YesNoSchema,
   addCrewInputs,
   cloneGitHubSubdirectory,
+  detectInstalledIDEs,
+  handleIDEDocsSetup,
+  isLocalhost,
   isValidGitHubUrl,
   questions,
   sanitizers,
@@ -743,6 +940,7 @@ export {
   scaffoldEnv,
   scaffoldPackages,
   scaffoldShadCN,
+  setupIDEDocs,
   templateMapping
 };
 //# sourceMappingURL=index.js.map