junecoder 1.0.0

package/tools/ls.mjs

@@ -0,0 +1,62 @@
+/**
+ * ls tool — list directory contents with type, size, and modification time.
+ */
+import { readdirSync, statSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+
+export const lsTool = {
+  name: 'ls',
+  description:
+    'List directory contents with type, size, and modification time. Directories listed first.',
+  parameters: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'Directory path (default cwd)' },
+    },
+    required: [],
+  },
+  readonly: true,
+  parallel: true,
+
+  async execute(args, agent) {
+    const cwd = agent?.cwd || process.cwd();
+    const dir = args.path ? resolve(cwd, args.path) : cwd;
+
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      const results = [];
+
+      for (const entry of entries) {
+        const fullPath = resolve(dir, entry.name);
+        let info;
+        try {
+          const st = statSync(fullPath);
+          info = {
+            name: entry.name + (entry.isDirectory() ? '/' : ''),
+            size: st.size,
+            mtime: st.mtime.toISOString().slice(0, 19),
+          };
+        } catch {
+          info = { name: entry.name, size: 0, mtime: '???' };
+        }
+        info.isDir = entry.isDirectory();
+        results.push(info);
+      }
+
+      // Sort: directories first, then alphabetically
+      results.sort((a, b) => {
+        if (a.isDir && !b.isDir) return -1;
+        if (!a.isDir && b.isDir) return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+      const lines = results.map(
+        (r) => `${r.isDir ? 'd' : '-'} ${String(r.size).padStart(8)} ${r.mtime} ${r.name}`,
+      );
+
+      return `Directory: ${dir}\n${lines.join('\n') || '(empty)'}`;
+    } catch (err) {
+      return `Error listing directory: ${err.message}`;
+    }
+  },
+};

package/tools/read.mjs

@@ -0,0 +1,50 @@
+/**
+ * read tool — read a text file with optional offset/limit, returning numbered lines.
+ */
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export const readTool = {
+  name: 'read',
+  description:
+    'Read a text file. Returns numbered lines. Use offset/limit to page large files.',
+  parameters: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'File path, relative to cwd or absolute' },
+      offset: { type: 'number', description: '1-based line number to start from' },
+      limit: { type: 'number', description: 'Max lines to return (default 2000)' },
+    },
+    required: ['path'],
+  },
+  readonly: true,
+  parallel: true,
+
+  async execute(args, agent) {
+    const cwd = agent?.cwd || process.cwd();
+    const abs = resolve(cwd, args.path);
+
+    if (!existsSync(abs)) {
+      return `Error: file not found: ${args.path}`;
+    }
+
+    const st = statSync(abs);
+    if (st.isDirectory()) {
+      return `Error: "${args.path}" is a directory, not a file.`;
+    }
+
+    try {
+      const content = readFileSync(abs, 'utf-8');
+      const lines = content.split('\n');
+      const start = (args.offset || 1) - 1;
+      const end = args.limit ? start + args.limit : start + 2000;
+      const slice = lines.slice(Math.max(0, start), end);
+
+      return slice
+        .map((line, i) => `${String(start + i + 1).padStart(4, ' ')}| ${line}`)
+        .join('\n');
+    } catch (err) {
+      return `Error reading file: ${err.message}`;
+    }
+  },
+};

package/tools/websearch.mjs

@@ -0,0 +1,58 @@
+/**
+ * websearch tool — search the web (Bing).
+ */
+export const websearchTool = {
+  name: 'websearch',
+  description:
+    'Search the web (Bing). Returns result titles, URLs, and snippets.',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query' },
+      limit: { type: 'number', description: 'Max results (default 8)' },
+    },
+    required: ['query'],
+  },
+  readonly: true,
+  parallel: true,
+
+  async execute(args, _agent) {
+    try {
+      const url = `https://www.bing.com/search?q=${encodeURIComponent(args.query)}`;
+      const response = await fetch(url, {
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (compatible; junecode/1.0)',
+          'Accept': 'text/html',
+        },
+        signal: AbortSignal.timeout(15_000),
+      });
+
+      if (!response.ok) {
+        return `Error: HTTP ${response.status}`;
+      }
+
+      const html = await response.text();
+
+      // Parse Bing results (simple regex extraction)
+      const results = [];
+      const snippetRegex = /<li class="b_algo"[^>]*>[\s\S]*?<h2[^>]*><a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<p[^>]*>([\s\S]*?)<\/p>/gi;
+      let match;
+
+      while ((match = snippetRegex.exec(html)) !== null && results.length < (args.limit || 8)) {
+        const title = match[2].replace(/<[^>]+>/g, '').replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').trim();
+        const snippet = match[3].replace(/<[^>]+>/g, '').replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').trim();
+        if (title && snippet) {
+          results.push({ title, url: match[1], snippet });
+        }
+      }
+
+      if (results.length === 0) return '(no search results found)';
+
+      return results
+        .map((r) => `${r.title}\n  ${r.url}\n  ${r.snippet}`)
+        .join('\n\n');
+    } catch (err) {
+      return `Error searching web: ${err.message}`;
+    }
+  },
+};

package/tools/write.mjs

@@ -0,0 +1,54 @@
+/**
+ * write tool — write content to a file, creating parent directories as needed.
+ *
+ * Uses execSync (cat > file) for disk writes to avoid virtual-filesystem isolation
+ * that can cause writes to be lost when the agent session ends.
+ */
+import { existsSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
+
+/** Escape a path for safe use in a single-quoted shell string. */
+function shellEscape(str) {
+  return "'" + str.replace(/'/g, "'\\''") + "'";
+}
+
+export const writeTool = {
+  name: 'write',
+  description:
+    'Write content to a file. Creates parent directories; overwrites existing file.',
+  parameters: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'File path, relative to cwd or absolute' },
+      content: { type: 'string', description: 'Full content to write' },
+    },
+    required: ['path', 'content'],
+  },
+  readonly: false,
+  parallel: false,
+
+  async execute(args, agent) {
+    const cwd = agent?.cwd || process.cwd();
+    const abs = resolve(cwd, args.path);
+
+    try {
+      mkdirSync(dirname(abs), { recursive: true });
+      execSync(`cat > ${shellEscape(abs)}`, {
+        cwd,
+        input: args.content,
+        encoding: 'utf-8',
+        timeout: 10_000,
+        maxBuffer: 20 * 1024 * 1024,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      // Verify the write actually landed
+      if (existsSync(abs)) {
+        return `Wrote ${args.content.length} chars to ${args.path}`;
+      }
+      return `Error writing file: write command completed but file not found at ${args.path}`;
+    } catch (err) {
+      return `Error writing file: ${err.message}`;
+    }
+  },
+};

package/tools.mjs

@@ -0,0 +1,15 @@
+/**
+ * Tools index — schema conversion + base tool collection.
+ * Each tool lives in tools/*.mjs with its real implementation.
+ */
+export { readTool } from './tools/read.mjs';
+export { writeTool } from './tools/write.mjs';
+export { editTool } from './tools/edit.mjs';
+export { bashTool } from './tools/bash.mjs';
+export { globTool } from './tools/glob.mjs';
+export { grepTool } from './tools/grep.mjs';
+export { lsTool } from './tools/ls.mjs';
+export { fetchTool } from './tools/fetch.mjs';
+export { websearchTool } from './tools/websearch.mjs';
+export { deleteTool } from './tools/delete.mjs';
+export { toOpenAISchema, baseTools } from './tools/index.mjs';