natureco-cli 2.23.30 → 2.23.32

package/src/commands/acp.js

@@ -0,0 +1,39 @@
+const chalk = require('chalk');
+
+function acp(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'status') return cmdStatus();
+  if (action === 'info') return cmdInfo();
+
+  console.log(chalk.red(`\n  Unknown acp action: ${action}\n`));
+  console.log(chalk.gray('  Usage: natureco acp <action>'));
+  console.log(chalk.gray('  Actions: status, info\n'));
+  process.exit(1);
+}
+
+function cmdStatus() {
+  console.log(chalk.cyan('\n  ACP (Agent Communication Protocol) Status\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Endpoint:')}  ${chalk.green('http://127.0.0.1:3847/acp')}`);
+  console.log(`  ${chalk.white('Status:')}    ${chalk.gray('Stub — no real implementation')}`);
+  console.log('');
+  console.log(chalk.gray('  Available endpoints:'));
+  console.log(chalk.gray('    GET  /acp           — Protocol root'));
+  console.log(chalk.gray('    GET  /acp/health    — Health check'));
+  console.log(chalk.gray('    POST /acp/message   — Send agent message'));
+  console.log(chalk.gray('    GET  /acp/agents    — List agents'));
+  console.log('');
+}
+
+function cmdInfo() {
+  console.log(chalk.cyan('\n  ACP Protocol Info\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Protocol:')}  ${chalk.cyan('Agent Communication Protocol')}`);
+  console.log(`  ${chalk.white('Version:')}   ${chalk.cyan('1.0.0')}`);
+  console.log(`  ${chalk.white('Port:')}      ${chalk.cyan('3847')}`);
+  console.log(`  ${chalk.white('Transport:')} ${chalk.cyan('HTTP/JSON')}`);
+  console.log('');
+}
+
+module.exports = acp;

package/src/commands/admin-rpc.js

@@ -126,6 +126,75 @@ async function callMethod(method, jsonParams) {
     return;
   }
 
+  if (method === 'config.set') {
+    const { setConfigValue } = require('../utils/config');
+    if (!params.key) { console.log(chalk.red('\n  ❌ params.key gerekli\n')); process.exit(1); }
+    setConfigValue(params.key, params.value);
+    console.log(chalk.green(`\n  ✅ config.${params.key} = ${JSON.stringify(params.value)}\n`));
+    return;
+  }
+
+  if (method === 'channels.status' || method === 'channels.start' || method === 'channels.stop') {
+    const { getAllConfig } = require('../utils/config');
+    const cfg = getAllConfig();
+    const channels = ['telegram', 'discord', 'slack', 'whatsapp'];
+    console.log(chalk.cyan(`\n  📡 Channel: ${method}\n`));
+    if (method === 'channels.status') {
+      for (const ch of channels) {
+        const token = cfg[`${ch}Token`];
+        console.log(`  ${token ? chalk.green('●') : chalk.gray('○')} ${ch} ${token ? chalk.gray('(configured)') : chalk.gray('(not set)')}`);
+      }
+    } else {
+      const ch = params.name || 'all';
+      console.log(chalk.gray(`  ${method.split('.')[1]} ${ch} (simulated)\n`));
+    }
+    console.log();
+    return;
+  }
+
+  if (method === 'agents.list') {
+    const { listTasks, getTaskSummary } = require('../utils/background');
+    const tasks = listTasks({ limit: 20 });
+    const summary = getTaskSummary();
+    console.log(chalk.cyan(`\n  👤 Agents (${summary.active} active, ${summary.total} total)\n`));
+    console.log(chalk.gray('  ' + '─'.repeat(48)));
+    for (const t of tasks.slice(0, 10)) {
+      const icon = t.status === 'succeeded' ? chalk.green('✓') : t.status === 'running' ? chalk.yellow('●') : chalk.gray('○');
+      console.log(`  ${icon} ${chalk.white(t.message || '(no message)')}`);
+      console.log(chalk.gray(`     [${t.id}] ${t.runtime} — ${t.status}`));
+    }
+    console.log();
+    return;
+  }
+
+  if (method === 'cron.list' || method === 'cron.status') {
+    const { getConfig } = require('../utils/config');
+    const config = getConfig();
+    const jobs = config.cronJobs || [];
+    console.log(chalk.cyan(`\n  ⏰ ${method} (${jobs.length} jobs)\n`));
+    if (jobs.length === 0) {
+      console.log(chalk.gray('  Cron job yapılandırılmamış.\n'));
+      return;
+    }
+    for (const j of jobs) {
+      console.log(`  ${chalk.white(j.name || '(unnamed)')} — ${chalk.gray(j.schedule || j.interval)}`);
+    }
+    console.log();
+    return;
+  }
+
+  if (method === 'tasks.list') {
+    const { listTasks, getTaskSummary } = require('../utils/background');
+    const tasks = listTasks({ limit: 20 });
+    const summary = getTaskSummary();
+    console.log(chalk.cyan(`\n  📋 Tasks (${summary.active} active, ${summary.total} total)\n`));
+    for (const t of tasks.slice(0, 15)) {
+      console.log(`  ${chalk.white(t.id)} — ${chalk.cyan(t.status)} — ${chalk.gray(t.message?.substring(0, 50) || '')}`);
+    }
+    console.log();
+    return;
+  }
+
   console.log(chalk.yellow(`  ⚠️  Method "${method}" henüz implemente edilmedi\n`));
 }
 
@@ -174,6 +243,20 @@ function startAdmin(portStr) {
         } else if (rpc.method === 'plugins.list') {
           const { loadTools } = require('../utils/tool-runner');
           payload = { tools: Object.keys(loadTools()) };
+        } else if (rpc.method === 'config.set') {
+          const { setConfigValue } = require('../utils/config');
+          setConfigValue(rpc.params.key, rpc.params.value);
+          payload = { ok: true, key: rpc.params.key, value: rpc.params.value };
+        } else if (rpc.method === 'channels.status' || rpc.method === 'channels.start' || rpc.method === 'channels.stop') {
+          const channels = ['telegram', 'discord', 'slack', 'whatsapp'];
+          const status = {};
+          for (const ch of channels) status[ch] = !!config[`${ch}Token`];
+          payload = { action: rpc.method, channels: status };
+        } else if (rpc.method === 'agents.list' || rpc.method === 'tasks.list') {
+          const { listTasks, getTaskSummary } = require('../utils/background');
+          payload = { summary: getTaskSummary(), tasks: listTasks({ limit: 20 }) };
+        } else if (rpc.method === 'cron.list' || rpc.method === 'cron.status') {
+          payload = { jobs: config.cronJobs || [] };
         } else {
           payload = { message: `Method "${rpc.method}" called`, params: rpc.params };
         }

package/src/commands/agent.js

@@ -1,4 +1,10 @@
 const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BINDINGS_FILE = path.join(os.homedir(), '.natureco', 'agent-bindings.json');
+const IDENTITIES_FILE = path.join(os.homedir(), '.natureco', 'agent-identities.json');
 
 async function agent(args) {
   const opts = {};
@@ -10,10 +16,18 @@ async function agent(args) {
     else if (args[i] === '--model') opts.model = args[++i];
     else if (args[i] === '--provider') opts.provider = args[++i];
     else if (!opts.action) opts.action = args[i];
+    else (opts._positional = opts._positional || []).push(args[i]);
   }
 
   if (!opts.action || opts.action === 'help') return showHelp();
   if (opts.action === 'run') return runAgent(opts);
+  if (opts.action === 'abort') return abortAgent(opts.message);
+  if (opts.action === 'tail') return tailAgent(opts.message);
+  if (opts.action === 'logs') return logsAgent(opts.message);
+  if (opts.action === 'bindings') return listBindings();
+  if (opts.action === 'bind') return bindAgent(opts);
+  if (opts.action === 'unbind') return unbindAgent(opts);
+  if (opts.action === 'set-identity') return setIdentity(opts);
 
   console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${opts.action}\n`));
   process.exit(1);
@@ -21,13 +35,28 @@ async function agent(args) {
 
 async function runAgent(opts) {
   const { getConfig } = require('../utils/config');
+  const { createTask } = require('../utils/background');
+  const { getProviderConfig } = require('../utils/api');
   const config = getConfig();
+  const pc = getProviderConfig();
 
-  const provider = opts.provider || config.provider || 'openai';
-  const model = opts.model || config.model || 'gpt-4o';
+  const provider = opts.provider || (pc?.url?.includes('groq') ? 'groq' : config.provider || 'openai');
+  const model = opts.model || config.providerModel || config.model || 'llama-3.3-70b-versatile';
   const message = opts.message || 'Hello';
+  const apiKey = pc?.apiKey || config[`${provider}ApiKey`] || process.env[`${provider.toUpperCase()}_API_KEY`];
+
+  if (!apiKey) {
+    console.log(chalk.red(`\n  ❌ ${provider} API key gerekli\n`));
+    process.exit(1);
+  }
 
-  console.log(chalk.cyan(`\n  🤖 Agent Turn\n`));
+  const task = createTask({
+    runtime: 'cli',
+    message: message.substring(0, 80),
+    botName: opts.to || 'default',
+  });
+
+  console.log(chalk.cyan(`\n  🤖 Agent Turn [${task.id}]\n`));
   console.log(chalk.gray('  ' + '─'.repeat(48)));
   console.log(`  ${chalk.white('Message:')}  ${message}`);
   if (opts.to) console.log(`  ${chalk.white('To:')}       ${opts.to}`);
@@ -37,24 +66,26 @@ async function runAgent(opts) {
   console.log(chalk.gray('\n  Running...\n'));
 
   try {
-    const apiKey = config[`${provider}ApiKey`] || process.env[`${provider.toUpperCase()}_API_KEY`];
-    if (!apiKey) {
-      console.log(chalk.red(`  ❌ ${provider} API key gerekli\n`));
-      process.exit(1);
-    }
+    const { updateTask } = require('../utils/background');
+    updateTask(task.id, { status: 'running' });
 
-    const baseUrl = provider === 'openai' ? 'https://api.openai.com/v1' : `https://api.${provider}.com/v1`;
-    const response = await fetch(`${baseUrl}/chat/completions`, {
+    const apiUrl = pc?.url || `https://api.${provider}.com/v1`;
+    const response = await fetch(`${apiUrl}/chat/completions`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
       body: JSON.stringify({ model, messages: [{ role: 'user', content: message }], max_tokens: 2048 })
     });
 
-    if (!response.ok) throw new Error(`API error ${response.status}`);
+    if (!response.ok) {
+      updateTask(task.id, { status: 'failed', error: `API error ${response.status}` });
+      throw new Error(`API error ${response.status}`);
+    }
 
     const data = await response.json();
     const reply = data.choices?.[0]?.message?.content || 'No response';
 
+    updateTask(task.id, { status: 'succeeded', result: reply.substring(0, 500) });
+
     console.log(chalk.white('  Response:'));
     console.log(chalk.gray(`  ${reply.substring(0, 500)}`));
 
@@ -69,21 +100,181 @@ async function runAgent(opts) {
   }
 }
 
+function abortAgent(taskId) {
+  const { cancelTask, listTasks } = require('../utils/background');
+  if (taskId) {
+    const t = cancelTask(taskId);
+    if (!t) { console.log(chalk.red(`\n  ❌ Task bulunamadı: ${taskId}\n`)); process.exit(1); }
+    console.log(chalk.yellow(`\n  🛑 Task iptal edildi: ${taskId}\n`));
+    return;
+  }
+  const running = listTasks({ status: 'running' });
+  if (running.length === 0) {
+    console.log(chalk.gray('\n  Çalışan task yok\n'));
+    return;
+  }
+  for (const t of running) {
+    cancelTask(t.id);
+    console.log(chalk.yellow(`  🛑 Task iptal edildi: ${t.id} — ${t.message}`));
+  }
+  console.log();
+}
+
+function tailAgent(taskId) {
+  const { getTask } = require('../utils/background');
+  if (!taskId) {
+    console.log(chalk.red('\n  ❌ Task ID gerekli. Kullanım: natureco agent tail <id>\n'));
+    process.exit(1);
+  }
+  const task = getTask(taskId);
+  if (!task) { console.log(chalk.red(`\n  ❌ Task bulunamadı: ${taskId}\n`)); process.exit(1); }
+  console.log(chalk.cyan(`\n  📋 Task: ${task.id}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Message:')}  ${task.message}`);
+  console.log(`  ${chalk.white('Status:')}   ${statusColor(task.status)}`);
+  if (task.result) console.log(`  ${chalk.white('Result:')}   ${chalk.gray(task.result.substring(0, 300))}`);
+  if (task.error) console.log(`  ${chalk.white('Error:')}    ${chalk.red(task.error)}`);
+  if (task.createdAt) console.log(`  ${chalk.white('Created:')} ${chalk.gray(task.createdAt)}`);
+  if (task.endedAt) console.log(`  ${chalk.white('Ended:')}   ${chalk.gray(task.endedAt)}`);
+  console.log();
+}
+
+function logsAgent(statusFilter) {
+  const { listTasks } = require('../utils/background');
+  const tasks = listTasks(statusFilter ? { status: statusFilter } : {});
+  console.log(chalk.cyan(`\n  📜 Agent Logs${statusFilter ? ` (${statusFilter})` : ''}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  if (tasks.length === 0) {
+    console.log(chalk.gray('  Task bulunamadı.\n'));
+    return;
+  }
+  for (const t of tasks.slice(0, 20)) {
+    console.log(`  ${statusColor(t.status)} ${chalk.white(t.message || '(boş)')}`);
+    console.log(chalk.gray(`     [${t.id}] ${t.createdAt?.slice(0, 16) || ''} — ${t.runtime}`));
+  }
+  console.log();
+}
+
+// ── bindings ──────────────────────────────────────────────────────────
+function listBindings() {
+  const bindings = loadBindings();
+  const ids = loadIdentities();
+  console.log(chalk.cyan('\n  Agent Bindings\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  const entries = Object.entries(bindings);
+  if (entries.length === 0) {
+    console.log(chalk.gray('  No agents bound to any channels.\n'));
+    return;
+  }
+  for (const [agentId, channels] of entries) {
+    const identity = ids[agentId];
+    console.log(`  ${chalk.white(agentId)}${identity ? chalk.gray(' (' + identity + ')') : ''}`);
+    for (const ch of channels) {
+      console.log(chalk.gray('    └─ ') + chalk.cyan(ch));
+    }
+  }
+  console.log('');
+}
+
+function loadBindings() {
+  if (!fs.existsSync(BINDINGS_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(BINDINGS_FILE, 'utf8')); } catch { return {}; }
+}
+
+function saveBindings(data) {
+  const dir = path.dirname(BINDINGS_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(BINDINGS_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function bindAgent(opts) {
+  const pos = opts._positional || [];
+  const agentId = pos[0];
+  const channel = pos[1] || opts.channel;
+  if (!agentId || !channel) {
+    console.log(chalk.red('\nUsage: natureco agents bind <agentId> <channel>\n'));
+    process.exit(1);
+  }
+  const bindings = loadBindings();
+  if (!bindings[agentId]) bindings[agentId] = [];
+  if (!bindings[agentId].includes(channel)) bindings[agentId].push(channel);
+  saveBindings(bindings);
+  console.log(chalk.green('\nAgent "' + agentId + '" bound to ' + channel + '\n'));
+}
+
+function unbindAgent(opts) {
+  const pos = opts._positional || [];
+  const agentId = pos[0];
+  const channel = pos[1] || opts.channel;
+  if (!agentId || !channel) {
+    console.log(chalk.red('\nUsage: natureco agents unbind <agentId> <channel>\n'));
+    process.exit(1);
+  }
+  const bindings = loadBindings();
+  if (bindings[agentId]) {
+    bindings[agentId] = bindings[agentId].filter(c => c !== channel);
+    if (bindings[agentId].length === 0) delete bindings[agentId];
+  }
+  saveBindings(bindings);
+  console.log(chalk.green('\nAgent "' + agentId + '" unbound from ' + channel + '\n'));
+}
+
+// ── identities ────────────────────────────────────────────────────────
+function loadIdentities() {
+  if (!fs.existsSync(IDENTITIES_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(IDENTITIES_FILE, 'utf8')); } catch { return {}; }
+}
+
+function saveIdentities(data) {
+  const dir = path.dirname(IDENTITIES_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(IDENTITIES_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function setIdentity(opts) {
+  const pos = opts._positional || [];
+  const agentId = pos[0];
+  const identity = pos.slice(1).join(' ') || opts.message;
+  if (!agentId || !identity) {
+    console.log(chalk.red('\nUsage: natureco agents set-identity <agentId> <identity>\n'));
+    process.exit(1);
+  }
+  const ids = loadIdentities();
+  ids[agentId] = identity;
+  saveIdentities(ids);
+  console.log(chalk.green('\nIdentity set for agent "' + agentId + '": ' + identity + '\n'));
+}
+
+function statusColor(s) {
+  const m = { succeeded: chalk.green('✓'), failed: chalk.red('✗'), running: chalk.yellow('●'), queued: chalk.cyan('○'), cancelled: chalk.gray('−'), timed_out: chalk.red('⚠'), lost: chalk.magenta('?') };
+  return m[s] || chalk.gray('○');
+}
+
 function showHelp() {
   console.log(chalk.cyan('\n  🤖 Agent\n'));
-  console.log(chalk.gray('  Run one agent turn via the Gateway'));
-  console.log(chalk.gray('\n  Usage: natureco agent [options]'));
-  console.log(chalk.gray('\n  Options:'));
-  console.log(chalk.cyan('    run') + chalk.gray('                    Run an agent turn'));
-  console.log(chalk.cyan('    --message, -m <text>') + chalk.gray('  Message to send'));
-  console.log(chalk.cyan('    --to, -t <target>') + chalk.gray('     Target channel/contact'));
-  console.log(chalk.cyan('    --channel, -c <name>') + chalk.gray('  Channel to use'));
-  console.log(chalk.cyan('    --deliver') + chalk.gray('             Deliver reply via channel'));
-  console.log(chalk.cyan('    --model <model>') + chalk.gray('       Model override'));
-  console.log(chalk.cyan('    --provider <name>') + chalk.gray('    Provider override'));
+  console.log(chalk.gray('  Run, manage, and monitor agent tasks.\n'));
+  console.log(chalk.gray('  Usage: natureco agent <action> [options]'));
+  console.log(chalk.gray('\n  Actions:'));
+  console.log(chalk.cyan('    run') + chalk.gray('                     Run an agent turn'));
+  console.log(chalk.cyan('    abort [id]') + chalk.gray('             Cancel a running task'));
+  console.log(chalk.cyan('    tail <id>') + chalk.gray('              Show task details'));
+  console.log(chalk.cyan('    logs [status]') + chalk.gray('          List recent tasks'));
+  console.log(chalk.cyan('    bindings') + chalk.gray('               List agent bindings'));
+  console.log(chalk.cyan('    bind <id> <ch>') + chalk.gray('        Bind agent to channel'));
+  console.log(chalk.cyan('    unbind <id> <ch>') + chalk.gray('      Unbind agent from channel'));
+  console.log(chalk.cyan('    set-identity <id> <persona>') + chalk.gray('   Set agent identity'));
+  console.log(chalk.gray('\n  Options for run:'));
+  console.log(chalk.cyan('    --message, -m <text>') + chalk.gray('   Message to send'));
+  console.log(chalk.cyan('    --to, -t <target>') + chalk.gray('      Target channel/contact'));
+  console.log(chalk.cyan('    --channel, -c <name>') + chalk.gray('   Channel to use'));
+  console.log(chalk.cyan('    --deliver') + chalk.gray('              Deliver reply via channel'));
+  console.log(chalk.cyan('    --model <model>') + chalk.gray('        Model override'));
+  console.log(chalk.cyan('    --provider <name>') + chalk.gray('     Provider override'));
   console.log(chalk.gray('\n  Examples:'));
-  console.log(chalk.gray('    natureco agent run --message "Summarize this"'));
-  console.log(chalk.gray('    natureco agent run --to +1234 --message "Hi" --deliver\n'));
+  console.log(chalk.gray('    natureco agent run --message "Merhaba"'));
+  console.log(chalk.gray('    natureco agent abort'));
+  console.log(chalk.gray('    natureco agent tail <id>'));
+  console.log(chalk.gray('    natureco agent logs running\n'));
 }
 
 module.exports = agent;

package/src/commands/agents.js

@@ -1,8 +1,39 @@
 const chalk = require('chalk');
+const F = require('../utils/format');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 const inquirer = require('../utils/inquirer-wrapper');
 const { getConfig, saveConfig } = require('../utils/config');
 const { getBots } = require('../utils/api');
 
+const BINDINGS_FILE = path.join(os.homedir(), '.natureco', 'agent-bindings.json');
+const IDENTITIES_FILE = path.join(os.homedir(), '.natureco', 'agent-identities.json');
+
+function loadBindings() {
+  try {
+    if (fs.existsSync(BINDINGS_FILE)) return JSON.parse(fs.readFileSync(BINDINGS_FILE, 'utf8'));
+  } catch {}
+  return {};
+}
+
+function saveBindings(data) {
+  fs.mkdirSync(path.dirname(BINDINGS_FILE), { recursive: true });
+  fs.writeFileSync(BINDINGS_FILE, JSON.stringify(data, null, 2));
+}
+
+function loadIdentities() {
+  try {
+    if (fs.existsSync(IDENTITIES_FILE)) return JSON.parse(fs.readFileSync(IDENTITIES_FILE, 'utf8'));
+  } catch {}
+  return {};
+}
+
+function saveIdentities(data) {
+  fs.mkdirSync(path.dirname(IDENTITIES_FILE), { recursive: true });
+  fs.writeFileSync(IDENTITIES_FILE, JSON.stringify(data, null, 2));
+}
+
 async function agents(args) {
   const [action, ...params] = (args || []);
 
@@ -10,9 +41,13 @@ async function agents(args) {
   if (action === 'set') return setActiveAgent(params[0]);
   if (action === 'info') return agentInfo(params[0]);
   if (action === 'add') return addAgent();
+  if (action === 'bindings') return listBindings();
+  if (action === 'bind') return bindAgent(params[0], params[1]);
+  if (action === 'unbind') return unbindAgent(params[0], params[1]);
+  if (action === 'set-identity') return setIdentity(params[0], params.slice(1).join(' '));
 
   console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
-  console.log(chalk.gray('  Kullanım: natureco agents [list|set|info|add]\n'));
+  console.log(chalk.gray('  Kullanım: natureco agents [list|set|info|add|bindings|bind|unbind|set-identity]\n'));
   process.exit(1);
 }
 
@@ -20,32 +55,28 @@ async function listAgents() {
   const config = getConfig();
   const apiKey = config.providerApiKey || config.apiKey || '';
 
-  console.log(chalk.gray('\n  Agentlar yükleniyor...\n'));
+  F.info('Agentlar yükleniyor...');
 
   let botList = { bots: [] };
   try {
     botList = await getBots(apiKey);
   } catch {}
 
-  console.log(chalk.gray('  ' + '─'.repeat(48)));
-  console.log(chalk.cyan.bold('\n  Agentlar (Botlar)\n'));
+  F.header('Agents');
 
   if (!botList.bots?.length) {
-    console.log(chalk.gray('  Agent bulunamadı.'));
-    console.log(chalk.gray('  Oluşturmak için: ') + chalk.cyan('developers.natureco.me\n'));
+    F.list(['Agent bulunamadı.', 'Oluşturmak için: developers.natureco.me']);
     return;
   }
 
-  botList.bots.forEach((bot, i) => {
-    const active = config.botName === bot.name ? chalk.green(' ← aktif') : '';
-    console.log(chalk.white(`  ${i + 1}. ${bot.name}`) + active);
-    console.log(chalk.gray(`     ID      : ${bot.id}`));
-    console.log(chalk.gray(`     Provider: ${bot.ai_provider || 'groq'}`));
-    if (bot.model) console.log(chalk.gray(`     Model   : ${bot.model}`));
-    console.log('');
-  });
+  const rows = botList.bots.map(bot => [
+    bot.name + (config.botName === bot.name ? ' ← aktif' : ''),
+    bot.id,
+    bot.ai_provider || 'groq',
+    bot.model || '—'
+  ]);
+  F.table(['Name', 'ID', 'Provider', 'Model'], rows);
 
-  console.log(chalk.gray('  ' + '─'.repeat(48)));
   console.log(chalk.gray('  Değiştirmek için: ') + chalk.cyan('natureco agents set <bot-adı>\n'));
 }
 
@@ -91,7 +122,7 @@ async function agentInfo(botName) {
   const name = botName || config.botName;
 
   if (!name) {
-    console.log(chalk.gray('\n  Agent adı belirtin: natureco agents info <bot-adı>\n'));
+    F.error('Agent adı belirtin: natureco agents info <bot-adı>');
     return;
   }
 
@@ -102,33 +133,27 @@ async function agentInfo(botName) {
 
   const bot = botList.bots?.find(b => b.name === name || b.id === name);
 
-  console.log('');
-  console.log(chalk.gray('  ' + '─'.repeat(48)));
-  console.log(chalk.cyan.bold(`\n  Agent: ${name}\n`));
+  F.header('Agent: ' + name);
 
   if (bot) {
-    console.log(chalk.gray('  ID      : ') + chalk.white(bot.id));
-    console.log(chalk.gray('  Provider: ') + chalk.white(bot.ai_provider || 'groq'));
-    if (bot.model) console.log(chalk.gray('  Model   : ') + chalk.white(bot.model));
+    F.kv('ID', bot.id);
+    F.kv('Provider', bot.ai_provider || 'groq');
+    if (bot.model) F.kv('Model', bot.model);
     if (bot.system_prompt) {
-      console.log(chalk.gray('  Prompt  : ') + chalk.white(bot.system_prompt.slice(0, 80) + (bot.system_prompt.length > 80 ? '...' : '')));
+      F.kv('Prompt', bot.system_prompt.slice(0, 80) + (bot.system_prompt.length > 80 ? '...' : ''));
     }
   } else {
-    console.log(chalk.gray('  (Detay alınamadı)'));
+    F.meta('(Detay alınamadı)');
   }
 
-  // Hafıza bilgisi
   try {
     const { loadMemory } = require('../utils/memory');
     const mem = loadMemory(bot?.id || 'universal-provider');
     if (mem.name || mem.facts?.length) {
-      console.log('');
-      if (mem.name) console.log(chalk.gray('  Kullanıcı: ') + chalk.white(mem.name));
-      console.log(chalk.gray('  Hafıza   : ') + chalk.white(`${(mem.facts || []).length} bilgi`));
+      if (mem.name) F.kv('Kullanıcı', mem.name);
+      F.kv('Hafıza', (mem.facts || []).length + ' bilgi');
     }
   } catch {}
-
-  console.log('');
 }
 
 async function addAgent() {
@@ -138,4 +163,63 @@ async function addAgent() {
   console.log(chalk.gray('  Oluşturduktan sonra: ') + chalk.cyan('natureco agents list\n'));
 }
 
+// ── Bindings ──────────────────────────────────────────────────────────────────
+
+function listBindings() {
+  const bindings = loadBindings();
+  const keys = Object.keys(bindings);
+
+  F.section('Bindings (' + keys.length + ')');
+
+  if (keys.length === 0) {
+    F.meta('Henüz binding yok.');
+    return;
+  }
+
+  const items = [];
+  keys.forEach(agentId => {
+    bindings[agentId].forEach(ch => items.push(agentId + ' → ' + ch));
+  });
+  F.list(items);
+}
+
+function bindAgent(agentId, channel) {
+  if (!agentId || !channel) {
+    F.error('Kullanım: natureco agents bind <agentId> <channel>');
+    return;
+  }
+  const bindings = loadBindings();
+  if (!bindings[agentId]) bindings[agentId] = [];
+  if (!bindings[agentId].includes(channel)) bindings[agentId].push(channel);
+  saveBindings(bindings);
+  F.success('Agent ' + agentId + ' → ' + channel + ' bağlandı');
+}
+
+function unbindAgent(agentId, channel) {
+  if (!agentId || !channel) {
+    F.error('Kullanım: natureco agents unbind <agentId> <channel>');
+    return;
+  }
+  const bindings = loadBindings();
+  if (!bindings[agentId]) {
+    F.warning('Agent ' + agentId + ' için binding bulunamadı');
+    return;
+  }
+  bindings[agentId] = bindings[agentId].filter(ch => ch !== channel);
+  if (bindings[agentId].length === 0) delete bindings[agentId];
+  saveBindings(bindings);
+  F.success('Agent ' + agentId + ' → ' + channel + ' bağlantısı kaldırıldı');
+}
+
+function setIdentity(agentId, identity) {
+  if (!agentId) {
+    F.error('Kullanım: natureco agents set-identity <agentId> <identity>');
+    return;
+  }
+  const identities = loadIdentities();
+  identities[agentId] = identity || 'default';
+  saveIdentities(identities);
+  F.success('Agent ' + agentId + ' identity: ' + (identity || 'default'));
+}
+
 module.exports = agents;