nikcli 0.0.6

package/src/tool/rag_status.txt

@@ -0,0 +1,4 @@
+Show RAG index status.
+
+Usage:
+- no parameters

package/src/tool/read.ts

@@ -0,0 +1,203 @@
+import z from "zod"
+import * as fs from "fs"
+import * as path from "path"
+import { Tool } from "./tool"
+import { LSP } from "../lsp"
+import { FileTime } from "../file/time"
+import DESCRIPTION from "./read.txt"
+import { Instance } from "../project/instance"
+import { Identifier } from "../id/id"
+import { assertExternalDirectory } from "./external-directory"
+
+const DEFAULT_READ_LIMIT = 2000
+const MAX_LINE_LENGTH = 2000
+const MAX_BYTES = 50 * 1024
+
+export const ReadTool = Tool.define("read", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    filePath: z.string().describe("The absolute path to the file or directory to read"),
+    offset: z.coerce.number().describe("The line number to start reading from (1-indexed)").optional(),
+    limit: z.coerce.number().describe("The maximum number of lines to read (defaults to 2000)").optional(),
+  }),
+  async execute(params, ctx) {
+    if (params.offset !== undefined && params.offset < 1) {
+      throw new Error("offset must be greater than or equal to 1")
+    }
+    let filepath = params.filePath
+    if (!path.isAbsolute(filepath)) {
+      filepath = path.join(process.cwd(), filepath)
+    }
+    const title = path.relative(Instance.worktree, filepath)
+
+    await assertExternalDirectory(ctx, filepath, {
+      bypass: Boolean(ctx.extra?.["bypassCwdCheck"]),
+    })
+
+    await ctx.ask({
+      permission: "read",
+      patterns: [filepath],
+      always: ["*"],
+      metadata: {},
+    })
+
+    const file = Bun.file(filepath)
+    if (!(await file.exists())) {
+      const dir = path.dirname(filepath)
+      const base = path.basename(filepath)
+
+      const dirEntries = fs.readdirSync(dir)
+      const suggestions = dirEntries
+        .filter(
+          (entry) =>
+            entry.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(entry.toLowerCase()),
+        )
+        .map((entry) => path.join(dir, entry))
+        .slice(0, 3)
+
+      if (suggestions.length > 0) {
+        throw new Error(`File not found: ${filepath}\n\nDid you mean one of these?\n${suggestions.join("\n")}`)
+      }
+
+      throw new Error(`File not found: ${filepath}`)
+    }
+
+    const isImage =
+      file.type.startsWith("image/") && file.type !== "image/svg+xml" && file.type !== "image/vnd.fastbidsheet"
+    const isPdf = file.type === "application/pdf"
+    if (isImage || isPdf) {
+      const mime = file.type
+      const msg = `${isImage ? "Image" : "PDF"} read successfully`
+      return {
+        title,
+        output: msg,
+        metadata: {
+          preview: msg,
+          truncated: false,
+        },
+        attachments: [
+          {
+            id: Identifier.ascending("part"),
+            sessionID: ctx.sessionID,
+            messageID: ctx.messageID,
+            type: "file",
+            mime,
+            url: `data:${mime};base64,${Buffer.from(await file.bytes()).toString("base64")}`,
+          },
+        ],
+      }
+    }
+
+    const isBinary = await isBinaryFile(filepath, file)
+    if (isBinary) throw new Error(`Cannot read binary file: ${filepath}`)
+
+    const limit = params.limit ?? DEFAULT_READ_LIMIT
+    const offset = params.offset ?? 1
+    const start = offset - 1
+    const lines = await file.text().then((text) => text.split("\n"))
+    if (start >= lines.length) throw new Error(`Offset ${offset} is out of range for this file (${lines.length} lines)`)
+
+    const raw: string[] = []
+    let bytes = 0
+    let truncatedByBytes = false
+    for (let i = start; i < Math.min(lines.length, start + limit); i++) {
+      const line = lines[i].length > MAX_LINE_LENGTH ? lines[i].substring(0, MAX_LINE_LENGTH) + "..." : lines[i]
+      const size = Buffer.byteLength(line, "utf-8") + (raw.length > 0 ? 1 : 0)
+      if (bytes + size > MAX_BYTES) {
+        truncatedByBytes = true
+        break
+      }
+      raw.push(line)
+      bytes += size
+    }
+
+    const content = raw.map((line, index) => {
+      return `${index + offset}: ${line}`
+    })
+    const preview = raw.slice(0, 20).join("\n")
+
+    let output = "<file>\n"
+    output += content.join("\n")
+
+    const totalLines = lines.length
+    const lastReadLine = offset + raw.length - 1
+    const hasMoreLines = totalLines > lastReadLine
+    const truncated = hasMoreLines || truncatedByBytes
+
+    if (truncatedByBytes) {
+      output += `\n\n(Output truncated at ${MAX_BYTES} bytes. Use 'offset' parameter to read beyond line ${lastReadLine})`
+    } else if (hasMoreLines) {
+      output += `\n\n(File has more lines. Use 'offset' parameter to read beyond line ${lastReadLine})`
+    } else {
+      output += `\n\n(End of file - total ${totalLines} lines)`
+    }
+    output += "\n</file>"
+
+    LSP.touchFile(filepath, false)
+    FileTime.read(ctx.sessionID, filepath)
+
+    return {
+      title,
+      output,
+      metadata: {
+        preview,
+        truncated,
+      },
+    }
+  },
+})
+
+async function isBinaryFile(filepath: string, file: Bun.BunFile): Promise<boolean> {
+  const ext = path.extname(filepath).toLowerCase()
+  switch (ext) {
+    case ".zip":
+    case ".tar":
+    case ".gz":
+    case ".exe":
+    case ".dll":
+    case ".so":
+    case ".class":
+    case ".jar":
+    case ".war":
+    case ".7z":
+    case ".doc":
+    case ".docx":
+    case ".xls":
+    case ".xlsx":
+    case ".ppt":
+    case ".pptx":
+    case ".odt":
+    case ".ods":
+    case ".odp":
+    case ".bin":
+    case ".dat":
+    case ".obj":
+    case ".o":
+    case ".a":
+    case ".lib":
+    case ".wasm":
+    case ".pyc":
+    case ".pyo":
+      return true
+    default:
+      break
+  }
+
+  const stat = await file.stat()
+  const fileSize = stat.size
+  if (fileSize === 0) return false
+
+  const bufferSize = Math.min(4096, fileSize)
+  const buffer = await file.arrayBuffer()
+  if (buffer.byteLength === 0) return false
+  const bytes = new Uint8Array(buffer.slice(0, bufferSize))
+
+  let nonPrintableCount = 0
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] === 0) return true
+    if (bytes[i] < 9 || (bytes[i] > 13 && bytes[i] < 32)) {
+      nonPrintableCount++
+    }
+  }
+  return nonPrintableCount / bytes.length > 0.3
+}

package/src/tool/read.txt

@@ -0,0 +1,12 @@
+Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The filePath parameter must be an absolute path, not a relative path
+- By default, it reads up to 2000 lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- Any lines longer than 2000 characters will be truncated
+- Results are returned using cat -n format, with line numbers starting at 1
+- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
+- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
+- You can read image files using this tool.

package/src/tool/registry.ts

@@ -0,0 +1,214 @@
+import { plugin } from "bun"
+import { QuestionTool } from "./question"
+import { BashTool } from "./bash"
+import { EditTool } from "./edit"
+import { GlobTool } from "./glob"
+import { GrepTool } from "./grep"
+import { BatchTool } from "./batch"
+import { ReadTool } from "./read"
+import { TaskTool } from "./task"
+import { TodoWriteTool, TodoReadTool } from "./todo"
+import { WebFetchTool } from "./webfetch"
+import { WriteTool } from "./write"
+import { InvalidTool } from "./invalid"
+import { SkillTool } from "./skill"
+import type { Agent } from "../agent/agent"
+import { Tool } from "./tool"
+import { Instance } from "../project/instance"
+import { Config } from "../config/config"
+import path from "path"
+import { type ToolDefinition } from "@nikcli-ai/plugin"
+import z from "zod"
+import { Plugin } from "../plugin"
+import { WebSearchTool } from "./websearch"
+import { CodeSearchTool } from "./codesearch"
+import { TreeTool } from "./tree"
+import { DocsAddTool } from "./docs_add"
+import { DocsSearchTool } from "./docs_search"
+import { DocsLoadTool } from "./docs_load"
+import { DocsUnloadTool } from "./docs_unload"
+import { DocsContextTool } from "./docs_context"
+import { DocsRequestTool } from "./docs_request"
+import { DocsGapReportTool } from "./docs_gap_report"
+import { SmartDocsTool } from "./smart_docs"
+import { ContextCollectTool } from "./context_collect"
+import { ContextSearchTool } from "./context_search"
+import { ContextRelatedTool } from "./context_related"
+import { ContextDiagnosticsTool } from "./context_diagnostics"
+import { MemorySearchTool } from "./memory_search"
+import { RagIndexTool } from "./rag_index"
+import { RagSearchTool } from "./rag_search"
+import { RagStatusTool } from "./rag_status"
+import { RagResetTool } from "./rag_reset"
+import { GenerateImageTool } from "./generate_image"
+import { Flag } from "@/flag/flag"
+import { Log } from "@/util/log"
+import { LspTool } from "./lsp"
+import { Truncate } from "./truncation"
+import { PlanExitTool, PlanEnterTool } from "./plan"
+import { ApplyPatchTool } from "./apply_patch"
+import { UseConnectorTool } from "./use-connector"
+import { SpeakTool } from "./speak"
+
+const _toolDir = import.meta.dir
+
+plugin({
+  name: "nikcli-plugin-resolver",
+  setup(build) {
+    build.onResolve({ filter: /^@nikcli-ai\/plugin/ }, (args) => {
+      try {
+        return { path: Bun.resolveSync(args.path, _toolDir) }
+      } catch {
+        return undefined
+      }
+    })
+  },
+})
+
+export namespace ToolRegistry {
+  const log = Log.create({ service: "tool.registry" })
+
+  export const state = Instance.state(async () => {
+    const custom = [] as Tool.Info[]
+    const glob = new Bun.Glob("{tool,tools}/*.{js,ts}")
+
+    for (const dir of await Config.directories()) {
+      for await (const match of glob.scan({
+        cwd: dir,
+        absolute: true,
+        followSymlinks: true,
+        dot: true,
+      })) {
+        const namespace = path.basename(match, path.extname(match))
+        const mod = await import(match)
+        for (const [id, def] of Object.entries<ToolDefinition>(mod)) {
+          custom.push(fromPlugin(id === "default" ? namespace : `${namespace}_${id}`, def))
+        }
+      }
+    }
+
+    const plugins = await Plugin.list()
+    for (const plugin of plugins) {
+      for (const [id, def] of Object.entries(plugin.tool ?? {})) {
+        custom.push(fromPlugin(id, def))
+      }
+    }
+
+    return { custom }
+  })
+
+  function fromPlugin(id: string, def: ToolDefinition): Tool.Info {
+    return {
+      id,
+      init: async (initCtx) => ({
+        parameters: z.object(def.args),
+        description: def.description,
+        execute: async (args, ctx) => {
+          const result = await def.execute(args as any, ctx)
+          const out = await Truncate.output(result, {}, initCtx?.agent)
+          return {
+            title: "",
+            output: out.truncated ? out.content : result,
+            metadata: { truncated: out.truncated, outputPath: out.truncated ? out.outputPath : undefined },
+          }
+        },
+      }),
+    }
+  }
+
+  export async function register(tool: Tool.Info) {
+    const { custom } = await state()
+    const idx = custom.findIndex((t) => t.id === tool.id)
+    if (idx >= 0) {
+      custom.splice(idx, 1, tool)
+      return
+    }
+    custom.push(tool)
+  }
+
+  async function all(): Promise<Tool.Info[]> {
+    const custom = await state().then((x) => x.custom)
+    const config = await Config.get()
+
+    return [
+      InvalidTool,
+      ...(["app", "cli", "desktop"].includes(Flag.NIKCLI_CLIENT) ? [QuestionTool] : []),
+      BashTool,
+      ReadTool,
+      TreeTool,
+      GlobTool,
+      GrepTool,
+      EditTool,
+      WriteTool,
+      TaskTool,
+      DocsAddTool,
+      DocsSearchTool,
+      DocsLoadTool,
+      DocsUnloadTool,
+      DocsContextTool,
+      DocsRequestTool,
+      DocsGapReportTool,
+      SmartDocsTool,
+      ContextCollectTool,
+      ContextSearchTool,
+      ContextRelatedTool,
+      ContextDiagnosticsTool,
+      MemorySearchTool,
+      RagIndexTool,
+      RagSearchTool,
+      RagStatusTool,
+      RagResetTool,
+      GenerateImageTool,
+      WebFetchTool,
+      TodoWriteTool,
+      TodoReadTool,
+      WebSearchTool,
+      CodeSearchTool,
+      SkillTool,
+      ApplyPatchTool,
+      ...(Flag.NIKCLI_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
+      ...(config.experimental?.batch_tool === true ? [BatchTool] : []),
+      ...(Flag.NIKCLI_EXPERIMENTAL_PLAN_MODE && Flag.NIKCLI_CLIENT === "cli" ? [PlanExitTool, PlanEnterTool] : []),
+      UseConnectorTool,
+      SpeakTool,
+      ...custom,
+    ]
+  }
+
+  export async function ids() {
+    return all().then((x) => x.map((t) => t.id))
+  }
+
+  export async function tools(
+    model: {
+      providerID: string
+      modelID: string
+    },
+    agent?: Agent.Info,
+  ) {
+    const tools = await all()
+    const result = await Promise.all(
+      tools
+        .filter((t) => {
+          if (t.id === "codesearch" || t.id === "websearch") {
+            return model.providerID === "nikcli" || Flag.NIKCLI_ENABLE_EXA
+          }
+
+          const usePatch =
+            model.modelID.includes("gpt-") && !model.modelID.includes("oss") && !model.modelID.includes("gpt-4")
+          if (t.id === "apply_patch") return usePatch
+          if (t.id === "edit" || t.id === "write") return !usePatch
+
+          return true
+        })
+        .map(async (t) => {
+          using _ = log.time(t.id)
+          return {
+            id: t.id,
+            ...(await t.init({ agent })),
+          }
+        }),
+    )
+    return result
+  }
+}

package/src/tool/skill.ts

@@ -0,0 +1,169 @@
+import z from "zod"
+import { Tool } from "./tool"
+import { Skill } from "../skill"
+import { PermissionNext } from "../permission/next"
+import { Session } from "../session"
+
+export const SkillTool = Tool.define("skill", async (ctx) => {
+  const allSkills = await Skill.all()
+
+  const agent = ctx?.agent
+  const accessibleSkills = agent
+    ? allSkills.filter((skill) => {
+        const rule = PermissionNext.evaluate("skill", skill.name, agent.permission)
+        return rule.action !== "deny"
+      })
+    : allSkills
+
+  const description =
+    accessibleSkills.length === 0
+      ? "Load a skill to get detailed instructions for a specific task. No skills are currently available."
+      : [
+          "Load a skill to get detailed instructions for a specific task.",
+          "Skills provide specialized knowledge and step-by-step guidance.",
+          "Use this when a task matches an available skill's description.",
+          "Only the skills listed here are available:",
+          "<available_skills>",
+          ...accessibleSkills.flatMap((skill) =>
+            [
+              `  <skill>`,
+              `    <name>${skill.name}</name>`,
+              `    <description>${skill.description}</description>`,
+              skill.category ? `    <category>${skill.category}</category>` : null,
+              skill.tags?.length ? `    <tags>${skill.tags.join(", ")}</tags>` : null,
+            ].filter(Boolean),
+          ),
+          "</available_skills>",
+        ].join(" ")
+
+  const examples = accessibleSkills
+    .map((skill) => `'${skill.name}'`)
+    .slice(0, 3)
+    .join(", ")
+  const hint = examples.length > 0 ? ` (e.g., ${examples}, ...)` : ""
+
+  const parameters = z.object({
+    name: z.string().optional().describe(`The skill identifier from available_skills${hint}`),
+    search: z.string().optional().describe("Filter skills by name or description"),
+    category: z.string().optional().describe("Filter skills by category"),
+    tags: z.string().optional().describe("Filter by comma-separated tags"),
+  })
+
+  return {
+    description,
+    parameters,
+    formatValidationError(error) {
+      const formattedErrors = error.issues
+        .map((issue) => {
+          const path = issue.path.length > 0 ? `${issue.path.join(".")}: ` : ""
+          return `  - ${path}${issue.message}`
+        })
+        .join("\n")
+      return `Invalid parameters for skill tool:\n${formattedErrors}`
+    },
+    async execute(
+      params: z.infer<typeof parameters>,
+      ctx: Tool.Context,
+    ): Promise<{ title: string; output: string; metadata: Record<string, any> }> {
+      let skills = accessibleSkills
+
+      if (params.search) {
+        const searchLower = params.search.toLowerCase()
+        skills = skills.filter((s) =>
+          [s.name, s.description, s.category ?? "", ...(s.tags ?? [])].some((value) =>
+            value.toLowerCase().includes(searchLower),
+          ),
+        )
+      }
+
+      if (params.category) {
+        skills = skills.filter((s) => s.category === params.category)
+      }
+
+      if (params.tags) {
+        const tagList = params.tags.split(",").map((t) => t.trim().toLowerCase())
+        skills = skills.filter((s) => s.tags?.some((t) => tagList.includes(t.toLowerCase())))
+      }
+
+      if (params.name) {
+        const resolved = await Skill.resolve(params.name, accessibleSkills)
+        if (!resolved.skill) {
+          const suggestions = resolved.suggestions.join(", ")
+          const available = accessibleSkills.map((skill) => skill.name).join(", ")
+          const hint = suggestions ? ` Did you mean: ${suggestions}?` : ""
+          throw new Error(`Skill "${params.name}" not found.${hint} Available skills: ${available || "none"}`)
+        }
+
+        await ctx.ask({
+          permission: "skill",
+          patterns: [resolved.skill.name],
+          always: [resolved.skill.name],
+          metadata: {},
+        })
+
+        const loaded = await Skill.load(resolved.skill.name)
+        if (!loaded) {
+          throw new Error(`Skill "${resolved.skill.name}" could not be loaded.`)
+        }
+
+        if (ctx.sessionID) {
+          await Session.update(ctx.sessionID, (draft) => {
+            const next = new Set(draft.skills ?? [])
+            next.add(loaded.name)
+            draft.skills = [...next]
+          })
+        }
+
+        const dir = loaded.dir
+
+        const meta = [
+          `**Slash command**: /${Skill.commandName(loaded.name)}`,
+          `**Base directory**: ${dir}`,
+          loaded.category ? `**Category**: ${loaded.category}` : null,
+          loaded.tags?.length ? `**Tags**: ${loaded.tags.join(", ")}` : null,
+          loaded.version ? `**Version**: ${loaded.version}` : null,
+        ].filter(Boolean)
+
+        const output = [`## Skill: ${loaded.name}`, "", meta.join("\n"), "", loaded.content].join("\n")
+
+        return {
+          title: `Loaded skill: ${loaded.name}`,
+          output,
+          metadata: {
+            name: loaded.name,
+            dir,
+            category: loaded.category,
+            tags: loaded.tags,
+            version: loaded.version,
+            command: Skill.commandName(loaded.name),
+          },
+        }
+      }
+
+      if (skills.length === 0) {
+        return {
+          title: "No skills found",
+          output: "No skills match the specified filters.",
+          metadata: { count: 0 },
+        }
+      }
+
+      return {
+        title: `Found ${skills.length} skill(s)`,
+        output: [
+          "## Matching Skills",
+          "",
+          ...skills.map((s) => `- **${s.name}**: ${s.description}${s.category ? ` (${s.category})` : ""}`),
+        ].join("\n"),
+        metadata: {
+          count: skills.length,
+          skills: skills.map((s) => ({
+            name: s.name,
+            category: s.category,
+            tags: s.tags,
+          })),
+        },
+      }
+    },
+  }
+})

package/src/tool/skill.txt

@@ -0,0 +1,3 @@
+Load a skill to get detailed instructions for a specific task.
+
+Skills provide specialized knowledge and step-by-step guidance. Use this when a task matches an available skill's description.

package/src/tool/smart_docs.ts

@@ -0,0 +1,74 @@
+import z from "zod"
+import { Tool } from "./tool"
+import DESCRIPTION from "./smart_docs.txt"
+import { searchDocs } from "@/docs/library"
+import { getContextSummary, loadDocs } from "@/docs/context"
+
+const parameters = z.object({
+  query: z.string().describe("Search query"),
+  category: z.string().optional().describe("Optional category filter"),
+  limit: z.number().int().min(1).max(20).optional().describe("Result limit"),
+  autoLoad: z.boolean().optional().describe("Load matching docs into context"),
+})
+
+export const SmartDocsTool = Tool.define("smart_docs", {
+  description: DESCRIPTION,
+  parameters,
+  async execute(params, ctx) {
+    const limit = params.limit ?? 5
+    const autoLoad = params.autoLoad ?? true
+
+    await ctx.ask({
+      permission: "smart_docs",
+      patterns: [params.query],
+      always: ["*"],
+      metadata: {
+        query: params.query,
+        category: params.category,
+        limit,
+        autoLoad,
+      },
+    })
+
+    const results = await searchDocs(params.query, params.category, limit)
+    if (results.length === 0) {
+      return {
+        title: `Smart docs: ${params.query}`,
+        output: "No documentation matches found.",
+        metadata: { count: 0 },
+      }
+    }
+
+    const lines = results.map((result) => {
+      const score = result.score.toFixed(2)
+      const snippet = result.snippet.replace(/\s+/g, " ").trim()
+      return `- ${result.entry.title} (id: ${result.entry.id}, score: ${score})\n  ${snippet}`
+    })
+
+    if (!autoLoad) {
+      return {
+        title: `Smart docs: ${params.query}`,
+        output: lines.join("\n"),
+        metadata: { count: results.length },
+      }
+    }
+
+    const ids = results.map((item) => item.entry.id)
+    const loaded = await loadDocs(ids)
+    const summary = await getContextSummary()
+    const details = [
+      `Loaded docs: ${loaded.loaded.length}`,
+      loaded.missing.length > 0 ? `Missing: ${loaded.missing.join(", ")}` : "",
+    ]
+      .filter(Boolean)
+      .join("\n")
+
+    const output = [lines.join("\n"), "", details, "", summary].filter(Boolean).join("\n")
+
+    return {
+      title: `Smart docs: ${params.query}`,
+      output,
+      metadata: { count: results.length },
+    }
+  },
+})

package/src/tool/smart_docs.txt

@@ -0,0 +1,7 @@
+Search documentation and optionally load results into context.
+
+Usage:
+- query: search phrase
+- category: optional category filter
+- limit: maximum results (default: 5)
+- autoLoad: load matches into docs context (default: true)