natureco-cli 1.0.1 → 1.0.5

package/src/commands/tasks.js

@@ -0,0 +1,79 @@
+const chalk = require('chalk');
+const { loadBackgroundTasks, getBackgroundTask } = require('../utils/background');
+
+async function tasks(action, ...args) {
+  if (!action || action === 'list') {
+    return listTasks();
+  }
+  
+  if (action === 'show') {
+    const id = args[0];
+    if (!id) {
+      console.log(chalk.red('\n❌ Task ID required\n'));
+      console.log(chalk.gray('Usage: natureco tasks show <id>\n'));
+      process.exit(1);
+    }
+    return showTask(id);
+  }
+  
+  console.log(chalk.red(`\n❌ Unknown action: ${action}\n`));
+  console.log(chalk.gray('Available actions: list, show\n'));
+  process.exit(1);
+}
+
+function listTasks() {
+  const tasks = loadBackgroundTasks();
+  
+  if (tasks.length === 0) {
+    console.log(chalk.gray('\nNo background tasks found.\n'));
+    console.log(chalk.gray('Create one by pressing Ctrl+B in chat.\n'));
+    return;
+  }
+  
+  console.log(chalk.yellow('\nBackground Tasks:\n'));
+  
+  tasks.forEach(task => {
+    const statusColor = task.status === 'completed' ? chalk.green : task.status === 'failed' ? chalk.red : chalk.yellow;
+    const status = statusColor(task.status);
+    
+    console.log(`  ${chalk.cyan(task.id)} ${status}`);
+    console.log(chalk.white(`    ${task.message.slice(0, 60)}...`));
+    console.log(chalk.gray(`    Bot: ${task.botName} | Created: ${new Date(task.createdAt).toLocaleString()}`));
+    console.log('');
+  });
+}
+
+function showTask(id) {
+  const task = getBackgroundTask(id);
+  
+  if (!task) {
+    console.log(chalk.red(`\n❌ Task not found: ${id}\n`));
+    process.exit(1);
+  }
+  
+  console.log(chalk.yellow(`\nTask: ${task.id}\n`));
+  console.log(chalk.gray(`Status: ${task.status}`));
+  console.log(chalk.gray(`Bot: ${task.botName}`));
+  console.log(chalk.gray(`Created: ${new Date(task.createdAt).toLocaleString()}`));
+  
+  if (task.completedAt) {
+    console.log(chalk.gray(`Completed: ${new Date(task.completedAt).toLocaleString()}`));
+  }
+  
+  console.log(chalk.cyan('\nMessage:'));
+  console.log(chalk.white(task.message));
+  
+  if (task.result) {
+    console.log(chalk.cyan('\nResult:'));
+    console.log(chalk.white(task.result));
+  }
+  
+  if (task.error) {
+    console.log(chalk.red('\nError:'));
+    console.log(chalk.white(task.error));
+  }
+  
+  console.log('');
+}
+
+module.exports = tasks;

package/src/utils/api.js

@@ -25,6 +25,9 @@ async function getBots(apiKey) {
 }
 
 async function sendMessage(apiKey, botId, message, conversationId = null, skillPrompts = '') {
+  const { getConfig } = require('./config');
+  const config = getConfig();
+  
   const body = {
     agent_id: botId,
     message,
@@ -38,6 +41,12 @@ async function sendMessage(apiKey, botId, message, conversationId = null, skillP
     body.system_prompt = skillPrompts;
   }
 
+  // Custom AI provider varsa ekle
+  if (config.aiProvider && config.aiApiKey) {
+    body.custom_provider = config.aiProvider;
+    body.custom_api_key = config.aiApiKey;
+  }
+
   return request('/api/agent/chat', {
     method: 'POST',
     headers: { 

package/src/utils/background.js

@@ -0,0 +1,66 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BACKGROUND_TASKS_FILE = path.join(os.homedir(), '.natureco', 'background-tasks.json');
+
+function ensureBackgroundDir() {
+  const dir = path.dirname(BACKGROUND_TASKS_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function loadBackgroundTasks() {
+  ensureBackgroundDir();
+  if (!fs.existsSync(BACKGROUND_TASKS_FILE)) {
+    return [];
+  }
+  try {
+    const data = fs.readFileSync(BACKGROUND_TASKS_FILE, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+
+function saveBackgroundTasks(tasks) {
+  ensureBackgroundDir();
+  fs.writeFileSync(BACKGROUND_TASKS_FILE, JSON.stringify(tasks, null, 2), 'utf-8');
+}
+
+function addBackgroundTask(task) {
+  const tasks = loadBackgroundTasks();
+  const id = Date.now().toString(36) + Math.random().toString(36).slice(2);
+  const newTask = {
+    id,
+    ...task,
+    status: 'pending',
+    createdAt: new Date().toISOString(),
+  };
+  tasks.push(newTask);
+  saveBackgroundTasks(tasks);
+  return newTask;
+}
+
+function updateBackgroundTask(id, updates) {
+  const tasks = loadBackgroundTasks();
+  const index = tasks.findIndex(t => t.id === id);
+  if (index === -1) return false;
+  tasks[index] = { ...tasks[index], ...updates };
+  saveBackgroundTasks(tasks);
+  return true;
+}
+
+function getBackgroundTask(id) {
+  const tasks = loadBackgroundTasks();
+  return tasks.find(t => t.id === id);
+}
+
+module.exports = {
+  loadBackgroundTasks,
+  saveBackgroundTasks,
+  addBackgroundTask,
+  updateBackgroundTask,
+  getBackgroundTask,
+};

package/src/utils/commands.js

@@ -0,0 +1,77 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const USER_COMMANDS_DIR = path.join(os.homedir(), '.natureco', 'commands');
+const PROJECT_COMMANDS_DIR = path.join(process.cwd(), '.natureco', 'commands');
+
+function ensureCommandsDirs() {
+  if (!fs.existsSync(USER_COMMANDS_DIR)) {
+    fs.mkdirSync(USER_COMMANDS_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(PROJECT_COMMANDS_DIR)) {
+    fs.mkdirSync(PROJECT_COMMANDS_DIR, { recursive: true });
+  }
+}
+
+function getCommands() {
+  ensureCommandsDirs();
+  
+  const commands = [];
+  
+  // User commands
+  if (fs.existsSync(USER_COMMANDS_DIR)) {
+    const userFiles = fs.readdirSync(USER_COMMANDS_DIR).filter(f => f.endsWith('.md'));
+    userFiles.forEach(file => {
+      const name = path.basename(file, '.md');
+      const content = fs.readFileSync(path.join(USER_COMMANDS_DIR, file), 'utf-8');
+      commands.push({ name, content, source: 'user' });
+    });
+  }
+  
+  // Project commands
+  if (fs.existsSync(PROJECT_COMMANDS_DIR)) {
+    const projectFiles = fs.readdirSync(PROJECT_COMMANDS_DIR).filter(f => f.endsWith('.md'));
+    projectFiles.forEach(file => {
+      const name = path.basename(file, '.md');
+      const content = fs.readFileSync(path.join(PROJECT_COMMANDS_DIR, file), 'utf-8');
+      commands.push({ name, content, source: 'project' });
+    });
+  }
+  
+  return commands;
+}
+
+function getCommandContent(commandName) {
+  const commands = getCommands();
+  const command = commands.find(c => c.name === commandName);
+  return command ? command.content : null;
+}
+
+function createCommand(name, scope = 'project') {
+  ensureCommandsDirs();
+  
+  const dir = scope === 'user' ? USER_COMMANDS_DIR : PROJECT_COMMANDS_DIR;
+  const filePath = path.join(dir, `${name}.md`);
+  
+  if (fs.existsSync(filePath)) {
+    throw new Error(`Command "${name}" already exists`);
+  }
+  
+  const template = `# ${name} Command
+
+Write your custom instruction here. This will be added to the system prompt when you use /${name} in chat.
+
+Example:
+Review this code for security vulnerabilities, performance issues, and suggest improvements.
+`;
+  
+  fs.writeFileSync(filePath, template, 'utf-8');
+  return filePath;
+}
+
+module.exports = {
+  getCommands,
+  getCommandContent,
+  createCommand,
+};

package/src/utils/cron.js

@@ -0,0 +1,126 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const cron = require('node-cron');
+
+const CRON_FILE = path.join(os.homedir(), '.natureco', 'cron.json');
+const CRON_LOGS_DIR = path.join(os.homedir(), '.natureco', 'cron-logs');
+
+function ensureCronDirs() {
+  const dir = path.dirname(CRON_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  if (!fs.existsSync(CRON_LOGS_DIR)) {
+    fs.mkdirSync(CRON_LOGS_DIR, { recursive: true });
+  }
+}
+
+function loadCronJobs() {
+  ensureCronDirs();
+  if (!fs.existsSync(CRON_FILE)) {
+    return [];
+  }
+  try {
+    const data = fs.readFileSync(CRON_FILE, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+
+function saveCronJobs(jobs) {
+  ensureCronDirs();
+  fs.writeFileSync(CRON_FILE, JSON.stringify(jobs, null, 2), 'utf-8');
+}
+
+function addCronJob(job) {
+  const jobs = loadCronJobs();
+  const id = Date.now().toString(36) + Math.random().toString(36).slice(2);
+  const newJob = {
+    id,
+    ...job,
+    enabled: true,
+    createdAt: new Date().toISOString(),
+  };
+  jobs.push(newJob);
+  saveCronJobs(jobs);
+  return newJob;
+}
+
+function removeCronJob(id) {
+  const jobs = loadCronJobs();
+  const filtered = jobs.filter(j => j.id !== id);
+  saveCronJobs(filtered);
+  return filtered.length < jobs.length;
+}
+
+function updateCronJob(id, updates) {
+  const jobs = loadCronJobs();
+  const index = jobs.findIndex(j => j.id === id);
+  if (index === -1) return false;
+  jobs[index] = { ...jobs[index], ...updates };
+  saveCronJobs(jobs);
+  return true;
+}
+
+function getCronJob(id) {
+  const jobs = loadCronJobs();
+  return jobs.find(j => j.id === id);
+}
+
+function parseCronSchedule(schedule) {
+  // Basit zamanlama formatlarını cron expression'a çevir
+  if (schedule.startsWith('every ')) {
+    const parts = schedule.split(' ');
+    if (parts[2] === 'hours') {
+      const hours = parseInt(parts[1]);
+      return `0 */${hours} * * *`;
+    }
+    if (parts[2] === 'minutes') {
+      const minutes = parseInt(parts[1]);
+      return `*/${minutes} * * * *`;
+    }
+  }
+  
+  if (schedule.startsWith('daily at ')) {
+    const time = schedule.replace('daily at ', '');
+    const [hour, minute = '0'] = time.split(':');
+    return `${minute} ${hour} * * *`;
+  }
+  
+  // Zaten cron expression ise olduğu gibi döndür
+  return schedule;
+}
+
+function validateCronExpression(expression) {
+  return cron.validate(expression);
+}
+
+function logCronOutput(jobId, output) {
+  const logFile = path.join(CRON_LOGS_DIR, `${jobId}.log`);
+  const timestamp = new Date().toISOString();
+  const logEntry = `[${timestamp}]\n${output}\n\n`;
+  fs.appendFileSync(logFile, logEntry, 'utf-8');
+}
+
+function getCronLog(jobId) {
+  const logFile = path.join(CRON_LOGS_DIR, `${jobId}.log`);
+  if (!fs.existsSync(logFile)) {
+    return null;
+  }
+  return fs.readFileSync(logFile, 'utf-8');
+}
+
+module.exports = {
+  loadCronJobs,
+  saveCronJobs,
+  addCronJob,
+  removeCronJob,
+  updateCronJob,
+  getCronJob,
+  parseCronSchedule,
+  validateCronExpression,
+  logCronOutput,
+  getCronLog,
+};

package/src/utils/hooks.js

@@ -0,0 +1,154 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const USER_HOOKS_DIR = path.join(os.homedir(), '.natureco', 'hooks');
+const PROJECT_HOOKS_DIR = path.join(process.cwd(), '.natureco', 'hooks');
+
+function ensureHooksDirs() {
+  if (!fs.existsSync(USER_HOOKS_DIR)) {
+    fs.mkdirSync(USER_HOOKS_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(PROJECT_HOOKS_DIR)) {
+    fs.mkdirSync(PROJECT_HOOKS_DIR, { recursive: true });
+  }
+}
+
+function getHooks(type) {
+  ensureHooksDirs();
+  
+  const hooks = [];
+  
+  // User hooks
+  if (fs.existsSync(USER_HOOKS_DIR)) {
+    const userFiles = fs.readdirSync(USER_HOOKS_DIR).filter(f => f.endsWith('.js') && f.startsWith(type + '-'));
+    userFiles.forEach(file => {
+      const hookPath = path.join(USER_HOOKS_DIR, file);
+      hooks.push({ path: hookPath, source: 'user', name: file });
+    });
+  }
+  
+  // Project hooks
+  if (fs.existsSync(PROJECT_HOOKS_DIR)) {
+    const projectFiles = fs.readdirSync(PROJECT_HOOKS_DIR).filter(f => f.endsWith('.js') && f.startsWith(type + '-'));
+    projectFiles.forEach(file => {
+      const hookPath = path.join(PROJECT_HOOKS_DIR, file);
+      hooks.push({ path: hookPath, source: 'project', name: file });
+    });
+  }
+  
+  return hooks;
+}
+
+function getAllHooks() {
+  ensureHooksDirs();
+  
+  const hooks = [];
+  
+  // User hooks
+  if (fs.existsSync(USER_HOOKS_DIR)) {
+    const userFiles = fs.readdirSync(USER_HOOKS_DIR).filter(f => f.endsWith('.js'));
+    userFiles.forEach(file => {
+      const hookPath = path.join(USER_HOOKS_DIR, file);
+      const type = file.split('-')[0];
+      hooks.push({ path: hookPath, source: 'user', name: file, type });
+    });
+  }
+  
+  // Project hooks
+  if (fs.existsSync(PROJECT_HOOKS_DIR)) {
+    const projectFiles = fs.readdirSync(PROJECT_HOOKS_DIR).filter(f => f.endsWith('.js'));
+    projectFiles.forEach(file => {
+      const hookPath = path.join(PROJECT_HOOKS_DIR, file);
+      const type = file.split('-')[0];
+      hooks.push({ path: hookPath, source: 'project', name: file, type });
+    });
+  }
+  
+  return hooks;
+}
+
+async function runHooks(type, data, context = {}) {
+  const hooks = getHooks(type);
+  let result = data;
+  
+  for (const hook of hooks) {
+    try {
+      // Clear require cache to reload hook
+      delete require.cache[require.resolve(hook.path)];
+      const hookFn = require(hook.path);
+      
+      if (typeof hookFn === 'function') {
+        result = await hookFn(result, context);
+      }
+    } catch (err) {
+      console.error(`Hook error (${hook.name}):`, err.message);
+    }
+  }
+  
+  return result;
+}
+
+function createHook(type, scope = 'project') {
+  ensureHooksDirs();
+  
+  const dir = scope === 'user' ? USER_HOOKS_DIR : PROJECT_HOOKS_DIR;
+  const timestamp = Date.now().toString(36);
+  const fileName = `${type}-${timestamp}.js`;
+  const filePath = path.join(dir, fileName);
+  
+  const templates = {
+    'pre-message': `module.exports = async function(message, context) {
+  // This hook runs before sending a message to the bot
+  // You can modify the message or log it
+  
+  console.log('[Hook] Sending message:', message);
+  
+  // Return the (possibly modified) message
+  return message;
+};
+`,
+    'post-message': `module.exports = async function(reply, context) {
+  // This hook runs after receiving a reply from the bot
+  // You can modify the reply or log it
+  
+  console.log('[Hook] Received reply:', reply);
+  
+  // Return the (possibly modified) reply
+  return reply;
+};
+`,
+    'on-start': `module.exports = async function(data, context) {
+  // This hook runs when chat starts
+  
+  console.log('[Hook] Chat started with bot:', context.botName);
+  
+  return data;
+};
+`,
+    'on-exit': `module.exports = async function(data, context) {
+  // This hook runs when chat exits
+  
+  console.log('[Hook] Chat ended');
+  
+  return data;
+};
+`,
+  };
+  
+  const template = templates[type] || `module.exports = async function(data, context) {
+  // Custom hook
+  return data;
+};
+`;
+  
+  fs.writeFileSync(filePath, template, 'utf-8');
+  return filePath;
+}
+
+module.exports = {
+  getHooks,
+  getAllHooks,
+  runHooks,
+  createHook,
+};

package/src/utils/memory.js

@@ -0,0 +1,160 @@
+const fs = require('fs');
+const path = require('path');
+const { CONFIG_DIR } = require('./config');
+
+const MEMORY_DIR = path.join(CONFIG_DIR, 'memory');
+
+// Ensure memory directory exists
+function ensureMemoryDir() {
+  if (!fs.existsSync(MEMORY_DIR)) {
+    fs.mkdirSync(MEMORY_DIR, { recursive: true });
+  }
+}
+
+// Get memory file path for a bot
+function getMemoryFilePath(botId) {
+  ensureMemoryDir();
+  return path.join(MEMORY_DIR, `${botId}.json`);
+}
+
+// Load memory for a bot
+function loadMemory(botId) {
+  const filePath = getMemoryFilePath(botId);
+  
+  if (!fs.existsSync(filePath)) {
+    return {
+      name: null,
+      preferences: [],
+      facts: [],
+      lastSeen: null,
+    };
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return {
+      name: null,
+      preferences: [],
+      facts: [],
+      lastSeen: null,
+    };
+  }
+}
+
+// Save memory for a bot
+function saveMemory(botId, memory) {
+  const filePath = getMemoryFilePath(botId);
+  
+  try {
+    memory.lastSeen = new Date().toISOString();
+    fs.writeFileSync(filePath, JSON.stringify(memory, null, 2), 'utf8');
+  } catch (err) {
+    // Silently fail - memory is not critical
+  }
+}
+
+// Add memory entry
+function addMemoryEntry(botId, key, value) {
+  const memory = loadMemory(botId);
+  
+  if (key === 'name') {
+    memory.name = value;
+  } else if (key === 'preference') {
+    if (!memory.preferences.includes(value)) {
+      memory.preferences.push(value);
+    }
+  } else if (key === 'fact') {
+    if (!memory.facts.includes(value)) {
+      memory.facts.push(value);
+    }
+  }
+  
+  saveMemory(botId, memory);
+}
+
+// Extract memory from message (simple keyword extraction)
+function extractMemoryFromMessage(message) {
+  const extracted = [];
+  
+  // Name patterns: "adım X", "ben X'im", "ismim X"
+  const namePatterns = [
+    /ad[ıi]m\s+([A-ZÇĞİÖŞÜ][a-zçğıöşü]+)/i,
+    /ben\s+([A-ZÇĞİÖŞÜ][a-zçğıöşü]+)['']?[ıi]?m/i,
+    /[iı]smim\s+([A-ZÇĞİÖŞÜ][a-zçğıöşü]+)/i,
+  ];
+  
+  for (const pattern of namePatterns) {
+    const match = message.match(pattern);
+    if (match) {
+      extracted.push({ key: 'name', value: match[1] });
+      break;
+    }
+  }
+  
+  // Location patterns: "X'te yaşıyorum", "X'de yaşıyorum"
+  const locationPatterns = [
+    /([A-ZÇĞİÖŞÜ][a-zçğıöşü]+)['']?[td]e\s+ya[şs][ıi]yorum/i,
+  ];
+  
+  for (const pattern of locationPatterns) {
+    const match = message.match(pattern);
+    if (match) {
+      extracted.push({ key: 'fact', value: `${match[1]}'de yaşıyor` });
+    }
+  }
+  
+  // Profession patterns: "ben X'im", "X olarak çalışıyorum"
+  const professionKeywords = ['yazılımcı', 'developer', 'öğrenci', 'öğretmen', 'mühendis', 'doktor'];
+  for (const keyword of professionKeywords) {
+    if (message.toLowerCase().includes(keyword)) {
+      extracted.push({ key: 'fact', value: keyword.charAt(0).toUpperCase() + keyword.slice(1) });
+    }
+  }
+  
+  return extracted;
+}
+
+// Get memory as system prompt
+function getMemoryPrompt(botId) {
+  const memory = loadMemory(botId);
+  
+  if (!memory.name && memory.preferences.length === 0 && memory.facts.length === 0) {
+    return '';
+  }
+  
+  const parts = ['## Kullanıcı Hafızası'];
+  
+  if (memory.name) {
+    parts.push(`İsim: ${memory.name}`);
+  }
+  
+  if (memory.preferences.length > 0) {
+    parts.push(`Tercihler: ${memory.preferences.join(', ')}`);
+  }
+  
+  if (memory.facts.length > 0) {
+    parts.push(`Bilgiler: ${memory.facts.join(', ')}`);
+  }
+  
+  return parts.join('\n');
+}
+
+// Clear memory for a bot
+function clearMemory(botId) {
+  const filePath = getMemoryFilePath(botId);
+  
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+}
+
+module.exports = {
+  loadMemory,
+  saveMemory,
+  addMemoryEntry,
+  extractMemoryFromMessage,
+  getMemoryPrompt,
+  clearMemory,
+};