@cdoing/core 0.1.0

package/src/tools/view-repo-map.ts

@@ -0,0 +1,249 @@
+/**
+ * View Repo Map Tool — generate a structural overview of the repository.
+ *
+ * Shows the project layout: directories, key files, entry points,
+ * config files, and a summary of the codebase structure.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { exec } from "child_process";
+import type { BaseTool, ToolDefinition, ToolResult } from "./types";
+import { loadIgnorePatterns } from "../utils/gitignore";
+
+const ALWAYS_IGNORE = new Set([
+  "node_modules", ".git", "dist", "build", "out", ".next", ".nuxt",
+  "__pycache__", ".cache", ".turbo", "coverage", "venv", ".venv",
+  "target", "vendor", ".idea", ".vscode", ".DS_Store", "*.pyc",
+]);
+
+const CONFIG_FILES = new Set([
+  "package.json", "tsconfig.json", "tsconfig.base.json",
+  ".eslintrc.js", ".eslintrc.json", ".prettierrc",
+  "jest.config.js", "jest.config.ts", "vitest.config.ts",
+  "webpack.config.js", "vite.config.ts", "vite.config.js",
+  "rollup.config.js", "esbuild.config.js",
+  "Dockerfile", "docker-compose.yml", "docker-compose.yaml",
+  "Makefile", "CMakeLists.txt",
+  ".env.example", ".gitignore", ".dockerignore",
+  "pyproject.toml", "setup.py", "setup.cfg", "requirements.txt",
+  "Cargo.toml", "go.mod", "Gemfile", "composer.json",
+  "turbo.json", "lerna.json", "nx.json",
+]);
+
+const ENTRY_PATTERNS = [
+  "index.ts", "index.js", "main.ts", "main.js", "app.ts", "app.js",
+  "server.ts", "server.js", "cli.ts", "cli.js",
+  "index.py", "main.py", "app.py", "__main__.py",
+  "main.go", "main.rs", "lib.rs",
+];
+
+interface RepoStats {
+  totalFiles: number;
+  totalDirs: number;
+  languages: Map<string, number>;
+  configFiles: string[];
+  entryPoints: string[];
+}
+
+export class ViewRepoMapTool implements BaseTool {
+  definition: ToolDefinition = {
+    name: "view_repo_map",
+    description:
+      `Generate a structural overview of the repository. Shows:
+- Directory tree (top 2 levels)
+- Detected languages and file counts
+- Config files found
+- Likely entry points
+- Git branch and recent commits
+
+Use this to understand a new project before diving into code.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: "Subdirectory to focus on. Defaults to project root.",
+        },
+      },
+      required: [],
+    },
+    requiresPermission: false,
+  };
+
+  private workingDir: string;
+
+  constructor(workingDir: string) {
+    this.workingDir = workingDir;
+  }
+
+  async execute(input: Record<string, unknown>): Promise<ToolResult> {
+    const subdir = (input.directory as string) || "";
+    const rootDir = subdir ? path.resolve(this.workingDir, subdir) : this.workingDir;
+
+    if (!fs.existsSync(rootDir) || !fs.statSync(rootDir).isDirectory()) {
+      return { success: false, output: "", error: `Directory not found: ${rootDir}` };
+    }
+
+    const sections: string[] = [];
+
+    // 1. Header
+    sections.push(`# Repository Map: ${path.basename(rootDir)}`);
+    sections.push(`Path: ${rootDir}`);
+
+    // 2. Git info
+    const gitInfo = await this.getGitInfo(rootDir);
+    if (gitInfo) sections.push(gitInfo);
+
+    // 3. Directory tree (2 levels)
+    const tree = this.buildTree(rootDir, 2);
+    sections.push("\n## Directory Structure\n```\n" + tree + "\n```");
+
+    // 4. Stats
+    const stats = this.collectStats(rootDir);
+    sections.push(this.formatStats(stats));
+
+    return { success: true, output: sections.join("\n") };
+  }
+
+  private buildTree(dir: string, maxDepth: number, prefix = "", depth = 0): string {
+    if (depth > maxDepth) return "";
+
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return "";
+    }
+
+    entries = entries
+      .filter((e) => !ALWAYS_IGNORE.has(e.name) && !e.name.startsWith("."))
+      .sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory()) return -1;
+        if (!a.isDirectory() && b.isDirectory()) return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+    const lines: string[] = [];
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      const isLast = i === entries.length - 1;
+      const connector = isLast ? "└── " : "├── ";
+      const childPrefix = isLast ? "    " : "│   ";
+
+      if (entry.isDirectory()) {
+        lines.push(`${prefix}${connector}${entry.name}/`);
+        const subtree = this.buildTree(
+          path.join(dir, entry.name),
+          maxDepth,
+          prefix + childPrefix,
+          depth + 1,
+        );
+        if (subtree) lines.push(subtree);
+      } else {
+        lines.push(`${prefix}${connector}${entry.name}`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  private collectStats(dir: string, stats?: RepoStats, depth = 0): RepoStats {
+    if (!stats) {
+      stats = { totalFiles: 0, totalDirs: 0, languages: new Map(), configFiles: [], entryPoints: [] };
+    }
+    if (depth > 10 || stats.totalFiles > 5000) return stats;
+
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return stats;
+    }
+
+    for (const entry of entries) {
+      if (ALWAYS_IGNORE.has(entry.name)) continue;
+
+      if (entry.isDirectory()) {
+        stats.totalDirs++;
+        this.collectStats(path.join(dir, entry.name), stats, depth + 1);
+      } else {
+        stats.totalFiles++;
+
+        // Track language
+        const ext = path.extname(entry.name).toLowerCase();
+        if (ext) {
+          stats.languages.set(ext, (stats.languages.get(ext) || 0) + 1);
+        }
+
+        // Config files
+        if (CONFIG_FILES.has(entry.name) && depth <= 2) {
+          const rel = path.relative(this.workingDir, path.join(dir, entry.name));
+          stats.configFiles.push(rel);
+        }
+
+        // Entry points
+        if (ENTRY_PATTERNS.includes(entry.name) && depth <= 3) {
+          const rel = path.relative(this.workingDir, path.join(dir, entry.name));
+          stats.entryPoints.push(rel);
+        }
+      }
+    }
+
+    return stats;
+  }
+
+  private formatStats(stats: RepoStats): string {
+    const lines: string[] = ["\n## Summary"];
+    lines.push(`- **${stats.totalFiles}** files in **${stats.totalDirs}** directories`);
+
+    // Languages (top 10)
+    if (stats.languages.size > 0) {
+      const sorted = [...stats.languages.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10);
+      const langStr = sorted.map(([ext, count]) => `${ext} (${count})`).join(", ");
+      lines.push(`- **Languages:** ${langStr}`);
+    }
+
+    // Config files
+    if (stats.configFiles.length > 0) {
+      lines.push(`\n### Config Files`);
+      for (const f of stats.configFiles.slice(0, 20)) lines.push(`- ${f}`);
+    }
+
+    // Entry points
+    if (stats.entryPoints.length > 0) {
+      lines.push(`\n### Entry Points`);
+      for (const f of stats.entryPoints.slice(0, 20)) lines.push(`- ${f}`);
+    }
+
+    return lines.join("\n");
+  }
+
+  private getGitInfo(dir: string): Promise<string | null> {
+    return new Promise((resolve) => {
+      exec(
+        'git branch --show-current && echo "---" && git log --oneline -5 2>/dev/null',
+        { cwd: dir, timeout: 5000 },
+        (error, stdout) => {
+          if (error || !stdout.trim()) {
+            resolve(null);
+            return;
+          }
+          const parts = stdout.split("---");
+          const branch = parts[0]?.trim();
+          const commits = parts[1]?.trim();
+          const lines = [`Branch: **${branch}**`];
+          if (commits) {
+            lines.push("\nRecent commits:");
+            for (const c of commits.split("\n").slice(0, 5)) {
+              lines.push(`  ${c.trim()}`);
+            }
+          }
+          resolve(lines.join("\n"));
+        },
+      );
+    });
+  }
+}

package/src/tools/web-fetch.ts

@@ -0,0 +1,118 @@
+/**
+ * Web Fetch Tool — fetch content from URLs.
+ * Supports HTML pages (extracts text), JSON APIs, and plain text.
+ */
+
+import type { BaseTool, ToolDefinition, ToolResult } from "./types";
+import type { SandboxManager } from "../sandbox";
+
+export class WebFetchTool implements BaseTool {
+  definition: ToolDefinition = {
+    name: "web_fetch",
+    description:
+      "Fetch content from a URL. Returns the text content of the page. Useful for reading documentation, APIs, or web pages. Requires user permission. Network access is controlled by sandbox domain rules — requests to non-allowed domains may be blocked.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch",
+        },
+        max_length: {
+          type: "number",
+          description: "Maximum characters to return. Default: 10000.",
+        },
+      },
+      required: ["url"],
+    },
+    requiresPermission: true,
+    permissionMessage: (input) => `Fetch URL: ${input.url}`,
+  };
+
+  private sandboxManager?: SandboxManager;
+
+  constructor(sandboxManager?: SandboxManager) {
+    this.sandboxManager = sandboxManager;
+  }
+
+  async execute(input: Record<string, unknown>): Promise<ToolResult> {
+    const url = input.url as string;
+    const maxLength = (input.max_length as number) || 10000;
+
+    // Validate URL
+    try {
+      new URL(url);
+    } catch {
+      return { success: false, output: "", error: `Invalid URL: ${url}` };
+    }
+
+    // Sandbox network check
+    if (this.sandboxManager) {
+      const check = await this.sandboxManager.checkNetworkAccess(url);
+      if (!check.allowed) {
+        return { success: false, output: "", error: check.reason || "Sandbox: network access denied" };
+      }
+    }
+
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 30000);
+
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "Cdoing-Agent/0.1.0",
+          "Accept": "text/html,application/json,text/plain,*/*",
+        },
+      });
+
+      clearTimeout(timeout);
+
+      if (!response.ok) {
+        return {
+          success: false,
+          output: "",
+          error: `HTTP ${response.status}: ${response.statusText}`,
+        };
+      }
+
+      const contentType = response.headers.get("content-type") || "";
+      let text = await response.text();
+
+      // If HTML, strip tags and extract text content
+      if (contentType.includes("text/html")) {
+        text = stripHtml(text);
+      }
+
+      // Truncate if too long
+      if (text.length > maxLength) {
+        text = text.substring(0, maxLength) + `\n\n... [truncated at ${maxLength} characters]`;
+      }
+
+      return { success: true, output: text || "(empty response)" };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Fetch failed: ${message}` };
+    }
+  }
+}
+
+/** Simple HTML-to-text: remove tags, decode common entities, collapse whitespace */
+function stripHtml(html: string): string {
+  return html
+    // Remove script and style blocks
+    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+    // Remove HTML tags
+    .replace(/<[^>]+>/g, " ")
+    // Decode common entities
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, " ")
+    // Collapse whitespace
+    .replace(/\s+/g, " ")
+    .trim();
+}

package/src/tools/web-search.ts

@@ -0,0 +1,129 @@
+/**
+ * Web Search Tool — search the web using DuckDuckGo's HTML page.
+ * No API key required — uses DDG's lite HTML interface.
+ */
+
+import type { BaseTool, ToolDefinition, ToolResult } from "./types";
+
+export class WebSearchTool implements BaseTool {
+  definition: ToolDefinition = {
+    name: "web_search",
+    description:
+      "Search the web for information. Returns search results with titles, URLs, and snippets. Useful for finding documentation, solutions, or current information.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query",
+        },
+        max_results: {
+          type: "number",
+          description: "Maximum number of results. Default: 5.",
+        },
+      },
+      required: ["query"],
+    },
+    requiresPermission: true,
+    permissionMessage: (input) => `Web search: ${input.query}`,
+  };
+
+  async execute(input: Record<string, unknown>): Promise<ToolResult> {
+    const query = input.query as string;
+    const maxResults = (input.max_results as number) || 5;
+
+    try {
+      const encodedQuery = encodeURIComponent(query);
+      const url = `https://lite.duckduckgo.com/lite/?q=${encodedQuery}`;
+
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 15000);
+
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "Cdoing-Agent/0.1.0",
+          "Accept": "text/html",
+        },
+      });
+
+      clearTimeout(timeout);
+
+      if (!response.ok) {
+        return {
+          success: false,
+          output: "",
+          error: `Search failed: HTTP ${response.status}`,
+        };
+      }
+
+      const html = await response.text();
+      const results = parseSearchResults(html, maxResults);
+
+      if (results.length === 0) {
+        return { success: true, output: "No results found." };
+      }
+
+      const formatted = results
+        .map((r, i) => `${i + 1}. **${r.title}**\n   ${r.url}\n   ${r.snippet}`)
+        .join("\n\n");
+
+      return {
+        success: true,
+        output: `Search results for "${query}":\n\n${formatted}`,
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Search failed: ${message}` };
+    }
+  }
+}
+
+interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+}
+
+/** Parse DDG lite HTML for search results */
+function parseSearchResults(html: string, maxResults: number): SearchResult[] {
+  const results: SearchResult[] = [];
+
+  // DDG lite puts results in table rows with class "result-link" for titles
+  // and "result-snippet" for descriptions
+  const linkRegex = /<a[^>]+class="result-link"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+  const snippetRegex = /<td[^>]+class="result-snippet"[^>]*>([\s\S]*?)<\/td>/gi;
+
+  const links: { url: string; title: string }[] = [];
+  const snippets: string[] = [];
+
+  let match;
+  while ((match = linkRegex.exec(html)) !== null) {
+    links.push({
+      url: match[1].replace(/&amp;/g, "&"),
+      title: match[2].replace(/<[^>]+>/g, "").trim(),
+    });
+  }
+
+  while ((match = snippetRegex.exec(html)) !== null) {
+    snippets.push(
+      match[1]
+        .replace(/<[^>]+>/g, "")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .trim()
+    );
+  }
+
+  for (let i = 0; i < Math.min(links.length, maxResults); i++) {
+    results.push({
+      title: links[i].title || "(untitled)",
+      url: links[i].url,
+      snippet: snippets[i] || "",
+    });
+  }
+
+  return results;
+}

package/src/utils/gitignore.ts

@@ -0,0 +1,73 @@
+/**
+ * Gitignore-aware file filtering.
+ * Reads .gitignore and applies patterns to glob/grep searches.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+/** Default patterns to always ignore */
+const DEFAULT_IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/.git/**",
+  "**/*.lock",
+  "**/build/**",
+  "**/.next/**",
+  "**/.nuxt/**",
+  "**/coverage/**",
+  "**/__pycache__/**",
+  "**/.venv/**",
+  "**/venv/**",
+  "**/.env",
+  "**/.DS_Store",
+];
+
+/**
+ * Load ignore patterns from .gitignore + defaults.
+ * Converts .gitignore patterns to glob-compatible patterns.
+ */
+export function loadIgnorePatterns(workingDir: string): string[] {
+  const patterns = [...DEFAULT_IGNORE];
+  const gitignorePath = path.join(workingDir, ".gitignore");
+
+  try {
+    if (fs.existsSync(gitignorePath)) {
+      const content = fs.readFileSync(gitignorePath, "utf-8");
+      const lines = content.split("\n");
+
+      for (let line of lines) {
+        line = line.trim();
+        // Skip empty lines and comments
+        if (!line || line.startsWith("#")) continue;
+        // Skip negation patterns (complex to handle)
+        if (line.startsWith("!")) continue;
+
+        // Convert to glob pattern
+        let pattern = line;
+
+        // If it ends with /, it's a directory — add **
+        if (pattern.endsWith("/")) {
+          pattern = `**/${pattern}**`;
+        }
+        // If it doesn't contain a slash, it can match anywhere
+        else if (!pattern.includes("/")) {
+          pattern = `**/${pattern}`;
+        }
+        // If it starts with /, it's relative to root
+        else if (pattern.startsWith("/")) {
+          pattern = pattern.substring(1);
+        }
+
+        // Avoid duplicates
+        if (!patterns.includes(pattern)) {
+          patterns.push(pattern);
+        }
+      }
+    }
+  } catch {
+    // Silently ignore read errors
+  }
+
+  return patterns;
+}