@stevederico/dotbot 0.24.0 → 0.26.0

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+0.26
+
+  Update REPL prompt style
+  Add visible thinking output
+  Add /help, /show, /bye commands
+  Add multi-line input mode
+
+0.25
+
+  Add delete subcommands for memory, jobs, tasks, sessions
+  Add --json flag for machine-readable output
+  Add doctor command for environment check
+  Add ~/.dotbotrc config file support
+  Add --openai flag for OpenAI-compatible API
+  Add pipe support (stdin input)
+  Add --session flag to resume conversations
+
 0.24
 
   Add --system flag for custom prompts

package/README.md

@@ -13,7 +13,7 @@
       <img src="https://img.shields.io/github/stars/stevederico/dotbot?style=social" alt="GitHub stars">
     </a>
     <a href="https://github.com/stevederico/dotbot">
-      <img src="https://img.shields.io/badge/version-0.24-green" alt="version">
+      <img src="https://img.shields.io/badge/version-0.25-green" alt="version">
     </a>
     <img src="https://img.shields.io/badge/LOC-11k-orange" alt="Lines of Code">
   </p>
@@ -154,28 +154,38 @@ for await (const event of agent.chat({
 ## CLI Reference
 
 ```
-dotbot v0.24 — AI agent CLI
+dotbot v0.25 — AI agent CLI
 
 Usage:
   dotbot "message"            One-shot query
   dotbot                      Interactive chat
   dotbot serve [--port N]     Start HTTP server (default: 3000)
+  dotbot serve --openai       Start OpenAI-compatible API server
+  echo "msg" | dotbot         Pipe input from stdin
 
 Commands:
+  doctor                      Check environment and configuration
   tools                       List all available tools
   stats                       Show database statistics
   memory [list|search <q>]    Manage saved memories
+  memory delete <key>         Delete a memory by key
   jobs                        List scheduled jobs
+  jobs delete <id>            Delete a scheduled job
   tasks                       List active tasks
+  tasks delete <id>           Delete a task
   sessions                    List chat sessions
+  sessions delete <id>        Delete a session
   events [--summary]          View audit log
 
 Options:
   --provider, -p   AI provider: xai, anthropic, openai, ollama (default: xai)
   --model, -m      Model name (default: grok-4-1-fast-reasoning)
   --system, -s     Custom system prompt (prepended to default)
+  --session        Resume a specific session by ID
   --db             SQLite database path (default: ./dotbot.db)
   --port           Server port for 'serve' command
+  --openai         Enable OpenAI-compatible API endpoints
+  --json           Output as JSON (for inspection commands)
   --verbose        Show initialization logs
   --help, -h       Show help
   --version, -v    Show version
@@ -185,6 +195,9 @@ Environment Variables:
   ANTHROPIC_API_KEY    API key for Anthropic
   OPENAI_API_KEY       API key for OpenAI
   OLLAMA_BASE_URL      Base URL for Ollama (default: http://localhost:11434)
+
+Config File:
+  ~/.dotbotrc          JSON config for defaults (provider, model, db)
 ```
 
 <br />

package/bin/dotbot.js

@@ -22,11 +22,13 @@ process.emit = function (event, error) {
  */
 
 import { parseArgs } from 'node:util';
-import { readFileSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
 import * as readline from 'node:readline';
 import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
 
 // Read version from package.json
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -59,6 +61,7 @@ async function loadModules() {
 }
 const DEFAULT_PORT = 3000;
 const DEFAULT_DB = './dotbot.db';
+const CONFIG_PATH = join(homedir(), '.dotbotrc');
 
 // Spinner for tool execution feedback
 let spinnerInterval = null;
@@ -93,22 +96,32 @@ Usage:
   dotbot "message"            One-shot query
   dotbot                      Interactive chat
   dotbot serve [--port N]     Start HTTP server (default: ${DEFAULT_PORT})
+  dotbot serve --openai       Start OpenAI-compatible API server
+  echo "msg" | dotbot         Pipe input from stdin
 
 Commands:
+  doctor                      Check environment and configuration
   tools                       List all available tools
   stats                       Show database statistics
   memory [list|search <q>]    Manage saved memories
+  memory delete <key>         Delete a memory by key
   jobs                        List scheduled jobs
+  jobs delete <id>            Delete a scheduled job
   tasks                       List active tasks
+  tasks delete <id>           Delete a task
   sessions                    List chat sessions
+  sessions delete <id>        Delete a session
   events [--summary]          View audit log
 
 Options:
   --provider, -p   AI provider: xai, anthropic, openai, ollama (default: xai)
   --model, -m      Model name (default: grok-4-1-fast-reasoning)
   --system, -s     Custom system prompt (prepended to default)
+  --session        Resume a specific session by ID
   --db             SQLite database path (default: ${DEFAULT_DB})
   --port           Server port for 'serve' command (default: ${DEFAULT_PORT})
+  --openai         Enable OpenAI-compatible API endpoints (/v1/chat/completions, /v1/models)
+  --json           Output as JSON (for inspection commands)
   --verbose        Show initialization logs
   --help, -h       Show this help
   --version, -v    Show version
@@ -119,20 +132,51 @@ Environment Variables:
   OPENAI_API_KEY       API key for OpenAI
   OLLAMA_BASE_URL      Base URL for Ollama (default: http://localhost:11434)
 
+Config File:
+  ~/.dotbotrc                 JSON config for defaults (provider, model, db)
+
 Examples:
   dotbot "What's the weather in SF?"
   dotbot
   dotbot serve --port 8080
+  dotbot doctor
   dotbot tools
   dotbot memory search "preferences"
+  dotbot memory delete user_pref
+  dotbot stats --json
   dotbot --system "You are a pirate" "Hello"
+  dotbot --session abc-123 "follow up question"
+  echo "What is 2+2?" | dotbot
+  cat question.txt | dotbot
 `);
 }
 
 /**
- * Parse CLI arguments.
+ * Load config from ~/.dotbotrc if it exists.
+ *
+ * @returns {Object} Config object or empty object if not found
+ */
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(content);
+  } catch (err) {
+    console.error(`Warning: Invalid config file at ${CONFIG_PATH}: ${err.message}`);
+    return {};
+  }
+}
+
+/**
+ * Parse CLI arguments with config file fallback.
+ *
+ * @returns {Object} Merged CLI args and config values
  */
 function parseCliArgs() {
+  const config = loadConfig();
+
   try {
     const { values, positionals } = parseArgs({
       allowPositionals: true,
@@ -140,15 +184,29 @@ function parseCliArgs() {
         help: { type: 'boolean', short: 'h', default: false },
         version: { type: 'boolean', short: 'v', default: false },
         verbose: { type: 'boolean', default: false },
-        provider: { type: 'string', short: 'p', default: 'xai' },
-        model: { type: 'string', short: 'm', default: 'grok-4-1-fast-reasoning' },
-        system: { type: 'string', short: 's', default: '' },
+        provider: { type: 'string', short: 'p' },
+        model: { type: 'string', short: 'm' },
+        system: { type: 'string', short: 's' },
         summary: { type: 'boolean', default: false },
-        db: { type: 'string', default: DEFAULT_DB },
-        port: { type: 'string', default: String(DEFAULT_PORT) },
+        json: { type: 'boolean', default: false },
+        db: { type: 'string' },
+        port: { type: 'string' },
+        openai: { type: 'boolean', default: false },
+        session: { type: 'string', default: '' },
       },
     });
-    return { ...values, positionals };
+
+    // Merge: CLI args > config file > hardcoded defaults
+    return {
+      ...values,
+      provider: values.provider ?? config.provider ?? 'xai',
+      model: values.model ?? config.model ?? 'grok-4-1-fast-reasoning',
+      system: values.system ?? config.system ?? '',
+      db: values.db ?? config.db ?? DEFAULT_DB,
+      port: values.port ?? config.port ?? String(DEFAULT_PORT),
+      session: values.session ?? '',
+      positionals,
+    };
   } catch (err) {
     console.error(`Error: ${err.message}`);
     process.exit(1);
@@ -251,7 +309,20 @@ async function runChat(message, options) {
   const storesObj = await initStores(options.db, options.verbose, options.system);
   const provider = await getProviderConfig(options.provider);
 
-  const session = await storesObj.sessionStore.createSession('cli-user', options.model, options.provider);
+  let session;
+  let messages;
+
+  if (options.session) {
+    session = await storesObj.sessionStore.getSession(options.session, 'cli-user');
+    if (!session) {
+      console.error(`Error: Session not found: ${options.session}`);
+      process.exit(1);
+    }
+    messages = [...(session.messages || []), { role: 'user', content: message }];
+  } else {
+    session = await storesObj.sessionStore.createSession('cli-user', options.model, options.provider);
+    messages = [{ role: 'user', content: message }];
+  }
 
   const context = {
     userID: 'cli-user',
@@ -260,10 +331,8 @@ async function runChat(message, options) {
     ...storesObj,
   };
 
-  const messages = [{ role: 'user', content: message }];
-
-  process.stdout.write('\n[thinking] ');
-  startSpinner();
+  let isThinking = false;
+  let thinkingDone = false;
 
   for await (const event of agentLoop({
     model: options.model,
@@ -274,14 +343,28 @@ async function runChat(message, options) {
   })) {
     switch (event.type) {
       case 'thinking':
-        // Already showing spinner, ignore thinking events
+        if (!isThinking) {
+          process.stdout.write('Thinking...\n');
+          isThinking = true;
+        }
+        if (event.text) {
+          process.stdout.write(event.text);
+        }
         break;
       case 'text_delta':
-        stopSpinner('');  // Stop thinking spinner silently
+        if (isThinking && !thinkingDone) {
+          stopSpinner('');
+          process.stdout.write('\n...done thinking.\n\n');
+          thinkingDone = true;
+        }
         process.stdout.write(event.text);
         break;
       case 'tool_start':
-        stopSpinner('');  // Stop thinking spinner silently
+        if (isThinking && !thinkingDone) {
+          stopSpinner('');
+          process.stdout.write('\n...done thinking.\n\n');
+          thinkingDone = true;
+        }
         process.stdout.write(`[${event.name}] `);
         startSpinner();
         break;
@@ -310,8 +393,20 @@ async function runRepl(options) {
   const storesObj = await initStores(options.db, options.verbose, options.system);
   const provider = await getProviderConfig(options.provider);
 
-  const session = await storesObj.sessionStore.createSession('cli-user', options.model, options.provider);
-  const messages = [];
+  let session;
+  let messages;
+
+  if (options.session) {
+    session = await storesObj.sessionStore.getSession(options.session, 'cli-user');
+    if (!session) {
+      console.error(`Error: Session not found: ${options.session}`);
+      process.exit(1);
+    }
+    messages = [...(session.messages || [])];
+  } else {
+    session = await storesObj.sessionStore.createSession('cli-user', options.model, options.provider);
+    messages = [];
+  }
 
   const context = {
     userID: 'cli-user',
@@ -326,18 +421,58 @@ async function runRepl(options) {
   });
 
   console.log(`\ndotbot v${VERSION} — ${options.provider}/${options.model}`);
-  console.log('Type /quit to exit, /clear to reset conversation\n');
+  if (options.session) {
+    console.log(`Resuming session: ${session.id}`);
+  }
+  console.log('Type /? for help\n');
+
+  const showHelp = () => {
+    console.log('Available Commands:');
+    console.log('  /show            Show model information');
+    console.log('  /clear           Clear session context');
+    console.log('  /bye             Exit');
+    console.log('  /?, /help        Help for a command');
+    console.log('');
+    console.log('Use """ to begin a multi-line message.\n');
+  };
+
+  const showModel = () => {
+    console.log(`  Model:    ${options.model}`);
+    console.log(`  Provider: ${options.provider}`);
+    console.log(`  Session:  ${session.id}\n`);
+  };
 
-  const prompt = () => {
-    rl.question('> ', async (input) => {
+  const promptUser = () => {
+    rl.question('>>> ', async (input) => {
       const trimmed = input.trim();
 
       if (!trimmed) {
-        prompt();
+        promptUser();
         return;
       }
 
-      if (trimmed === '/quit' || trimmed === '/exit') {
+      // Multi-line input mode
+      if (trimmed === '"""') {
+        let multiLine = '';
+        const collectLines = () => {
+          rl.question('... ', (line) => {
+            if (line.trim() === '"""') {
+              if (multiLine.trim()) {
+                handleMessage(multiLine.trim());
+              } else {
+                promptUser();
+              }
+            } else {
+              multiLine += (multiLine ? '\n' : '') + line;
+              collectLines();
+            }
+          });
+        };
+        collectLines();
+        return;
+      }
+
+      if (trimmed === '/bye' || trimmed === '/quit' || trimmed === '/exit') {
         console.log('Goodbye!');
         rl.close();
         process.exit(0);
@@ -346,64 +481,94 @@ async function runRepl(options) {
       if (trimmed === '/clear') {
         messages.length = 0;
         console.log('Conversation cleared.\n');
-        prompt();
+        promptUser();
+        return;
+      }
+
+      if (trimmed === '/?' || trimmed === '/help') {
+        showHelp();
+        promptUser();
         return;
       }
 
-      messages.push({ role: 'user', content: trimmed });
+      if (trimmed === '/show') {
+        showModel();
+        promptUser();
+        return;
+      }
 
-      process.stdout.write('\n[thinking] ');
-      startSpinner();
-      let assistantContent = '';
+      await handleMessage(trimmed);
+    });
+  };
 
-      try {
-        for await (const event of agentLoop({
-          model: options.model,
-          messages: [...messages],
-          tools: coreTools,
-          provider,
-          context,
-        })) {
-          switch (event.type) {
-            case 'thinking':
-              // Already showing spinner, ignore thinking events
-              break;
-            case 'text_delta':
-              stopSpinner('');  // Stop thinking spinner silently
+  const handleMessage = async (text) => {
+    messages.push({ role: 'user', content: text });
+
+    let isThinking = false;
+    let thinkingDone = false;
+    let assistantContent = '';
+
+    try {
+      for await (const event of agentLoop({
+        model: options.model,
+        messages: [...messages],
+        tools: coreTools,
+        provider,
+        context,
+      })) {
+        switch (event.type) {
+          case 'thinking':
+            if (!isThinking) {
+              process.stdout.write('Thinking...\n');
+              isThinking = true;
+            }
+            if (event.text) {
               process.stdout.write(event.text);
-              assistantContent += event.text;
-              break;
-            case 'tool_start':
-              stopSpinner('');  // Stop thinking spinner silently
-              process.stdout.write(`[${event.name}] `);
-              startSpinner();
-              break;
-            case 'tool_result':
-              stopSpinner('done');
-              break;
-            case 'tool_error':
-              stopSpinner('error');
-              break;
-            case 'error':
-              stopSpinner();
-              console.error(`\nError: ${event.error}`);
-              break;
-          }
+            }
+            break;
+          case 'text_delta':
+            if (isThinking && !thinkingDone) {
+              stopSpinner('');
+              process.stdout.write('\n...done thinking.\n\n');
+              thinkingDone = true;
+            }
+            process.stdout.write(event.text);
+            assistantContent += event.text;
+            break;
+          case 'tool_start':
+            if (isThinking && !thinkingDone) {
+              stopSpinner('');
+              process.stdout.write('\n...done thinking.\n\n');
+              thinkingDone = true;
+            }
+            process.stdout.write(`[${event.name}] `);
+            startSpinner();
+            break;
+          case 'tool_result':
+            stopSpinner('done');
+            break;
+          case 'tool_error':
+            stopSpinner('error');
+            break;
+          case 'error':
+            stopSpinner();
+            console.error(`\nError: ${event.error}`);
+            break;
         }
+      }
 
-        if (assistantContent) {
-          messages.push({ role: 'assistant', content: assistantContent });
-        }
-      } catch (err) {
-        console.error(`\nError: ${err.message}`);
+      if (assistantContent) {
+        messages.push({ role: 'assistant', content: assistantContent });
       }
+    } catch (err) {
+      console.error(`\nError: ${err.message}`);
+    }
 
-      process.stdout.write('\n\n');
-      prompt();
-    });
+    process.stdout.write('\n\n');
+    promptUser();
   };
 
-  prompt();
+  promptUser();
 }
 
 /**
@@ -436,6 +601,140 @@ async function runServer(options) {
       return;
     }
 
+    // OpenAI-compatible endpoints (when --openai flag is set)
+    if (options.openai) {
+      // GET /v1/models - list available models
+      if (req.method === 'GET' && url.pathname === '/v1/models') {
+        const models = [
+          { id: 'grok-3', object: 'model', owned_by: 'xai' },
+          { id: 'grok-4-1-fast-reasoning', object: 'model', owned_by: 'xai' },
+          { id: 'claude-sonnet-4-5', object: 'model', owned_by: 'anthropic' },
+          { id: 'claude-opus-4', object: 'model', owned_by: 'anthropic' },
+          { id: 'gpt-4o', object: 'model', owned_by: 'openai' },
+        ];
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ object: 'list', data: models }));
+        return;
+      }
+
+      // POST /v1/chat/completions - OpenAI-compatible chat endpoint
+      if (req.method === 'POST' && url.pathname === '/v1/chat/completions') {
+        let body = '';
+        for await (const chunk of req) body += chunk;
+
+        try {
+          const { model = 'grok-4-1-fast-reasoning', messages: reqMessages, stream = true } = JSON.parse(body);
+
+          if (!reqMessages || !Array.isArray(reqMessages)) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: { message: 'messages array required', type: 'invalid_request_error' } }));
+            return;
+          }
+
+          // Determine provider from model name
+          let providerId = 'xai';
+          if (model.startsWith('claude')) providerId = 'anthropic';
+          else if (model.startsWith('gpt')) providerId = 'openai';
+          else if (model.startsWith('llama') || model.startsWith('mistral')) providerId = 'ollama';
+
+          const provider = await getProviderConfig(providerId);
+          const session = await storesObj.sessionStore.createSession('api-user', model, providerId);
+
+          const context = {
+            userID: 'api-user',
+            sessionId: session.id,
+            providers: { [providerId]: { apiKey: process.env[AI_PROVIDERS[providerId]?.envKey] } },
+            ...storesObj,
+          };
+
+          const completionId = `chatcmpl-${randomUUID()}`;
+          const created = Math.floor(Date.now() / 1000);
+
+          if (stream) {
+            res.writeHead(200, {
+              'Content-Type': 'text/event-stream',
+              'Cache-Control': 'no-cache',
+              'Connection': 'keep-alive',
+            });
+
+            // Send initial role chunk
+            const roleChunk = {
+              id: completionId,
+              object: 'chat.completion.chunk',
+              created,
+              model,
+              choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
+            };
+            res.write(`data: ${JSON.stringify(roleChunk)}\n\n`);
+
+            for await (const event of agentLoop({
+              model,
+              messages: reqMessages,
+              tools: coreTools,
+              provider,
+              context,
+            })) {
+              if (event.type === 'text_delta') {
+                const chunk = {
+                  id: completionId,
+                  object: 'chat.completion.chunk',
+                  created,
+                  model,
+                  choices: [{ index: 0, delta: { content: event.text }, finish_reason: null }],
+                };
+                res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+              } else if (event.type === 'done') {
+                const finalChunk = {
+                  id: completionId,
+                  object: 'chat.completion.chunk',
+                  created,
+                  model,
+                  choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+                };
+                res.write(`data: ${JSON.stringify(finalChunk)}\n\n`);
+              }
+            }
+
+            res.write('data: [DONE]\n\n');
+            res.end();
+          } else {
+            // Non-streaming response
+            let fullContent = '';
+            for await (const event of agentLoop({
+              model,
+              messages: reqMessages,
+              tools: coreTools,
+              provider,
+              context,
+            })) {
+              if (event.type === 'text_delta') {
+                fullContent += event.text;
+              }
+            }
+
+            const response = {
+              id: completionId,
+              object: 'chat.completion',
+              created,
+              model,
+              choices: [{
+                index: 0,
+                message: { role: 'assistant', content: fullContent },
+                finish_reason: 'stop',
+              }],
+              usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+            };
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(response));
+          }
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: { message: err.message, type: 'server_error' } }));
+        }
+        return;
+      }
+    }
+
     // Chat endpoint
     if (req.method === 'POST' && url.pathname === '/chat') {
       let body = '';
@@ -503,15 +802,30 @@ async function runServer(options) {
     console.log(`Listening on http://localhost:${port}`);
     console.log(`\nEndpoints:`);
     console.log(`  GET  /health     Health check`);
-    console.log(`  POST /chat       Send message (SSE stream)\n`);
+    console.log(`  POST /chat       Send message (SSE stream)`);
+    if (options.openai) {
+      console.log(`\nOpenAI-compatible API:`);
+      console.log(`  GET  /v1/models            List available models`);
+      console.log(`  POST /v1/chat/completions  Chat completions (SSE stream)`);
+    }
+    console.log();
   });
 }
 
 /**
  * List all available tools.
+ *
+ * @param {Object} options - CLI options
  */
-async function runTools() {
+async function runTools(options) {
   await loadModules();
+
+  if (options.json) {
+    const toolList = coreTools.map((t) => ({ name: t.name, description: t.description }));
+    console.log(JSON.stringify(toolList));
+    return;
+  }
+
   console.log(`\ndotbot tools (${coreTools.length})\n`);
 
   // Group tools by category based on name prefix
@@ -539,27 +853,39 @@ async function runTools() {
 async function runStats(options) {
   const storesObj = await initStores(options.db, options.verbose, options.system);
 
-  console.log(`\ndotbot stats\n`);
-  console.log(`  Database: ${options.db}`);
-
   // Sessions
   const sessions = await storesObj.sessionStore.listSessions('cli-user');
-  console.log(`  Sessions: ${sessions.length}`);
 
   // Memory
   const memories = await storesObj.memoryStore.getAllMemories('cli-user');
-  console.log(`  Memories: ${memories.length}`);
 
   // Jobs (need to get session IDs first)
   const jobs = await storesObj.cronStore.listTasksBySessionIds(['default'], 'cli-user');
-  console.log(`  Jobs: ${jobs.length}`);
 
   // Tasks
   const tasks = await storesObj.taskStore.getTasks('cli-user');
-  console.log(`  Tasks: ${tasks.length}`);
 
   // Triggers
   const triggers = await storesObj.triggerStore.listTriggers('cli-user');
+
+  if (options.json) {
+    console.log(JSON.stringify({
+      database: options.db,
+      sessions: sessions.length,
+      memories: memories.length,
+      jobs: jobs.length,
+      tasks: tasks.length,
+      triggers: triggers.length,
+    }));
+    return;
+  }
+
+  console.log(`\ndotbot stats\n`);
+  console.log(`  Database: ${options.db}`);
+  console.log(`  Sessions: ${sessions.length}`);
+  console.log(`  Memories: ${memories.length}`);
+  console.log(`  Jobs: ${jobs.length}`);
+  console.log(`  Tasks: ${tasks.length}`);
   console.log(`  Triggers: ${triggers.length}`);
 
   console.log();
@@ -569,14 +895,28 @@ async function runStats(options) {
  * Manage memories.
  *
  * @param {Object} options - CLI options
- * @param {string} subcommand - list or search
- * @param {string} query - Search query
+ * @param {string} subcommand - list, search, or delete
+ * @param {string} query - Search query or key to delete
  */
 async function runMemory(options, subcommand, query) {
   const storesObj = await initStores(options.db, options.verbose, options.system);
 
+  if (subcommand === 'delete' && query) {
+    const result = await storesObj.memoryStore.deleteMemory('cli-user', query);
+    if (options.json) {
+      console.log(JSON.stringify({ deleted: result, key: query }));
+    } else {
+      console.log(result ? `\nDeleted memory: ${query}\n` : `\nMemory not found: ${query}\n`);
+    }
+    return;
+  }
+
   if (subcommand === 'search' && query) {
     const results = await storesObj.memoryStore.readMemoryPattern('cli-user', `%${query}%`);
+    if (options.json) {
+      console.log(JSON.stringify(results));
+      return;
+    }
     console.log(`\nMemory search: "${query}" (${results.length} results)\n`);
     for (const mem of results) {
       const val = typeof mem.value === 'string' ? mem.value : JSON.stringify(mem.value);
@@ -584,6 +924,10 @@ async function runMemory(options, subcommand, query) {
     }
   } else {
     const memories = await storesObj.memoryStore.getAllMemories('cli-user');
+    if (options.json) {
+      console.log(JSON.stringify(memories));
+      return;
+    }
     console.log(`\nMemories (${memories.length})\n`);
     for (const mem of memories) {
       const val = typeof mem.value === 'string' ? mem.value : JSON.stringify(mem.value);
@@ -594,14 +938,32 @@ async function runMemory(options, subcommand, query) {
 }
 
 /**
- * List scheduled jobs.
+ * Manage scheduled jobs.
  *
  * @param {Object} options - CLI options
+ * @param {string} subcommand - list or delete
+ * @param {string} jobId - Job ID to delete
  */
-async function runJobs(options) {
+async function runJobs(options, subcommand, jobId) {
   const storesObj = await initStores(options.db, options.verbose, options.system);
 
+  if (subcommand === 'delete' && jobId) {
+    const result = await storesObj.cronStore.deleteTask(jobId);
+    if (options.json) {
+      console.log(JSON.stringify({ deleted: result, id: jobId }));
+    } else {
+      console.log(result ? `\nDeleted job: ${jobId}\n` : `\nJob not found: ${jobId}\n`);
+    }
+    return;
+  }
+
   const jobs = await storesObj.cronStore.listTasksBySessionIds(['default'], 'cli-user');
+
+  if (options.json) {
+    console.log(JSON.stringify(jobs));
+    return;
+  }
+
   console.log(`\nScheduled jobs (${jobs.length})\n`);
 
   for (const job of jobs) {
@@ -617,14 +979,32 @@ async function runJobs(options) {
 }
 
 /**
- * List active tasks.
+ * Manage active tasks.
  *
  * @param {Object} options - CLI options
+ * @param {string} subcommand - list or delete
+ * @param {string} taskId - Task ID to delete
  */
-async function runTasks(options) {
+async function runTasks(options, subcommand, taskId) {
   const storesObj = await initStores(options.db, options.verbose, options.system);
 
+  if (subcommand === 'delete' && taskId) {
+    const result = await storesObj.taskStore.deleteTask('cli-user', taskId);
+    if (options.json) {
+      console.log(JSON.stringify({ deleted: result, id: taskId }));
+    } else {
+      console.log(result ? `\nDeleted task: ${taskId}\n` : `\nTask not found: ${taskId}\n`);
+    }
+    return;
+  }
+
   const tasks = await storesObj.taskStore.getTasks('cli-user');
+
+  if (options.json) {
+    console.log(JSON.stringify(tasks));
+    return;
+  }
+
   console.log(`\nTasks (${tasks.length})\n`);
 
   for (const task of tasks) {
@@ -639,14 +1019,32 @@ async function runTasks(options) {
 }
 
 /**
- * List chat sessions.
+ * Manage chat sessions.
  *
  * @param {Object} options - CLI options
+ * @param {string} subcommand - list or delete
+ * @param {string} sessionId - Session ID to delete
  */
-async function runSessions(options) {
+async function runSessions(options, subcommand, sessionId) {
   const storesObj = await initStores(options.db, options.verbose, options.system);
 
+  if (subcommand === 'delete' && sessionId) {
+    const result = await storesObj.sessionStore.deleteSession(sessionId, 'cli-user');
+    if (options.json) {
+      console.log(JSON.stringify({ deleted: result, id: sessionId }));
+    } else {
+      console.log(result ? `\nDeleted session: ${sessionId}\n` : `\nSession not found: ${sessionId}\n`);
+    }
+    return;
+  }
+
   const sessions = await storesObj.sessionStore.listSessions('cli-user');
+
+  if (options.json) {
+    console.log(JSON.stringify(sessions));
+    return;
+  }
+
   console.log(`\nSessions (${sessions.length})\n`);
 
   for (const session of sessions) {
@@ -670,6 +1068,10 @@ async function runEvents(options) {
 
   if (options.summary) {
     const summary = await storesObj.eventStore.summary({ userId: 'cli-user' });
+    if (options.json) {
+      console.log(JSON.stringify(summary));
+      return;
+    }
     console.log(`\nEvent summary\n`);
     console.log(`  Total events: ${summary.total || 0}`);
     if (summary.breakdown) {
@@ -679,6 +1081,10 @@ async function runEvents(options) {
     }
   } else {
     const events = await storesObj.eventStore.query({ userId: 'cli-user', limit: 20 });
+    if (options.json) {
+      console.log(JSON.stringify(events));
+      return;
+    }
     console.log(`\nRecent events (${events.length})\n`);
 
     for (const event of events) {
@@ -693,6 +1099,71 @@ async function runEvents(options) {
   console.log();
 }
 
+/**
+ * Check environment and configuration.
+ *
+ * @param {Object} options - CLI options
+ */
+async function runDoctor(options) {
+  console.log(`\ndotbot doctor\n`);
+
+  // Node.js version
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+  const nodeOk = nodeMajor >= 22;
+  console.log(`  Node.js: ${nodeVersion} ${nodeOk ? '\u2713' : '\u2717 (requires >= 22.0.0)'}`);
+
+  // Database check
+  const dbPath = options.db;
+  let dbOk = false;
+  try {
+    if (existsSync(dbPath)) {
+      // Try to open database
+      const { DatabaseSync } = await import('node:sqlite');
+      const db = new DatabaseSync(dbPath, { open: true });
+      db.close();
+      dbOk = true;
+    } else {
+      dbOk = true; // Will be created on first use
+    }
+  } catch {
+    dbOk = false;
+  }
+  console.log(`  Database: ${dbPath} ${dbOk ? '\u2713' : '\u2717 not accessible'}`);
+
+  // Config file check
+  let configOk = false;
+  let configMsg = '';
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      const content = readFileSync(CONFIG_PATH, 'utf8');
+      JSON.parse(content);
+      configOk = true;
+      configMsg = `${CONFIG_PATH} \u2713`;
+    } catch (err) {
+      configMsg = `${CONFIG_PATH} \u2717 invalid JSON`;
+    }
+  } else {
+    configMsg = `${CONFIG_PATH} (not found)`;
+  }
+  console.log(`  Config: ${configMsg}`);
+
+  // API Keys
+  console.log(`\n  API Keys:`);
+  const apiKeys = [
+    { name: 'XAI_API_KEY', env: process.env.XAI_API_KEY },
+    { name: 'ANTHROPIC_API_KEY', env: process.env.ANTHROPIC_API_KEY },
+    { name: 'OPENAI_API_KEY', env: process.env.OPENAI_API_KEY },
+  ];
+
+  for (const key of apiKeys) {
+    const isSet = Boolean(key.env);
+    console.log(`    ${key.name}: ${isSet ? '\u2713 set' : '\u2717 not set'}`);
+  }
+
+  console.log();
+}
+
 /**
  * Main entry point.
  */
@@ -711,12 +1182,28 @@ async function main() {
 
   const command = args.positionals[0];
 
+  // Handle piped input from stdin
+  if (!process.stdin.isTTY && !command) {
+    let input = '';
+    for await (const chunk of process.stdin) {
+      input += chunk;
+    }
+    const message = input.trim();
+    if (message) {
+      await runChat(message, args);
+      return;
+    }
+  }
+
   switch (command) {
+    case 'doctor':
+      await runDoctor(args);
+      break;
     case 'serve':
       await runServer(args);
       break;
     case 'tools':
-      await runTools();
+      await runTools(args);
       break;
     case 'stats':
       await runStats(args);
@@ -725,13 +1212,13 @@ async function main() {
       await runMemory(args, args.positionals[1], args.positionals.slice(2).join(' '));
       break;
     case 'jobs':
-      await runJobs(args);
+      await runJobs(args, args.positionals[1], args.positionals[2]);
       break;
     case 'tasks':
-      await runTasks(args);
+      await runTasks(args, args.positionals[1], args.positionals[2]);
       break;
     case 'sessions':
-      await runSessions(args);
+      await runSessions(args, args.positionals[1], args.positionals[2]);
       break;
     case 'events':
       await runEvents(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stevederico/dotbot",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "AI agent CLI and library for Node.js — streaming, multi-provider, tool execution, autonomous tasks",
   "type": "module",
   "main": "index.js",