nikcli 0.0.6

package/src/tool/codesearch.ts

@@ -0,0 +1,132 @@
+import z from "zod"
+import { Tool } from "./tool"
+import DESCRIPTION from "./codesearch.txt"
+
+const API_CONFIG = {
+  BASE_URL: "https://mcp.exa.ai",
+  ENDPOINTS: {
+    CONTEXT: "/mcp",
+  },
+} as const
+
+interface McpCodeRequest {
+  jsonrpc: string
+  id: number
+  method: string
+  params: {
+    name: string
+    arguments: {
+      query: string
+      tokensNum: number
+    }
+  }
+}
+
+interface McpCodeResponse {
+  jsonrpc: string
+  result: {
+    content: Array<{
+      type: string
+      text: string
+    }>
+  }
+}
+
+export const CodeSearchTool = Tool.define("codesearch", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    query: z
+      .string()
+      .describe(
+        "Search query to find relevant context for APIs, Libraries, and SDKs. For example, 'React useState hook examples', 'Python pandas dataframe filtering', 'Express.js middleware', 'Next js partial prerendering configuration'",
+      ),
+    tokensNum: z
+      .number()
+      .min(1000)
+      .max(50000)
+      .default(5000)
+      .describe(
+        "Number of tokens to return (1000-50000). Default is 5000 tokens. Adjust this value based on how much context you need - use lower values for focused queries and higher values for comprehensive documentation.",
+      ),
+  }),
+  async execute(params, ctx) {
+    await ctx.ask({
+      permission: "codesearch",
+      patterns: [params.query],
+      always: ["*"],
+      metadata: {
+        query: params.query,
+        tokensNum: params.tokensNum,
+      },
+    })
+
+    const codeRequest: McpCodeRequest = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: {
+        name: "get_code_context_exa",
+        arguments: {
+          query: params.query,
+          tokensNum: params.tokensNum || 5000,
+        },
+      },
+    }
+
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), 30000)
+
+    try {
+      const headers: Record<string, string> = {
+        accept: "application/json, text/event-stream",
+        "content-type": "application/json",
+      }
+
+      const response = await fetch(`${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.CONTEXT}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(codeRequest),
+        signal: AbortSignal.any([controller.signal, ctx.abort]),
+      })
+
+      clearTimeout(timeoutId)
+
+      if (!response.ok) {
+        const errorText = await response.text()
+        throw new Error(`Code search error (${response.status}): ${errorText}`)
+      }
+
+      const responseText = await response.text()
+
+      // Parse SSE response
+      const lines = responseText.split("\n")
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data: McpCodeResponse = JSON.parse(line.substring(6))
+          if (data.result && data.result.content && data.result.content.length > 0) {
+            return {
+              output: data.result.content[0].text,
+              title: `Code search: ${params.query}`,
+              metadata: {},
+            }
+          }
+        }
+      }
+
+      return {
+        output:
+          "No code snippets or documentation found. Please try a different query, be more specific about the library or programming concept, or check the spelling of framework names.",
+        title: `Code search: ${params.query}`,
+        metadata: {},
+      }
+    } catch (error) {
+      clearTimeout(timeoutId)
+
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error("Code search request timed out")
+      }
+
+      throw error
+    }
+  },
+})

package/src/tool/codesearch.txt

@@ -0,0 +1,12 @@
+- Search and get relevant context for any programming task using Exa Code API
+- Provides the highest quality and freshest context for libraries, SDKs, and APIs
+- Use this tool for ANY question or task related to programming
+- Returns comprehensive code examples, documentation, and API references
+- Optimized for finding specific programming patterns and solutions
+
+Usage notes:
+  - Adjustable token count (1000-50000) for focused or comprehensive results
+  - Default 5000 tokens provides balanced context for most queries
+  - Use lower values for specific questions, higher values for comprehensive documentation
+  - Supports queries about frameworks, libraries, APIs, and programming concepts
+  - Examples: 'React useState hook examples', 'Python pandas dataframe filtering', 'Express.js middleware'

package/src/tool/context_collect.ts

@@ -0,0 +1,152 @@
+import z from "zod"
+import path from "path"
+import { pathToFileURL } from "url"
+import { Tool } from "./tool"
+import DESCRIPTION from "./context_collect.txt"
+import { Instance } from "@/project/instance"
+import { Ripgrep } from "@/file/ripgrep"
+import { assertExternalDirectory } from "./external-directory"
+import { FileIgnore } from "@/file/ignore"
+import { LSP } from "@/lsp"
+
+const parameters = z.object({
+  paths: z.array(z.string()).optional().describe("Files or directories to include"),
+  pattern: z.string().optional().describe("Optional regex filter for lines"),
+  maxFiles: z.number().int().min(1).max(100).optional().describe("Maximum files to collect"),
+  maxLines: z.number().int().min(1).max(2000).optional().describe("Maximum lines per file"),
+  includeSymbols: z.boolean().optional().describe("Include LSP symbols for files"),
+  includeDiagnostics: z.boolean().optional().describe("Include LSP diagnostics for files"),
+})
+
+export const ContextCollectTool = Tool.define<typeof parameters, { count: number; truncated: boolean }>(
+  "context_collect",
+  {
+    description: DESCRIPTION,
+    parameters,
+    async execute(params, ctx) {
+      const roots = params.paths?.length ? params.paths : [Instance.directory]
+      const limitFiles = params.maxFiles ?? 20
+      const limitLines = params.maxLines ?? 200
+      const includeSymbols = params.includeSymbols ?? false
+      const includeDiagnostics = params.includeDiagnostics ?? false
+      const resolved = roots.map((item) => (path.isAbsolute(item) ? item : path.resolve(Instance.directory, item)))
+      const regex = params.pattern ? new RegExp(params.pattern) : undefined
+
+      await ctx.ask({
+        permission: "context_collect",
+        patterns: resolved,
+        always: ["*"],
+        metadata: {
+          paths: resolved,
+          pattern: params.pattern,
+          maxFiles: limitFiles,
+          maxLines: limitLines,
+        },
+      })
+
+      for (const item of resolved) {
+        const info = await Bun.file(item)
+          .stat()
+          .catch(() => undefined)
+        const kind = info && info.isDirectory() ? "directory" : "file"
+        await assertExternalDirectory(ctx, item, { kind })
+      }
+
+      const files = await collectFiles(resolved, limitFiles)
+      const diagnostics = includeDiagnostics ? await LSP.diagnostics() : undefined
+      const lines: string[] = []
+
+      if (files.length === 0) {
+        return {
+          title: "Context collect",
+          output: "No files found.",
+          metadata: {
+            count: 0,
+            truncated: false,
+          },
+        }
+      }
+
+      lines.push(`Collected ${files.length} files`)
+
+      for (const file of files) {
+        const rel = path.relative(Instance.directory, file) || file
+        const body = await readSnippet(file, limitLines, regex)
+        const snippet = body || "(no matching content)"
+        lines.push("")
+        lines.push(`file: ${rel}`)
+        lines.push(snippet)
+
+        if (includeSymbols) {
+          const symbols = await collectSymbols(file)
+          if (symbols.length > 0) {
+            lines.push("")
+            lines.push("symbols:")
+            lines.push(...symbols.map((item) => `- ${item}`))
+          }
+        }
+
+        if (includeDiagnostics && diagnostics) {
+          const issues = diagnostics[file] ?? []
+          if (issues.length > 0) {
+            lines.push("")
+            lines.push("diagnostics:")
+            lines.push(...issues.slice(0, 10).map((item) => `- ${LSP.Diagnostic.pretty(item)}`))
+          }
+        }
+      }
+
+      return {
+        title: "Context collect",
+        output: lines.join("\n"),
+        metadata: {
+          count: files.length,
+          truncated: files.length >= limitFiles,
+        },
+      }
+    },
+  },
+)
+
+async function collectFiles(roots: string[], limit: number) {
+  const files: string[] = []
+  for (const root of roots) {
+    if (files.length >= limit) break
+    const info = await Bun.file(root)
+      .stat()
+      .catch(() => undefined)
+    if (!info) continue
+    if (info.isFile()) {
+      files.push(root)
+      continue
+    }
+    if (!info.isDirectory()) continue
+
+    for await (const entry of Ripgrep.files({ cwd: root })) {
+      if (files.length >= limit) break
+      const full = path.join(root, entry)
+      const rel = path.relative(Instance.directory, full)
+      if (FileIgnore.match(rel)) continue
+      files.push(full)
+    }
+  }
+  return files
+}
+
+async function readSnippet(filePath: string, limit: number, regex?: RegExp) {
+  const file = Bun.file(filePath)
+  if (file.type.startsWith("image/") || file.type === "application/pdf") {
+    return ""
+  }
+  const text = await file.text().catch(() => "")
+  if (!text) return ""
+  const lines = text.split("\n")
+  const filtered = regex ? lines.filter((line) => regex.test(line)) : lines
+  return filtered.slice(0, limit).join("\n")
+}
+
+async function collectSymbols(filePath: string) {
+  const uri = pathToFileURL(filePath).href
+  const symbols = await LSP.documentSymbol(uri).catch(() => [])
+  return symbols.map((item) => item.name).slice(0, 20)
+}

package/src/tool/context_collect.txt

@@ -0,0 +1,9 @@
+Collect workspace context from files.
+
+Usage:
+- paths: files or directories to include
+- pattern: optional regex to filter lines
+- maxFiles: maximum files to collect (default: 20)
+- maxLines: maximum lines per file (default: 200)
+- includeSymbols: include LSP symbols
+- includeDiagnostics: include LSP diagnostics

package/src/tool/context_diagnostics.ts

@@ -0,0 +1,81 @@
+import z from "zod"
+import path from "path"
+import { Tool } from "./tool"
+import DESCRIPTION from "./context_diagnostics.txt"
+import { LSP } from "@/lsp"
+import { Instance } from "@/project/instance"
+import { assertExternalDirectory } from "./external-directory"
+
+const parameters = z.object({
+  filePath: z.string().optional().describe("Optional file path to filter diagnostics"),
+  limit: z.number().int().min(1).max(200).optional().describe("Maximum diagnostics per file"),
+})
+
+export const ContextDiagnosticsTool = Tool.define<typeof parameters, { count: number }>("context_diagnostics", {
+  description: DESCRIPTION,
+  parameters,
+  async execute(params, ctx) {
+    const limit = params.limit ?? 50
+
+    await ctx.ask({
+      permission: "context_diagnostics",
+      patterns: [params.filePath ?? "*"],
+      always: ["*"],
+      metadata: {
+        filePath: params.filePath,
+        limit,
+      },
+    })
+
+    if (params.filePath) {
+      const target = path.isAbsolute(params.filePath)
+        ? params.filePath
+        : path.resolve(Instance.directory, params.filePath)
+      await assertExternalDirectory(ctx, target, { kind: "file" })
+      await LSP.touchFile(target, true)
+
+      const all = await LSP.diagnostics()
+      const issues = all[target] ?? []
+      if (issues.length === 0) {
+        return {
+          title: path.relative(Instance.worktree, target),
+          output: "No diagnostics found.",
+          metadata: { count: 0 },
+        }
+      }
+
+      const output = issues
+        .slice(0, limit)
+        .map((item) => LSP.Diagnostic.pretty(item))
+        .join("\n")
+      return {
+        title: path.relative(Instance.worktree, target),
+        output,
+        metadata: { count: issues.length },
+      }
+    }
+
+    const diagnostics = await LSP.diagnostics()
+    const entries = Object.entries(diagnostics).filter(([, issues]) => issues.length > 0)
+    if (entries.length === 0) {
+      return {
+        title: "Diagnostics",
+        output: "No diagnostics found.",
+        metadata: { count: 0 },
+      }
+    }
+
+    const lines: string[] = []
+    for (const [file, issues] of entries) {
+      lines.push(`${file}:`)
+      lines.push(...issues.slice(0, limit).map((item) => `  ${LSP.Diagnostic.pretty(item)}`))
+      lines.push("")
+    }
+
+    return {
+      title: "Diagnostics",
+      output: lines.join("\n").trim(),
+      metadata: { count: entries.length },
+    }
+  },
+})

package/src/tool/context_diagnostics.txt

@@ -0,0 +1,5 @@
+List LSP diagnostics.
+
+Usage:
+- filePath: optional file path to filter
+- limit: maximum diagnostics per file (default: 50)

package/src/tool/context_related.ts

@@ -0,0 +1,117 @@
+import z from "zod"
+import path from "path"
+import { Tool } from "./tool"
+import DESCRIPTION from "./context_related.txt"
+import { Instance } from "@/project/instance"
+import { assertExternalDirectory } from "./external-directory"
+
+const parameters = z.object({
+  filePath: z.string().describe("Entry file to analyze for related imports"),
+  limit: z.number().int().min(1).max(200).optional().describe("Maximum related files"),
+})
+
+export const ContextRelatedTool = Tool.define<typeof parameters, { count: number }>("context_related", {
+  description: DESCRIPTION,
+  parameters,
+  async execute(params, ctx) {
+    const entry = path.isAbsolute(params.filePath) ? params.filePath : path.resolve(Instance.directory, params.filePath)
+    const limit = params.limit ?? 50
+
+    await ctx.ask({
+      permission: "context_related",
+      patterns: [entry],
+      always: ["*"],
+      metadata: {
+        filePath: entry,
+        limit,
+      },
+    })
+
+    await assertExternalDirectory(ctx, entry, { kind: "file" })
+
+    const file = Bun.file(entry)
+    if (!(await file.exists())) {
+      throw new Error(`File not found: ${entry}`)
+    }
+
+    const text = await file.text().catch(() => "")
+    if (!text) {
+      return {
+        title: path.relative(Instance.worktree, entry),
+        output: "No related files found.",
+        metadata: { count: 0 },
+      }
+    }
+
+    const imports = collectImports(text)
+    const related = await resolveImports(imports, path.dirname(entry), limit)
+
+    if (related.length === 0) {
+      return {
+        title: path.relative(Instance.worktree, entry),
+        output: "No related files found.",
+        metadata: { count: 0 },
+      }
+    }
+
+    return {
+      title: path.relative(Instance.worktree, entry),
+      output: related.join("\n"),
+      metadata: { count: related.length },
+    }
+  },
+})
+
+function collectImports(text: string) {
+  const results = new Set<string>()
+  const patterns = [/from\s+["']([^"']+)["']/g, /require\(\s*["']([^"']+)["']\s*\)/g, /import\s+["']([^"']+)["']/g]
+
+  for (const pattern of patterns) {
+    for (const match of text.matchAll(pattern)) {
+      const item = match[1]
+      if (!item) continue
+      results.add(item)
+    }
+  }
+
+  return Array.from(results)
+}
+
+async function resolveImports(imports: string[], base: string, limit: number) {
+  const results: string[] = []
+  for (const item of imports) {
+    if (results.length >= limit) break
+    if (!item.startsWith(".")) continue
+    const full = path.resolve(base, item)
+    const resolved = await resolveFile(full)
+    if (!resolved) continue
+    results.push(resolved)
+  }
+  return results
+}
+
+async function resolveFile(base: string) {
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.js`,
+    `${base}.jsx`,
+    `${base}.mjs`,
+    `${base}.cjs`,
+    `${base}.json`,
+    `${base}.mts`,
+    `${base}.cts`,
+    path.join(base, "index.ts"),
+    path.join(base, "index.tsx"),
+    path.join(base, "index.js"),
+    path.join(base, "index.jsx"),
+    path.join(base, "index.mjs"),
+    path.join(base, "index.cjs"),
+  ]
+
+  for (const item of candidates) {
+    if (await Bun.file(item).exists()) return item
+  }
+  return undefined
+}

package/src/tool/context_related.txt

@@ -0,0 +1,5 @@
+List files related to an entry file.
+
+Usage:
+- filePath: entry file to analyze
+- limit: maximum related files (default: 50)

package/src/tool/context_search.ts

@@ -0,0 +1,108 @@
+import z from "zod"
+import path from "path"
+import { Tool } from "./tool"
+import DESCRIPTION from "./context_search.txt"
+import { Rag } from "@/rag"
+import { Ripgrep } from "@/file/ripgrep"
+import { Instance } from "@/project/instance"
+import { assertExternalDirectory } from "./external-directory"
+
+const parameters = z.object({
+  pattern: z.string().describe("Regex pattern to search for"),
+  path: z.string().optional().describe("Directory to search in"),
+  include: z.string().optional().describe('File pattern to include in the search (e.g. "*.ts")'),
+  limit: z.number().int().min(1).max(200).optional().describe("Maximum number of matches"),
+  mode: z.enum(["regex", "semantic"]).optional().describe("Search mode (regex or semantic)"),
+})
+
+export const ContextSearchTool = Tool.define<typeof parameters, { matches: number; truncated: boolean }>(
+  "context_search",
+  {
+    description: DESCRIPTION,
+    parameters,
+    async execute(params, ctx) {
+      const search = params.path ?? Instance.directory
+      const base = path.isAbsolute(search) ? search : path.resolve(Instance.directory, search)
+      const limit = params.limit ?? 50
+      const mode = params.mode ?? "regex"
+
+      await ctx.ask({
+        permission: "context_search",
+        patterns: [params.pattern],
+        always: ["*"],
+        metadata: {
+          pattern: params.pattern,
+          path: base,
+          include: params.include,
+          limit,
+          mode,
+        },
+      })
+
+      await assertExternalDirectory(ctx, base, { kind: "directory" })
+
+      if (mode === "semantic") {
+        const semantic = await Rag.search({
+          query: params.pattern,
+          limit,
+        })
+        if (!semantic.ready) {
+          return {
+            title: params.pattern,
+            output: "RAG index not found. Run rag_index first.",
+            metadata: { matches: 0, truncated: false },
+          }
+        }
+        if (semantic.results.length === 0) {
+          return {
+            title: params.pattern,
+            output: "No semantic matches found.",
+            metadata: { matches: 0, truncated: false },
+          }
+        }
+        const lines = semantic.results.map((item) => {
+          const score = item.score.toFixed(3)
+          return `[${score}] ${item.file}:${item.start}-${item.end} ${item.snippet}`
+        })
+        return {
+          title: params.pattern,
+          output: lines.join("\n"),
+          metadata: { matches: semantic.results.length, truncated: false },
+        }
+      }
+
+      const matches = await Ripgrep.search({
+        cwd: base,
+        pattern: params.pattern,
+        glob: params.include ? [params.include] : undefined,
+        limit,
+      })
+
+      if (matches.length === 0) {
+        return {
+          title: params.pattern,
+          output: "No matches found.",
+          metadata: { matches: 0, truncated: false },
+        }
+      }
+
+      const rows = [`Found ${matches.length} matches`]
+      for (const match of matches) {
+        const full = path.resolve(base, match.path.text)
+        const text = match.lines.text.replace(/\s+/g, " ").trim()
+        rows.push(`${full}:${match.line_number}: ${text}`)
+      }
+
+      if (matches.length >= limit) {
+        rows.push("")
+        rows.push("(Results are truncated. Consider narrowing the pattern or path.)")
+      }
+
+      return {
+        title: params.pattern,
+        output: rows.join("\n"),
+        metadata: { matches: matches.length, truncated: matches.length >= limit },
+      }
+    },
+  },
+)

package/src/tool/context_search.txt

@@ -0,0 +1,8 @@
+Search workspace text to gather context.
+
+Usage:
+- pattern: regex pattern to search for
+- path: directory to search (defaults to workspace)
+- include: glob filter
+- limit: maximum matches (default: 50)
+- mode: regex or semantic search