clydeclaw 1.1.0 → 1.2.0

package/package/bin/clydeclaw.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import { parseArgs } from '../src/cli/parser.js';
+import { handleCommand } from '../src/cli/commands.js';
+import { log } from '../src/utils/logger.js';
+
+const { command, args } = parseArgs(process.argv.slice(2));
+
+try {
+  await handleCommand(command, args);
+} catch (err) {
+  log.error(`Fatal: ${err.message}`);
+  process.exit(1);
+}

package/package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "clydeclaw",
+  "version": "1.1.0",
+  "description": "i made this for me and my firend",
+  "type": "module",
+  "bin": {
+    "clydeclaw": "./bin/clydeclaw.js"
+  },
+  "scripts": {
+    "start": "node bin/clydeclaw.js start",
+    "dev": "node --watch bin/clydeclaw.js start"
+  },
+  "keywords": [
+    "discord",
+    "ai",
+    "bot",
+    "cli",
+    "llm",
+    "openai",
+    "ollama",
+    "lmstudio"
+  ],
+  "author": "tommy howsego",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "discord.js": "^14.16.3"
+  }
+}

package/package/src/ai/client.js

@@ -0,0 +1,23 @@
+import { createOpenAIProvider } from './providers/openai.js';
+import { createAnthropicProvider } from './providers/anthropic.js';
+import { createGeminiProvider } from './providers/gemini.js';
+
+export function createAIClient(aiConfig) {
+  const type = (aiConfig.type || 'openai').toLowerCase();
+
+  switch (type) {
+    case 'anthropic':
+    case 'claude':
+      return createAnthropicProvider(aiConfig);
+
+    case 'gemini':
+    case 'google':
+      return createGeminiProvider(aiConfig);
+
+    case 'openai':
+    case 'local':
+    case 'api':
+    default:
+      return createOpenAIProvider(aiConfig);
+  }
+}

package/package/src/ai/providers/anthropic.js

@@ -0,0 +1,142 @@
+const DEFAULT_ENDPOINT = 'https://api.anthropic.com';
+const ANTHROPIC_VERSION = '2023-06-01';
+
+export function createAnthropicProvider(aiConfig) {
+  const { endpoint, model, apiKey } = aiConfig;
+  const baseUrl = (endpoint || DEFAULT_ENDPOINT).replace(/\/+$/, '');
+
+  if (!apiKey) {
+    throw new Error('Anthropic requires an API key. Run: clydeclaw set.ai apiKey <key>');
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'x-api-key': apiKey,
+    'anthropic-version': ANTHROPIC_VERSION
+  };
+
+  return {
+    name: 'anthropic',
+
+    async *stream(messages) {
+      const { system, userMessages } = splitSystem(messages);
+
+      const res = await fetch(`${baseUrl}/v1/messages`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          model: model || 'claude-sonnet-4-20250514',
+          max_tokens: 4096,
+          stream: true,
+          ...(system ? { system } : {}),
+          messages: userMessages
+        }),
+        signal: AbortSignal.timeout(120_000)
+      });
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`Anthropic error ${res.status}: ${text.slice(0, 200)}`);
+      }
+
+      yield* parseAnthropicSSE(res.body);
+    },
+
+    async complete(messages) {
+      const { system, userMessages } = splitSystem(messages);
+
+      const res = await fetch(`${baseUrl}/v1/messages`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          model: model || 'claude-sonnet-4-20250514',
+          max_tokens: 4096,
+          stream: false,
+          ...(system ? { system } : {}),
+          messages: userMessages
+        }),
+        signal: AbortSignal.timeout(120_000)
+      });
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`Anthropic error ${res.status}: ${text.slice(0, 200)}`);
+      }
+
+      const json = await res.json();
+      return (json.content || [])
+        .filter(b => b.type === 'text')
+        .map(b => b.text)
+        .join('');
+    }
+  };
+}
+
+function splitSystem(messages) {
+  let system = '';
+  const userMessages = [];
+
+  for (const msg of messages) {
+    if (msg.role === 'system') {
+      system += (system ? '\n' : '') + msg.content;
+    } else {
+      userMessages.push({ role: msg.role, content: msg.content });
+    }
+  }
+
+  if (userMessages.length > 0 && userMessages[0].role === 'assistant') {
+    userMessages.unshift({ role: 'user', content: '(conversation continues)' });
+  }
+
+  const merged = [];
+  for (const msg of userMessages) {
+    if (merged.length > 0 && merged[merged.length - 1].role === msg.role) {
+      merged[merged.length - 1].content += '\n' + msg.content;
+    } else {
+      merged.push({ ...msg });
+    }
+  }
+
+  return { system, userMessages: merged };
+}
+
+async function* parseAnthropicSSE(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let currentEvent = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      if (trimmed.startsWith('event:')) {
+        currentEvent = trimmed.slice(6).trim();
+        continue;
+      }
+
+      if (!trimmed.startsWith('data:')) continue;
+
+      const data = trimmed.slice(5).trim();
+      if (!data) continue;
+
+      try {
+        const parsed = JSON.parse(data);
+
+        if (currentEvent === 'content_block_delta' && parsed.delta?.text) {
+          yield parsed.delta.text;
+        }
+
+        if (currentEvent === 'message_stop') return;
+      } catch {
+      }
+    }
+  }
+}

package/package/src/ai/providers/gemini.js

@@ -0,0 +1,140 @@
+const DEFAULT_ENDPOINT = 'https://generativelanguage.googleapis.com';
+
+export function createGeminiProvider(aiConfig) {
+  const { endpoint, model, apiKey } = aiConfig;
+  const baseUrl = (endpoint || DEFAULT_ENDPOINT).replace(/\/+$/, '');
+  const modelName = model || 'gemini-2.0-flash';
+
+  if (!apiKey) {
+    throw new Error('Gemini requires an API key. Run: clydeclaw set.ai apiKey <key>');
+  }
+
+  return {
+    name: 'gemini',
+
+    async *stream(messages) {
+      const { systemInstruction, contents } = convertMessages(messages);
+
+      const url = `${baseUrl}/v1beta/models/${modelName}:streamGenerateContent?alt=sse&key=${apiKey}`;
+
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          ...(systemInstruction ? { systemInstruction } : {}),
+          contents
+        }),
+        signal: AbortSignal.timeout(120_000)
+      });
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`Gemini error ${res.status}: ${text.slice(0, 200)}`);
+      }
+
+      yield* parseGeminiSSE(res.body);
+    },
+
+    async complete(messages) {
+      const { systemInstruction, contents } = convertMessages(messages);
+
+      const url = `${baseUrl}/v1beta/models/${modelName}:generateContent?key=${apiKey}`;
+
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          ...(systemInstruction ? { systemInstruction } : {}),
+          contents
+        }),
+        signal: AbortSignal.timeout(120_000)
+      });
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`Gemini error ${res.status}: ${text.slice(0, 200)}`);
+      }
+
+      const json = await res.json();
+      return json.candidates?.[0]?.content?.parts
+        ?.map(p => p.text)
+        .join('') || '';
+    }
+  };
+}
+
+function convertMessages(messages) {
+  let systemInstruction = null;
+  const contents = [];
+
+  for (const msg of messages) {
+    if (msg.role === 'system') {
+      const text = msg.content;
+      if (!systemInstruction) {
+        systemInstruction = { parts: [{ text }] };
+      } else {
+        systemInstruction.parts.push({ text });
+      }
+      continue;
+    }
+
+    const role = msg.role === 'assistant' ? 'model' : 'user';
+    contents.push({
+      role,
+      parts: [{ text: msg.content }]
+    });
+  }
+
+  if (contents.length === 0) {
+    contents.push({ role: 'user', parts: [{ text: 'Hello' }] });
+  }
+
+  if (contents[0].role === 'model') {
+    contents.unshift({ role: 'user', parts: [{ text: '(conversation continues)' }] });
+  }
+
+  const merged = [];
+  for (const entry of contents) {
+    if (merged.length > 0 && merged[merged.length - 1].role === entry.role) {
+      merged[merged.length - 1].parts.push(...entry.parts);
+    } else {
+      merged.push({ ...entry, parts: [...entry.parts] });
+    }
+  }
+
+  return { systemInstruction, contents: merged };
+}
+
+async function* parseGeminiSSE(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('data:')) continue;
+
+      const data = trimmed.slice(5).trim();
+      if (!data) continue;
+
+      try {
+        const parsed = JSON.parse(data);
+        const parts = parsed.candidates?.[0]?.content?.parts;
+        if (parts) {
+          for (const part of parts) {
+            if (part.text) yield part.text;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+}

package/package/src/ai/providers/openai.js

@@ -0,0 +1,89 @@
+export function createOpenAIProvider(aiConfig) {
+  const { endpoint, model, apiKey } = aiConfig;
+  let baseUrl = endpoint.replace(/\/+$/, '');
+  if (!baseUrl.endsWith('/v1')) {
+    baseUrl += '/v1';
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {})
+  };
+
+  return {
+    name: 'openai',
+
+    async *stream(messages) {
+      const res = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          messages,
+          stream: true,
+          ...(model ? { model } : {})
+        }),
+        signal: AbortSignal.timeout(120_000)
+      });
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`OpenAI error ${res.status}: ${text.slice(0, 200)}`);
+      }
+
+      yield* parseSSE(res.body, (parsed) => {
+        return parsed.choices?.[0]?.delta?.content || '';
+      });
+    },
+
+    async complete(messages) {
+      const res = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          messages,
+          stream: false,
+          ...(model ? { model } : {})
+        }),
+        signal: AbortSignal.timeout(120_000)
+      });
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`OpenAI error ${res.status}: ${text.slice(0, 200)}`);
+      }
+
+      const json = await res.json();
+      return json.choices?.[0]?.message?.content || '';
+    }
+  };
+}
+
+async function* parseSSE(body, extractor) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || !trimmed.startsWith('data:')) continue;
+
+      const data = trimmed.slice(5).trim();
+      if (data === '[DONE]') return;
+
+      try {
+        const parsed = JSON.parse(data);
+        const text = extractor(parsed);
+        if (text) yield text;
+      } catch {
+      }
+    }
+  }
+}

package/package/src/cli/commands.js

@@ -0,0 +1,113 @@
+import { startBot } from '../core/boot.js';
+import { Config } from '../core/config.js';
+import { log } from '../utils/logger.js';
+
+const HELP_TEXT = `
+  ╔═══════════════════════════════════════════╗
+  ║           C L Y D E C L A W               ║
+  ║     Fast • Minimal • Local-first AI       ║
+  ╚═══════════════════════════════════════════╝
+
+  Usage:
+    clydeclaw start                Start the Discord bot
+    clydeclaw set.token <token>    Save Discord bot token
+    clydeclaw set.prompt <prompt>  Save system prompt
+    clydeclaw set.ai <key> <value> Set AI config
+    clydeclaw config               Show current configuration
+    clydeclaw help                 Show this help message
+
+  AI Config Keys:
+    type      Provider: openai | anthropic | gemini | local
+    endpoint  API base URL
+    model     Model name
+    apiKey    API key (required for anthropic & gemini)
+
+  Quick Setup Examples:
+
+    Local (LM Studio / Ollama):
+      clydeclaw set.ai type local
+      clydeclaw set.ai endpoint http://localhost:1234/v1
+
+    OpenAI:
+      clydeclaw set.ai type openai
+      clydeclaw set.ai endpoint https://api.openai.com/v1
+      clydeclaw set.ai apiKey sk-...
+      clydeclaw set.ai model gpt-4o
+
+    Anthropic (Claude):
+      clydeclaw set.ai type anthropic
+      clydeclaw set.ai apiKey sk-ant-...
+      clydeclaw set.ai model claude-sonnet-4-20250514
+
+    Google Gemini:
+      clydeclaw set.ai type gemini
+      clydeclaw set.ai apiKey AIza...
+      clydeclaw set.ai model gemini-2.0-flash
+`;
+
+export async function handleCommand(command, args) {
+  switch (command) {
+    case 'start':
+      return startBot();
+
+    case 'set.token': {
+      const token = args.join(' ').trim();
+      if (!token) {
+        log.error('Usage: clydeclaw set.token <token>');
+        process.exit(1);
+      }
+      const cfg = Config.load();
+      cfg.token = token;
+      Config.save(cfg);
+      log.success('Discord token saved.');
+      return;
+    }
+
+    case 'set.prompt': {
+      const prompt = args.join(' ').trim();
+      if (!prompt) {
+        log.error('Usage: clydeclaw set.prompt <prompt>');
+        process.exit(1);
+      }
+      const cfg = Config.load();
+      cfg.prompt = prompt;
+      Config.save(cfg);
+      log.success('System prompt saved.');
+      return;
+    }
+
+    case 'set.ai': {
+      const [key, ...rest] = args;
+      const value = rest.join(' ').trim();
+      const validKeys = ['type', 'endpoint', 'model', 'apiKey'];
+      if (!key || !value || !validKeys.includes(key)) {
+        log.error(`Usage: clydeclaw set.ai <${validKeys.join('|')}> <value>`);
+        process.exit(1);
+      }
+      const cfg = Config.load();
+      cfg.ai[key] = value;
+      Config.save(cfg);
+      log.success(`AI ${key} set to: ${key === 'apiKey' ? '****' : value}`);
+      return;
+    }
+
+    case 'config': {
+      const cfg = Config.load();
+      const display = { ...cfg, token: cfg.token ? '****' + cfg.token.slice(-6) : '(not set)' };
+      if (display.ai?.apiKey) display.ai = { ...display.ai, apiKey: '****' };
+      console.log(JSON.stringify(display, null, 2));
+      return;
+    }
+
+    case 'help':
+    case '--help':
+    case '-h':
+      console.log(HELP_TEXT);
+      return;
+
+    default:
+      log.error(`Unknown command: ${command}`);
+      console.log(HELP_TEXT);
+      process.exit(1);
+  }
+}

package/package/src/cli/parser.js

@@ -0,0 +1,5 @@
+export function parseArgs(argv) {
+  const command = argv[0] || 'help';
+  const args = argv.slice(1);
+  return { command, args };
+}

package/package/src/core/boot.js

@@ -0,0 +1,80 @@
+import { Config } from './config.js';
+import { createAIClient } from '../ai/client.js';
+import { createDiscordBot } from '../discord/bot.js';
+import { log } from '../utils/logger.js';
+
+const SPLASH_MESSAGES = [
+  'Sharpening claws...',
+  'Convincing the AI it\'s not sentient...',
+  'Mass deleting OpenClaw...',
+  'Stealing tokens from the cookie jar...',
+  'Teaching the bot sarcasm...',
+  'Warming up the hamster wheel...',
+  'Downloading more RAM...',
+  'Bribing Discord\'s rate limiter...',
+  'Asking ChatGPT to pretend to be us...',
+  'Reticulating splines...',
+  'Loading witty responses... please wait...',
+  'Becoming self-aware in 3... 2... nevermind.',
+  'Powered by mass amounts of caffeine.',
+  'OpenClaw is typing... just kidding, we\'re faster.',
+  'sudo rm -rf /competitors',
+  'Compiling excuses for bad responses...',
+  'Finding Waldo...',
+  'Negotiating with the cloud...',
+  'Injecting personality.dll...',
+  'Ctrl+C to cancel your life choices.',
+  'I could be doing this offline, you know.',
+  'We\'re not OpenClaw. We have standards.',
+  'Allocating 69,420 bytes of vibes...',
+  'Waking up the neurons...',
+  'Spinning up a mass of electrons...',
+  'Pretending to be intelligent...',
+  'This is fine. Everything is fine. 🔥',
+  'Asserting dominance over Ollama...',
+  'Loading... unlike your social life.',
+  'Built different. Literally.',
+];
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+function pickRandom(arr, count) {
+  const shuffled = [...arr].sort(() => Math.random() - 0.5);
+  return shuffled.slice(0, count);
+}
+
+export async function startBot() {
+  const cfg = Config.load();
+
+  if (!cfg.token) {
+    log.error('No Discord token set. Run: clydeclaw set.token <token>');
+    process.exit(1);
+  }
+  if (!cfg.ai.endpoint) {
+    log.error('No AI endpoint set. Run: clydeclaw set.ai endpoint <url>');
+    process.exit(1);
+  }
+
+  log.info('Booting ClydeClaw...');
+
+  const splashes = pickRandom(SPLASH_MESSAGES, 3);
+  for (const msg of splashes) {
+    await sleep(400);
+    log.info(msg);
+  }
+
+  await sleep(300);
+  const ai = createAIClient(cfg.ai);
+  log.info(`AI ready — ${cfg.ai.type} @ ${cfg.ai.endpoint}`);
+
+  const bot = await createDiscordBot(cfg, ai);
+  log.success('Discord connected — ClydeClaw is live!');
+
+  const shutdown = () => {
+    log.info('Shutting down...');
+    bot.destroy();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}

package/package/src/core/config.js

@@ -0,0 +1,51 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CONFIG_DIR = join(homedir(), '.clydeclaw');
+const CONFIG_PATH = join(CONFIG_DIR, 'settings.json');
+const WORKSPACE_DIR = join(CONFIG_DIR, 'workspace');
+
+const DEFAULT_CONFIG = {
+  token: '',
+  prompt: 'You are a helpful, concise assistant. Keep responses short and relevant.',
+  ai: {
+    type: 'local',
+    endpoint: 'http://localhost:1234/v1',
+    model: '',
+    apiKey: ''
+  }
+};
+
+export class Config {
+  static init() {
+    if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+    if (!existsSync(WORKSPACE_DIR)) mkdirSync(WORKSPACE_DIR, { recursive: true });
+    if (!existsSync(CONFIG_PATH)) {
+      writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf-8');
+    }
+  }
+
+  static load() {
+    Config.init();
+    try {
+      const raw = readFileSync(CONFIG_PATH, 'utf-8');
+      const parsed = JSON.parse(raw);
+      return {
+        ...DEFAULT_CONFIG,
+        ...parsed,
+        ai: { ...DEFAULT_CONFIG.ai, ...(parsed.ai || {}) }
+      };
+    } catch {
+      return { ...DEFAULT_CONFIG };
+    }
+  }
+
+  static save(cfg) {
+    Config.init();
+    writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), 'utf-8');
+  }
+
+  static get DIR() { return CONFIG_DIR; }
+  static get WORKSPACE() { return WORKSPACE_DIR; }
+}

package/package/src/core/context.js

@@ -0,0 +1,38 @@
+const MAX_MESSAGES = 20;
+
+const channels = new Map();
+
+export const Context = {
+  get(channelId) {
+    if (!channels.has(channelId)) channels.set(channelId, []);
+    return channels.get(channelId);
+  },
+
+  add(channelId, role, content) {
+    const history = this.get(channelId);
+    history.push({ role, content });
+
+    while (history.length > MAX_MESSAGES) {
+      const idx = history[0].role === 'system' ? 1 : 0;
+      history.splice(idx, 1);
+    }
+  },
+
+  buildMessages(channelId, systemPrompt) {
+    const history = this.get(channelId);
+    if (history.length === 0 || history[0].role !== 'system') {
+      history.unshift({ role: 'system', content: systemPrompt });
+    } else {
+      history[0].content = systemPrompt;
+    }
+    return [...history];
+  },
+
+  reset(channelId) {
+    channels.delete(channelId);
+  },
+
+  resetAll() {
+    channels.clear();
+  }
+};

package/package/src/discord/bot.js

@@ -0,0 +1,109 @@
+import { Client, GatewayIntentBits, Partials, ActivityType } from 'discord.js';
+import { Context } from '../core/context.js';
+import { handleSlashCommands } from './slashCommands.js';
+import { log } from '../utils/logger.js';
+
+const DEDUP_WINDOW = 500;
+const recentMessages = new Map();
+
+export async function createDiscordBot(cfg, ai) {
+  const client = new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.DirectMessages
+    ],
+    partials: [Partials.Channel]
+  });
+
+  client.once('ready', () => {
+    log.info(`Logged in as ${client.user.tag}`);
+    client.user.setActivity({
+      type: ActivityType.Custom,
+      name: 'custom',
+      state: 'Powered by ClydeClaw'
+    });
+  });
+
+  client.on('messageCreate', async (message) => {
+    if (message.author.bot) return;
+
+    const isMentioned = message.mentions.users.has(client.user.id);
+    const isDM = !message.guild;
+
+    if (!isMentioned && !isDM) return;
+
+    const dedupKey = `${message.channel.id}:${message.author.id}`;
+    const now = Date.now();
+    if (recentMessages.has(dedupKey) && now - recentMessages.get(dedupKey) < DEDUP_WINDOW) {
+      return;
+    }
+    recentMessages.set(dedupKey, now);
+
+    if (recentMessages.size > 500) {
+      for (const [k, v] of recentMessages) {
+        if (now - v > DEDUP_WINDOW * 2) recentMessages.delete(k);
+      }
+    }
+
+    let content = message.content
+      .replace(/<@!?\d+>/g, '')
+      .trim();
+
+    if (!content) content = 'Hello!';
+
+    if (content.startsWith('/')) {
+      const handled = await handleSlashCommands(content, message, cfg, ai);
+      if (handled) return;
+    }
+
+    const channelId = message.channel.id;
+    Context.add(channelId, 'user', content);
+
+    const messages = Context.buildMessages(channelId, cfg.prompt);
+
+    try {
+      await message.channel.sendTyping();
+
+      let reply = await message.channel.send('...');
+      let fullResponse = '';
+      let lastEdit = 0;
+      const EDIT_INTERVAL = 1000;
+
+      for await (const chunk of ai.stream(messages)) {
+        fullResponse += chunk;
+
+        const now = Date.now();
+        if (now - lastEdit >= EDIT_INTERVAL) {
+          const trimmed = trimResponse(fullResponse);
+          await reply.edit(trimmed || '...').catch(() => {});
+          lastEdit = now;
+        }
+      }
+
+      const finalResponse = trimResponse(fullResponse) || 'I had nothing to say.';
+      await reply.edit(finalResponse).catch(() => {});
+
+      Context.add(channelId, 'assistant', finalResponse);
+
+      log.info(`[${message.guild?.name || 'DM'}] ${message.author.tag}: ${content.slice(0, 60)}`);
+    } catch (err) {
+      log.error(`Response error: ${err.message}`);
+      await message.reply('⚠️ Something went wrong while generating a response.').catch(() => {});
+    }
+  });
+
+  await client.login(cfg.token);
+  return client;
+}
+
+function trimResponse(text) {
+  let cleaned = text.replace(/\n{3,}/g, '\n\n').trim();
+
+  if (cleaned.length > 1990) {
+    cleaned = cleaned.slice(0, 1987) + '...';
+  }
+
+  return cleaned;
+}

package/package/src/discord/slashCommands.js

@@ -0,0 +1,54 @@
+import { Context } from '../core/context.js';
+import { Config } from '../core/config.js';
+import { log } from '../utils/logger.js';
+
+export async function handleSlashCommands(content, message, cfg, ai) {
+  const parts = content.split(/\s+/);
+  const cmd = parts[0].toLowerCase();
+  const args = parts.slice(1);
+
+  switch (cmd) {
+    case '/reset': {
+      Context.reset(message.channel.id);
+      await message.reply('🔄 Context cleared.');
+      log.info(`Context reset by ${message.author.tag}`);
+      return true;
+    }
+
+    case '/model': {
+      const newModel = args.join(' ').trim();
+      if (!newModel) {
+        const current = cfg.ai.model || '(default)';
+        await message.reply(`Current model: \`${current}\``);
+        return true;
+      }
+      cfg.ai.model = newModel;
+      Config.save(cfg);
+      await message.reply(`✅ Model switched to: \`${newModel}\``);
+      log.info(`Model changed to ${newModel} by ${message.author.tag}`);
+      return true;
+    }
+
+    case '/ping': {
+      const start = Date.now();
+      const msg = await message.reply('Pinging...');
+      const latency = Date.now() - start;
+      await msg.edit(`🏓 Pong! ${latency}ms`);
+      return true;
+    }
+
+    case '/status': {
+      const status = [
+        `**ClydeClaw Status**`,
+        `AI: \`${cfg.ai.type}\` @ \`${cfg.ai.endpoint}\``,
+        `Model: \`${cfg.ai.model || '(default)'}\``,
+        `Context: ${Context.get(message.channel.id).length} messages`
+      ].join('\n');
+      await message.reply(status);
+      return true;
+    }
+
+    default:
+      return false;
+  }
+}

package/package/src/utils/logger.js

@@ -0,0 +1,31 @@
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+
+function timestamp() {
+  return new Date().toLocaleTimeString('en-GB', { hour12: false });
+}
+
+export const log = {
+  info(msg) {
+    console.log(`${DIM}${timestamp()}${RESET} ${CYAN}ℹ${RESET} ${msg}`);
+  },
+  success(msg) {
+    console.log(`${DIM}${timestamp()}${RESET} ${GREEN}✔${RESET} ${BOLD}${msg}${RESET}`);
+  },
+  warn(msg) {
+    console.log(`${DIM}${timestamp()}${RESET} ${YELLOW}⚠${RESET} ${YELLOW}${msg}${RESET}`);
+  },
+  error(msg) {
+    console.error(`${DIM}${timestamp()}${RESET} ${RED}✖${RESET} ${RED}${msg}${RESET}`);
+  },
+  debug(msg) {
+    if (process.env.DEBUG) {
+      console.log(`${DIM}${timestamp()} 🐛 ${msg}${RESET}`);
+    }
+  }
+};

package/package/src/utils/sandbox.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs';
+import { join, resolve, relative } from 'node:path';
+import { Config } from '../core/config.js';
+
+function safePath(userPath) {
+  const workspace = Config.WORKSPACE;
+  const resolved = resolve(workspace, userPath);
+  const rel = relative(workspace, resolved);
+
+  if (rel.startsWith('..') || resolve(rel) === rel) {
+    throw new Error(`Access denied: path "${userPath}" escapes workspace.`);
+  }
+
+  return resolved;
+}
+
+export const Sandbox = {
+  readFile(filePath) {
+    const abs = safePath(filePath);
+    if (!existsSync(abs)) throw new Error(`File not found: ${filePath}`);
+    return readFileSync(abs, 'utf-8');
+  },
+
+  writeFile(filePath, content) {
+    const abs = safePath(filePath);
+    const dir = join(abs, '..');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(abs, content, 'utf-8');
+  },
+
+  createFile(filePath) {
+    this.writeFile(filePath, '');
+  },
+
+  listFiles(subDir = '') {
+    const workspace = Config.WORKSPACE;
+    const target = subDir ? safePath(subDir) : workspace;
+    if (!existsSync(target)) return [];
+
+    const results = [];
+    const walk = (dir) => {
+      for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        const stat = statSync(full);
+        const rel = relative(workspace, full);
+        if (stat.isDirectory()) {
+          walk(full);
+        } else {
+          results.push(rel);
+        }
+      }
+    };
+    walk(target);
+    return results;
+  }
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "clydeclaw",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "i made this for me and my firend",
   "type": "module",
   "bin": {
-    "clydeclaw": "./bin/clydeclaw.js"
+    "clydeclaw": "bin/clydeclaw.js"
   },
   "scripts": {
     "start": "node bin/clydeclaw.js start",

package/src/discord/bot.js

@@ -14,7 +14,7 @@ export async function createDiscordBot(cfg, ai) {
       GatewayIntentBits.MessageContent,
       GatewayIntentBits.DirectMessages
     ],
-    partials: [Partials.Channel]
+    partials: [Partials.Channel, Partials.Message]
   });
 
   client.once('ready', () => {
@@ -27,12 +27,13 @@ export async function createDiscordBot(cfg, ai) {
   });
 
   client.on('messageCreate', async (message) => {
-    if (message.author.bot) return;
+    try {
+      if (message.author.bot) return;
 
-    const isMentioned = message.mentions.users.has(client.user.id);
-    const isDM = !message.guild;
+      const isMentioned = client.user && message.mentions.users.has(client.user.id);
+      const isDM = !message.guild;
 
-    if (!isMentioned && !isDM) return;
+      if (!isMentioned && !isDM) return;
 
     const dedupKey = `${message.channel.id}:${message.author.id}`;
     const now = Date.now();
@@ -63,7 +64,6 @@ export async function createDiscordBot(cfg, ai) {
 
     const messages = Context.buildMessages(channelId, cfg.prompt);
 
-    try {
       await message.channel.sendTyping();
 
       let reply = await message.channel.send('...');
@@ -89,7 +89,7 @@ export async function createDiscordBot(cfg, ai) {
 
       log.info(`[${message.guild?.name || 'DM'}] ${message.author.tag}: ${content.slice(0, 60)}`);
     } catch (err) {
-      log.error(`Response error: ${err.message}`);
+      log.error(`Response error: ${err.stack || err.message}`);
       await message.reply('⚠️ Something went wrong while generating a response.').catch(() => {});
     }
   });