jarvis-ai-framework 1.0.0

package/bin/lib/config/ide-config.js

@@ -0,0 +1,233 @@
+/**
+ * @fileoverview Configuração centralizada de IDEs suportadas
+ * @module config/ide-config
+ */
+
+import { logger } from "../utils/logger.js";
+
+/** @constant {string} Pasta padrão para workflows */
+export const DEFAULT_WORKFLOWS_FOLDER = "workflows";
+
+/** @constant {string} Pasta alternativa para comandos */
+export const COMMANDS_FOLDER = "commands";
+
+/** @constant {string} Pasta de steering files (Kiro) */
+export const STEERING_FOLDER = "steering";
+
+/**
+ * @typedef {Object} IDEConfig
+ * @property {string} name - Nome completo da IDE
+ * @property {string} value - Identificador único (slug)
+ * @property {boolean} supported - Se a IDE é suportada
+ * @property {string} workflowsFolder - Nome da pasta para workflows/commands
+ * @property {string} [folderName] - Nome real da pasta no filesystem (sem o ponto). Defaults para value.
+ * @property {string} [icon] - Emoji/ícone da IDE (opcional)
+ */
+
+/**
+ * Lista de IDEs suportadas (source of truth)
+ * @type {ReadonlyArray<Readonly<IDEConfig>>}
+ */
+export const IDES = Object.freeze([
+  {
+    name: "Windsurf",
+    value: "windsurf",
+    supported: true,
+    workflowsFolder: DEFAULT_WORKFLOWS_FOLDER,
+    icon: "🤖",
+  },
+  {
+    name: "Claude Code",
+    value: "claude",
+    supported: true,
+    workflowsFolder: COMMANDS_FOLDER,
+    icon: "🔌",
+  },
+  {
+    name: "Cursor",
+    value: "cursor",
+    supported: true,
+    workflowsFolder: COMMANDS_FOLDER,
+    icon: "💻",
+  },
+  {
+    name: "Codex (OpenAI)",
+    value: "codex",
+    supported: true,
+    workflowsFolder: DEFAULT_WORKFLOWS_FOLDER,
+    icon: "🔮",
+  },
+  {
+    name: "OpenCode",
+    value: "opencode",
+    supported: true,
+    workflowsFolder: COMMANDS_FOLDER,
+    icon: "⚡",
+  },
+  {
+    name: "Gemini CLI / Antigravity (Google)",
+    value: "gemini",
+    folderName: "agents",
+    supported: true,
+    workflowsFolder: DEFAULT_WORKFLOWS_FOLDER,
+    icon: "🌐",
+  },
+  {
+    name: "Kiro (AWS)",
+    value: "kiro",
+    supported: true,
+    workflowsFolder: STEERING_FOLDER,
+    icon: "☁️",
+  },
+]);
+
+/** @type {Map<string, IDEConfig> | null} */
+let _ideConfigCache = null;
+
+/**
+ * Inicializa o cache de configurações (O(n) uma vez, depois O(1))
+ * @private
+ * @returns {Map<string, IDEConfig>}
+ */
+function _initCache() {
+  if (_ideConfigCache === null) {
+    _ideConfigCache = new Map();
+    for (const ide of IDES) {
+      _validateIDEConfig(ide);
+      _ideConfigCache.set(ide.value, ide);
+    }
+  }
+  return _ideConfigCache;
+}
+
+/**
+ * Valida schema de configuração de IDE
+ * @private
+ * @param {IDEConfig} config
+ * @throws {Error} Se a configuração for inválida
+ */
+function _validateIDEConfig(config) {
+  if (!config.name || typeof config.name !== "string") {
+    throw new Error(`IDE config inválida: 'name' é obrigatório (string)`);
+  }
+  if (!config.value || typeof config.value !== "string") {
+    throw new Error(
+      `IDE config inválida: 'value' é obrigatório (string) para ${config.name}`,
+    );
+  }
+  if (typeof config.supported !== "boolean") {
+    throw new Error(
+      `IDE config inválida: 'supported' é obrigatório (boolean) para ${config.name}`,
+    );
+  }
+  if (!config.workflowsFolder || typeof config.workflowsFolder !== "string") {
+    throw new Error(
+      `IDE config inválida: 'workflowsFolder' é obrigatório (string) para ${config.name}`,
+    );
+  }
+  // Validar valores conhecidos
+  const knownFolders = [DEFAULT_WORKFLOWS_FOLDER, COMMANDS_FOLDER, STEERING_FOLDER];
+  if (!knownFolders.includes(config.workflowsFolder)) {
+    logger.warn(
+      `⚠️  Atenção: IDE '${config.name}' usa workflowsFolder customizado: '${config.workflowsFolder}'`,
+    );
+  }
+}
+
+/**
+ * Busca configuração de IDE por slug (O(1) com cache)
+ * @param {string} ideValue - Slug da IDE (ex: "windsurf", "claude")
+ * @returns {IDEConfig | undefined} Configuração da IDE ou undefined
+ * @example
+ * const config = getIDEConfig("windsurf");
+ * // config.workflowsFolder === "workflows"
+ */
+export function getIDEConfig(ideValue) {
+  if (!ideValue || typeof ideValue !== "string") {
+    return undefined;
+  }
+  const cache = _initCache();
+  return cache.get(ideValue);
+}
+
+/**
+ * Retorna todas as IDEs suportadas
+ * @returns {ReadonlyArray<Readonly<IDEConfig>>}
+ */
+export function getSupportedIDEs() {
+  return IDES.filter((ide) => ide.supported);
+}
+
+/**
+ * Retorna lista de slugs de IDEs suportadas
+ * @returns {string[]}
+ * @example
+ * getIDEValues() // ["windsurf", "claude", "cursor", ...]
+ */
+export function getIDEValues() {
+  return getSupportedIDEs().map((ide) => ide.value);
+}
+
+/**
+ * Valida se uma IDE é suportada
+ * @param {string} ideValue - Slug da IDE
+ * @returns {boolean}
+ * @example
+ * isIDESupported("windsurf") // true
+ * isIDESupported("vscode") // false
+ */
+export function isIDESupported(ideValue) {
+  const config = getIDEConfig(ideValue);
+  return config !== undefined && config.supported === true;
+}
+
+/**
+ * Formata lista de IDEs para exibição no CLI
+ * @param {string} [separator=" | "] - Separador entre IDEs
+ * @returns {string}
+ * @example
+ * formatIDEsList() // "🤖 Windsurf | 🔌 Claude Code | ..."
+ */
+export function formatIDEsList(separator = "  |  ") {
+  return getSupportedIDEs()
+    .map((ide) => `${ide.icon || "•"} ${ide.name}`)
+    .join(separator);
+}
+
+/**
+ * Retorna o nome da pasta no filesystem para uma IDE (sem o ponto)
+ * Usa folderName se definido, senão usa value.
+ * @param {string} ideValue - Slug da IDE
+ * @returns {string} Nome da pasta (ex: "windsurf", "agents" para gemini)
+ * @example
+ * getIDEFolder("windsurf") // "windsurf"
+ * getIDEFolder("gemini")   // "agents"
+ * getIDEFolder("unknown")  // "unknown" (fallback)
+ */
+export function getIDEFolder(ideValue) {
+  const config = getIDEConfig(ideValue);
+  return config?.folderName || ideValue;
+}
+
+/**
+ * Retorna a pasta de workflows para uma IDE (com fallback)
+ * @param {string} ideValue - Slug da IDE
+ * @returns {string} Nome da pasta (ex: "workflows", "commands")
+ * @example
+ * getWorkflowsFolder("windsurf") // "workflows"
+ * getWorkflowsFolder("claude") // "commands"
+ * getWorkflowsFolder("gemini") // "workflows"
+ * getWorkflowsFolder("unknown") // "workflows" (fallback)
+ */
+export function getWorkflowsFolder(ideValue) {
+  const config = getIDEConfig(ideValue);
+  return config?.workflowsFolder || DEFAULT_WORKFLOWS_FOLDER;
+}
+
+/**
+ * Limpa o cache (útil para testes)
+ * @private
+ */
+export function _clearCache() {
+  _ideConfigCache = null;
+}

package/bin/lib/core/scanner.js

@@ -0,0 +1,124 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getFrameworkRoot } from "../utils/paths.js";
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return {};
+
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const kv = line.match(/^(\w[\w-]*):\s*(.+)$/);
+    if (kv) {
+      let val = kv[2].trim();
+      if (
+        (val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))
+      ) {
+        val = val.slice(1, -1);
+      }
+      fm[kv[1]] = val;
+    }
+  }
+  return fm;
+}
+
+function extractDeps(content) {
+  const deps = { rules: [], templates: [], skills: [], agents: [] };
+
+  const ruleFile = content.match(/rules_file:\s*"?\$IDE\/rules\/(.+?)\.md"?/);
+  if (ruleFile) deps.rules.push(ruleFile[1]);
+
+  for (const m of content.matchAll(/rules\/([\w./-]+)\.md/g)) {
+    if (!deps.rules.includes(m[1])) deps.rules.push(m[1]);
+  }
+
+  const tplFile = content.match(
+    /template_file:\s*"?\$IDE\/templates\/(.+?)\.md"?/,
+  );
+  if (tplFile) deps.templates.push(tplFile[1]);
+
+  const agentFile = content.match(/agent:\s*"?\$IDE\/agents\/(.+?)\.md"?/);
+  if (agentFile) deps.agents.push(agentFile[1]);
+
+  return deps;
+}
+
+function scanDir(dir, type) {
+  if (!existsSync(dir)) return [];
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+  const results = [];
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      if (type === "skill") {
+        const skillFile = join(fullPath, "SKILL.md");
+        if (existsSync(skillFile)) {
+          const content = readFileSync(skillFile, "utf-8");
+          const fm = parseFrontmatter(content);
+          results.push({
+            id: fm.name || entry.name,
+            type,
+            name: fm.name || entry.name,
+            description: fm.description || "",
+            version: fm.version || "1.0.0",
+            deps: extractDeps(content),
+            path: skillFile,
+          });
+        }
+      } else {
+        results.push(...scanDir(fullPath, type));
+      }
+      continue;
+    }
+
+    if (
+      !entry.name.endsWith(".md") ||
+      entry.name === "README.md" ||
+      entry.name === "AGENTS.md"
+    ) {
+      continue;
+    }
+
+    const content = readFileSync(fullPath, "utf-8");
+    const fm = parseFrontmatter(content);
+    const id = entry.name.replace(".md", "");
+
+    results.push({
+      id,
+      type,
+      name: fm.description || id,
+      description: fm.description || "",
+      model: fm.model || fm.recommended_model || "",
+      version: fm.version || "1.0.0",
+      deps: extractDeps(content),
+      path: fullPath,
+    });
+  }
+
+  return results;
+}
+
+export function discoverAll() {
+  const root = getFrameworkRoot();
+
+  return {
+    agents: scanDir(join(root, "agents"), "agent"),
+    skills: scanDir(join(root, "skills"), "skill"),
+    workflows: scanDir(join(root, "workflows"), "workflow"),
+  };
+}
+
+export function findPrompt(typeAndName) {
+  const [type, name] = typeAndName.split("/");
+  if (!type || !name) return null;
+
+  const all = discoverAll();
+  const collection = all[type + "s"];
+  if (!collection) return null;
+
+  return collection.find((p) => p.id === name) || null;
+}