natureco-cli 1.0.0

package/src/utils/mcp.js

@@ -0,0 +1,188 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { CONFIG_DIR, loadConfig, saveConfig } = require('./config');
+
+// MCP templates
+const MCP_TEMPLATES = {
+  filesystem: {
+    name: 'filesystem',
+    description: 'File system operations (read, write, list files)',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-filesystem', process.cwd()],
+    env: {},
+  },
+  github: {
+    name: 'github',
+    description: 'GitHub repository operations (issues, PRs, commits)',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-github'],
+    env: {
+      GITHUB_TOKEN: '<your-github-token>',
+    },
+  },
+  postgres: {
+    name: 'postgres',
+    description: 'PostgreSQL database operations',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-postgres'],
+    env: {
+      POSTGRES_CONNECTION_STRING: 'postgresql://user:password@localhost:5432/dbname',
+    },
+  },
+  sqlite: {
+    name: 'sqlite',
+    description: 'SQLite database operations',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-sqlite', '--db-path', './database.db'],
+    env: {},
+  },
+  'brave-search': {
+    name: 'brave-search',
+    description: 'Web search using Brave Search API',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-brave-search'],
+    env: {
+      BRAVE_API_KEY: '<your-brave-api-key>',
+    },
+  },
+};
+
+// Get MCP servers from config
+function getMcpServers() {
+  const config = loadConfig();
+  return config?.mcpServers || {};
+}
+
+// Save MCP servers to config
+function saveMcpServers(servers) {
+  const config = loadConfig() || {};
+  config.mcpServers = servers;
+  saveConfig(config);
+}
+
+// Add MCP server
+function addMcpServer(name, template = null, customConfig = null) {
+  const servers = getMcpServers();
+
+  if (servers[name]) {
+    throw new Error(`MCP sunucu zaten mevcut: ${name}`);
+  }
+
+  let serverConfig;
+
+  if (template && MCP_TEMPLATES[template]) {
+    serverConfig = { ...MCP_TEMPLATES[template] };
+    delete serverConfig.name;
+  } else if (customConfig) {
+    serverConfig = customConfig;
+  } else {
+    throw new Error('Template veya custom config gerekli');
+  }
+
+  servers[name] = {
+    ...serverConfig,
+    disabled: false,
+    autoApprove: [],
+  };
+
+  saveMcpServers(servers);
+}
+
+// Remove MCP server
+function removeMcpServer(name) {
+  const servers = getMcpServers();
+
+  if (!servers[name]) {
+    throw new Error(`MCP sunucu bulunamadı: ${name}`);
+  }
+
+  delete servers[name];
+  saveMcpServers(servers);
+}
+
+// Test MCP server connection
+function testMcpServer(name) {
+  const servers = getMcpServers();
+
+  if (!servers[name]) {
+    throw new Error(`MCP sunucu bulunamadı: ${name}`);
+  }
+
+  const server = servers[name];
+
+  // Check if command exists
+  try {
+    if (server.command === 'npx') {
+      // Check if npx is available
+      execSync('npx --version', { stdio: 'ignore' });
+    } else {
+      // Check if custom command exists
+      execSync(`${server.command} --version`, { stdio: 'ignore' });
+    }
+  } catch {
+    throw new Error(`Komut bulunamadı: ${server.command}`);
+  }
+
+  // Check environment variables
+  if (server.env) {
+    const missingEnvVars = [];
+    for (const [key, value] of Object.entries(server.env)) {
+      if (value.startsWith('<') && value.endsWith('>')) {
+        missingEnvVars.push(key);
+      } else if (!process.env[key] && value) {
+        missingEnvVars.push(key);
+      }
+    }
+
+    if (missingEnvVars.length > 0) {
+      throw new Error(`Eksik environment variable'lar: ${missingEnvVars.join(', ')}`);
+    }
+  }
+
+  return true;
+}
+
+// Enable/disable MCP server
+function toggleMcpServer(name, enabled) {
+  const servers = getMcpServers();
+
+  if (!servers[name]) {
+    throw new Error(`MCP sunucu bulunamadı: ${name}`);
+  }
+
+  servers[name].disabled = !enabled;
+  saveMcpServers(servers);
+}
+
+// Get MCP templates
+function getMcpTemplates() {
+  return MCP_TEMPLATES;
+}
+
+// Update MCP server config
+function updateMcpServer(name, updates) {
+  const servers = getMcpServers();
+
+  if (!servers[name]) {
+    throw new Error(`MCP sunucu bulunamadı: ${name}`);
+  }
+
+  servers[name] = {
+    ...servers[name],
+    ...updates,
+  };
+
+  saveMcpServers(servers);
+}
+
+module.exports = {
+  getMcpServers,
+  saveMcpServers,
+  addMcpServer,
+  removeMcpServer,
+  testMcpServer,
+  toggleMcpServer,
+  getMcpTemplates,
+  updateMcpServer,
+};

package/src/utils/skills.js

@@ -0,0 +1,285 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const { CONFIG_DIR } = require('./config');
+
+const BUILTIN_SKILLS_DIR = path.join(__dirname, '..', '..', 'skills');
+const USER_SKILLS_DIR = path.join(CONFIG_DIR, 'skills');
+const PROJECT_SKILLS_DIR = path.join(process.cwd(), '.natureco', 'skills');
+
+// Skill metadata parser
+function parseSkillMetadata(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) return null;
+
+  const frontmatter = frontmatterMatch[1];
+  const metadata = {};
+
+  // name
+  const nameMatch = frontmatter.match(/name:\s*(.+)/);
+  if (nameMatch) metadata.name = nameMatch[1].trim();
+
+  // description
+  const descMatch = frontmatter.match(/description:\s*(.+)/);
+  if (descMatch) metadata.description = descMatch[1].trim();
+
+  // metadata JSON
+  const metaMatch = frontmatter.match(/metadata:\s*(\{[\s\S]*?\})/);
+  if (metaMatch) {
+    try {
+      metadata.metadata = JSON.parse(metaMatch[1]);
+    } catch {
+      metadata.metadata = {};
+    }
+  }
+
+  return metadata;
+}
+
+// Skill gating - requirements check
+function checkSkillRequirements(metadata) {
+  const errors = [];
+
+  if (metadata?.metadata?.natureco?.requires?.bins) {
+    const bins = metadata.metadata.natureco.requires.bins;
+    for (const bin of bins) {
+      try {
+        execSync(`${bin} --version`, { stdio: 'ignore' });
+      } catch {
+        errors.push(`Binary gerekli: ${bin}`);
+      }
+    }
+  }
+
+  if (metadata?.metadata?.natureco?.requires?.env) {
+    const envVars = metadata.metadata.natureco.requires.env;
+    for (const envVar of envVars) {
+      if (!process.env[envVar]) {
+        errors.push(`Environment variable gerekli: ${envVar}`);
+      }
+    }
+  }
+
+  if (metadata?.metadata?.natureco?.os) {
+    const supportedOS = metadata.metadata.natureco.os;
+    if (!supportedOS.includes(os.platform())) {
+      errors.push(`Platform desteklenmiyor. Desteklenen: ${supportedOS.join(', ')}`);
+    }
+  }
+
+  return errors;
+}
+
+// Get all skills from all sources
+function getSkills() {
+  const skills = [];
+
+  // Builtin skills
+  if (fs.existsSync(BUILTIN_SKILLS_DIR)) {
+    const builtinDirs = fs.readdirSync(BUILTIN_SKILLS_DIR, { withFileTypes: true })
+      .filter(d => d.isDirectory());
+    
+    for (const dir of builtinDirs) {
+      const skillFile = path.join(BUILTIN_SKILLS_DIR, dir.name, 'SKILL.md');
+      if (fs.existsSync(skillFile)) {
+        const content = fs.readFileSync(skillFile, 'utf8');
+        const metadata = parseSkillMetadata(content);
+        if (metadata) {
+          skills.push({
+            ...metadata,
+            slug: dir.name,
+            source: 'builtin',
+            path: path.join(BUILTIN_SKILLS_DIR, dir.name),
+          });
+        }
+      }
+    }
+  }
+
+  // User skills
+  if (fs.existsSync(USER_SKILLS_DIR)) {
+    const userDirs = fs.readdirSync(USER_SKILLS_DIR, { withFileTypes: true })
+      .filter(d => d.isDirectory());
+    
+    for (const dir of userDirs) {
+      const skillFile = path.join(USER_SKILLS_DIR, dir.name, 'SKILL.md');
+      if (fs.existsSync(skillFile)) {
+        const content = fs.readFileSync(skillFile, 'utf8');
+        const metadata = parseSkillMetadata(content);
+        if (metadata) {
+          skills.push({
+            ...metadata,
+            slug: dir.name,
+            source: 'user',
+            path: path.join(USER_SKILLS_DIR, dir.name),
+          });
+        }
+      }
+    }
+  }
+
+  // Project skills
+  if (fs.existsSync(PROJECT_SKILLS_DIR)) {
+    const projectDirs = fs.readdirSync(PROJECT_SKILLS_DIR, { withFileTypes: true })
+      .filter(d => d.isDirectory());
+    
+    for (const dir of projectDirs) {
+      const skillFile = path.join(PROJECT_SKILLS_DIR, dir.name, 'SKILL.md');
+      if (fs.existsSync(skillFile)) {
+        const content = fs.readFileSync(skillFile, 'utf8');
+        const metadata = parseSkillMetadata(content);
+        if (metadata) {
+          skills.push({
+            ...metadata,
+            slug: dir.name,
+            source: 'project',
+            path: path.join(PROJECT_SKILLS_DIR, dir.name),
+          });
+        }
+      }
+    }
+  }
+
+  return skills;
+}
+
+// Install skill from NatureHub
+async function installSkill(slug) {
+  const url = `https://natureco.me/hub/skills/${slug}/SKILL.md`;
+  
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Skill bulunamadı: ${slug}`);
+    }
+
+    const content = await response.text();
+    const metadata = parseSkillMetadata(content);
+    
+    if (!metadata) {
+      throw new Error('Geçersiz skill formatı');
+    }
+
+    // Check requirements
+    const errors = checkSkillRequirements(metadata);
+    if (errors.length > 0) {
+      throw new Error(`Gereksinimler karşılanmadı:\n${errors.join('\n')}`);
+    }
+
+    // Save to user skills
+    if (!fs.existsSync(USER_SKILLS_DIR)) {
+      fs.mkdirSync(USER_SKILLS_DIR, { recursive: true });
+    }
+
+    const skillDir = path.join(USER_SKILLS_DIR, slug);
+    if (!fs.existsSync(skillDir)) {
+      fs.mkdirSync(skillDir, { recursive: true });
+    }
+
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content, 'utf8');
+  } catch (err) {
+    throw new Error(`Skill yüklenemedi: ${err.message}`);
+  }
+}
+
+// Remove skill
+function removeSkill(slug) {
+  const skillPath = path.join(USER_SKILLS_DIR, slug);
+  
+  if (!fs.existsSync(skillPath)) {
+    throw new Error(`Skill bulunamadı: ${slug}`);
+  }
+
+  fs.rmSync(skillPath, { recursive: true, force: true });
+}
+
+// Update all skills
+async function updateAllSkills() {
+  const skills = getSkills().filter(s => s.source === 'user');
+  const updated = [];
+
+  for (const skill of skills) {
+    try {
+      await installSkill(skill.slug);
+      updated.push(skill.slug);
+    } catch {
+      // Skip failed updates
+    }
+  }
+
+  return updated;
+}
+
+// Create skill template
+function createSkillTemplate(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+  const skillDir = path.join(USER_SKILLS_DIR, slug);
+
+  if (fs.existsSync(skillDir)) {
+    throw new Error(`Skill zaten mevcut: ${slug}`);
+  }
+
+  if (!fs.existsSync(USER_SKILLS_DIR)) {
+    fs.mkdirSync(USER_SKILLS_DIR, { recursive: true });
+  }
+
+  fs.mkdirSync(skillDir, { recursive: true });
+
+  const template = `---
+name: ${name}
+description: ${name} skill açıklaması
+metadata: {"natureco": {"requires": {"bins": [], "env": []}, "os": ["win32","darwin","linux"]}}
+---
+
+# ${name} Skill
+
+Bu skill ${name} işlemlerini yapar.
+
+## Kullanım
+
+[Kullanım talimatları]
+
+## Örnekler
+
+\`\`\`
+[Örnek komutlar]
+\`\`\`
+
+## Notlar
+
+[Ek notlar]
+`;
+
+  fs.writeFileSync(path.join(skillDir, 'SKILL.md'), template, 'utf8');
+
+  return path.join(skillDir, 'SKILL.md');
+}
+
+// Get skill prompt injection content
+function getSkillPrompts() {
+  const skills = getSkills();
+  const prompts = [];
+
+  for (const skill of skills) {
+    const skillFile = path.join(skill.path, 'SKILL.md');
+    if (fs.existsSync(skillFile)) {
+      const content = fs.readFileSync(skillFile, 'utf8');
+      // Remove frontmatter
+      const withoutFrontmatter = content.replace(/^---\n[\s\S]*?\n---\n/, '');
+      prompts.push(`\n## Skill: ${skill.name}\n${withoutFrontmatter}`);
+    }
+  }
+
+  return prompts.join('\n\n');
+}
+
+module.exports = {
+  getSkills,
+  installSkill,
+  removeSkill,
+  updateAllSkills,
+  createSkillTemplate,
+  getSkillPrompts,
+  checkSkillRequirements,
+};