nikcli 0.0.6

package/src/tool/generate_image.ts

@@ -0,0 +1,174 @@
+import z from "zod"
+import { Tool } from "./tool"
+import DESCRIPTION from "./generate_image.txt"
+import { Config } from "@/config/config"
+import { Provider } from "@/provider/provider"
+import { ProviderTransform } from "@/provider/transform"
+import { experimental_generateImage } from "ai"
+import { Identifier } from "@/id/id"
+import type { MessageV2 } from "@/session/message-v2"
+import { Installation } from "@/installation"
+import os from "os"
+import { Instance } from "@/project/instance"
+import { Flag } from "@/flag/flag"
+
+const GPT_IMAGE_LATEST = {
+  provider: "openrouter",
+  model: "openai/gpt-5-image",
+} as const
+
+const NANOBANANA_LATEST = {
+  provider: "openrouter",
+  model: "google/nano-banana-pro-2.5",
+} as const
+
+function extFromMime(mime: string): string {
+  switch (mime) {
+    case "image/png":
+      return ".png"
+    case "image/jpeg":
+      return ".jpg"
+    case "image/webp":
+      return ".webp"
+    default:
+      return ""
+  }
+}
+
+function buildRequestHeaders(input: {
+  model: Provider.Model
+  sessionID: string
+  messageID: string
+}): Record<string, string> {
+  if (input.model.providerID.startsWith("nikcli")) {
+    return {
+      "x-nikcli-project": Instance.project.id,
+      "x-nikcli-session": input.sessionID,
+      "x-nikcli-request": input.messageID,
+      "x-nikcli-client": Flag.NIKCLI_CLIENT,
+    }
+  }
+
+  return {
+    "User-Agent": `nikcli/${Installation.VERSION} (${os.platform()} ${os.release()}; ${os.arch()})`,
+  }
+}
+
+const parameters = z
+  .object({
+    prompt: z.string().describe("Text prompt for image generation"),
+    generator: z.enum(["gpt_image", "nanobanana"]).optional().describe("Preset image generator to use (optional)"),
+    provider: z.string().optional().describe("Provider ID to use (overrides config/preset)"),
+    model: z.string().optional().describe("Image model ID to use (overrides config/preset)"),
+    n: z.number().int().min(1).max(4).optional().describe("Number of images to generate (default: 1)"),
+    size: z
+      .string()
+      .regex(/^\d+x\d+$/, "size must be in the format {width}x{height}")
+      .optional()
+      .describe('Image size in the format "{width}x{height}" (optional)'),
+    aspectRatio: z
+      .string()
+      .regex(/^\d+:\d+$/, "aspectRatio must be in the format {width}:{height}")
+      .optional()
+      .describe('Image aspect ratio in the format "{width}:{height}" (optional)'),
+    seed: z.number().int().optional().describe("Deterministic seed (optional)"),
+    providerOptions: z
+      .record(z.string(), z.any())
+      .optional()
+      .describe("Provider-specific options passed through to the underlying image API (optional)"),
+  })
+  .superRefine((val, ctx) => {
+    if (val.size && val.aspectRatio) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Provide either size or aspectRatio, not both.",
+        path: ["aspectRatio"],
+      })
+    }
+  })
+
+export const GenerateImageTool = Tool.define("generate_image", {
+  description: DESCRIPTION,
+  parameters,
+  async execute(params, ctx) {
+    const config = await Config.get()
+
+    const preset = params.generator === "nanobanana" ? NANOBANANA_LATEST : GPT_IMAGE_LATEST
+    const configured = params.generator ? undefined : config.image
+
+    const providerID =
+      params.provider ?? (params.generator ? preset.provider : configured?.provider) ?? GPT_IMAGE_LATEST.provider
+    const modelID = params.model ?? (params.generator ? preset.model : configured?.model) ?? GPT_IMAGE_LATEST.model
+
+    await ctx.ask({
+      permission: "generate_image",
+      patterns: [`${providerID}/${modelID}`],
+      always: ["*"],
+      metadata: {
+        provider: providerID,
+        model: modelID,
+        generator: params.generator,
+        n: params.n,
+        size: params.size,
+        aspectRatio: params.aspectRatio,
+        seed: params.seed,
+      },
+    })
+
+    const model = await Provider.getModel(providerID, modelID)
+    const imageModel = await Provider.getImageModel(model)
+
+    const providerOptions = params.providerOptions
+      ? ProviderTransform.providerOptions(model, params.providerOptions)
+      : undefined
+
+    const result = await experimental_generateImage({
+      model: imageModel,
+      prompt: params.prompt,
+      n: params.n ?? 1,
+      size: params.size as any,
+      aspectRatio: params.aspectRatio as any,
+      seed: params.seed,
+      providerOptions,
+      abortSignal: ctx.abort,
+      headers: buildRequestHeaders({ model, sessionID: ctx.sessionID, messageID: ctx.messageID }),
+    })
+
+    const attachments: MessageV2.FilePart[] = result.images.map((image, index) => {
+      const ext = extFromMime(image.mediaType)
+      const filename = `generated-${index + 1}${ext}`
+      return {
+        id: Identifier.ascending("part"),
+        sessionID: ctx.sessionID,
+        messageID: ctx.messageID,
+        type: "file",
+        mime: image.mediaType,
+        url: `data:${image.mediaType};base64,${image.base64}`,
+        filename,
+      }
+    })
+
+    const warnings = result.warnings?.length ? result.warnings : undefined
+
+    const lines = [
+      `Generated ${result.images.length} image(s) using ${providerID}/${modelID}.`,
+      params.size ? `Size: ${params.size}` : undefined,
+      params.aspectRatio ? `Aspect ratio: ${params.aspectRatio}` : undefined,
+      params.seed !== undefined ? `Seed: ${params.seed}` : undefined,
+      warnings ? `Warnings: ${warnings.map((w) => w.type).join(", ")}` : undefined,
+    ].filter(Boolean)
+
+    return {
+      title: "Generate image",
+      output: lines.join("\n"),
+      attachments,
+      metadata: {
+        provider: providerID,
+        model: modelID,
+        generator: params.generator,
+        count: result.images.length,
+        warnings,
+      },
+    }
+  },
+})

package/src/tool/generate_image.txt

@@ -0,0 +1,12 @@
+Generate an image from a text prompt using an image model (e.g. GPT Image or Nano Banana).
+
+Usage:
+- prompt: text prompt for image generation
+- generator: preset image generator (optional)
+- provider: provider ID override (optional)
+- model: model ID override (optional)
+- n: number of images to generate (default: 1)
+- size: output size in "{width}x{height}" (optional)
+- aspectRatio: output aspect ratio in "{width}:{height}" (optional)
+- seed: deterministic seed (optional)
+- providerOptions: provider-specific options passed through to the underlying API (optional)

package/src/tool/glob.ts

@@ -0,0 +1,79 @@
+import z from "zod"
+import path from "path"
+import { Tool } from "./tool"
+import DESCRIPTION from "./glob.txt"
+import { Ripgrep } from "../file/ripgrep"
+import { Instance } from "../project/instance"
+import { assertExternalDirectory } from "./external-directory"
+
+export const GlobTool = Tool.define("glob", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    pattern: z.string().describe("The glob pattern to match files against"),
+    path: z
+      .string()
+      .optional()
+      .describe(
+        `The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.`,
+      ),
+  }),
+  async execute(params, ctx) {
+    await ctx.ask({
+      permission: "glob",
+      patterns: [params.pattern],
+      always: ["*"],
+      metadata: {
+        pattern: params.pattern,
+        path: params.path,
+      },
+    })
+
+    let search = params.path ?? Instance.directory
+    search = path.isAbsolute(search) ? search : path.resolve(Instance.directory, search)
+    await assertExternalDirectory(ctx, search, { kind: "directory" })
+
+    const limit = 100
+    const files = []
+    let truncated = false
+    for await (const file of Ripgrep.files({
+      cwd: search,
+      glob: [params.pattern],
+    })) {
+      if (files.length >= limit) {
+        truncated = true
+        break
+      }
+      const full = path.resolve(search, file)
+      const stats = await Bun.file(full)
+        .stat()
+        .then((x) => x.mtime.getTime())
+        .catch(() => 0)
+      files.push({
+        path: full,
+        mtime: stats,
+      })
+    }
+    files.sort((a, b) => b.mtime - a.mtime)
+
+    const output = []
+    if (files.length === 0) output.push("No files found")
+    if (files.length > 0) {
+      output.push(...files.map((f) => f.path))
+      if (truncated) {
+        output.push("")
+        output.push(
+          `(Results are truncated: showing first ${limit} results. Consider using a more specific path or pattern.)`,
+        )
+      }
+    }
+
+    return {
+      title: path.relative(Instance.worktree, search),
+      metadata: {
+        count: files.length,
+        truncated,
+      },
+      output: output.join("\n"),
+    }
+  },
+})

package/src/tool/glob.txt

@@ -0,0 +1,6 @@
+- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
+- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.

package/src/tool/grep.ts

@@ -0,0 +1,153 @@
+import z from "zod"
+import { Tool } from "./tool"
+import { Ripgrep } from "../file/ripgrep"
+
+import DESCRIPTION from "./grep.txt"
+import { Instance } from "../project/instance"
+import path from "path"
+import { assertExternalDirectory } from "./external-directory"
+
+const MAX_LINE_LENGTH = 2000
+
+export const GrepTool = Tool.define("grep", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    pattern: z.string().describe("The regex pattern to search for in file contents"),
+    path: z.string().optional().describe("The directory to search in. Defaults to the current working directory."),
+    include: z.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
+  }),
+  async execute(params, ctx) {
+    if (!params.pattern) {
+      throw new Error("pattern is required")
+    }
+
+    await ctx.ask({
+      permission: "grep",
+      patterns: [params.pattern],
+      always: ["*"],
+      metadata: {
+        pattern: params.pattern,
+        path: params.path,
+        include: params.include,
+      },
+    })
+
+    let searchPath = params.path ?? Instance.directory
+    searchPath = path.isAbsolute(searchPath) ? searchPath : path.resolve(Instance.directory, searchPath)
+    await assertExternalDirectory(ctx, searchPath, { kind: "directory" })
+
+    const rgPath = await Ripgrep.filepath()
+    const args = [
+      "-nH",
+      "--hidden",
+      "--follow",
+      "--no-messages",
+      "--field-match-separator=|",
+      "--regexp",
+      params.pattern,
+    ]
+    if (params.include) {
+      args.push("--glob", params.include)
+    }
+    args.push(searchPath)
+
+    const proc = Bun.spawn([rgPath, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    const output = await new Response(proc.stdout).text()
+    const errorOutput = await new Response(proc.stderr).text()
+    const exitCode = await proc.exited
+
+    if (exitCode === 1 || (exitCode === 2 && !output.trim())) {
+      return {
+        title: params.pattern,
+        metadata: { matches: 0, truncated: false },
+        output: "No files found",
+      }
+    }
+
+    if (exitCode !== 0 && exitCode !== 2) {
+      throw new Error(`ripgrep failed: ${errorOutput}`)
+    }
+
+    const hasErrors = exitCode === 2
+
+    const lines = output.trim().split(/\r?\n/)
+    const matches = []
+
+    for (const line of lines) {
+      if (!line) continue
+
+      const [filePath, lineNumStr, ...lineTextParts] = line.split("|")
+      if (!filePath || !lineNumStr || lineTextParts.length === 0) continue
+
+      const lineNum = parseInt(lineNumStr, 10)
+      const lineText = lineTextParts.join("|")
+
+      const file = Bun.file(filePath)
+      const stats = await file.stat().catch(() => null)
+      if (!stats) continue
+
+      matches.push({
+        path: filePath,
+        modTime: stats.mtime.getTime(),
+        lineNum,
+        lineText,
+      })
+    }
+
+    matches.sort((a, b) => b.modTime - a.modTime)
+
+    const limit = 100
+    const truncated = matches.length > limit
+    const finalMatches = truncated ? matches.slice(0, limit) : matches
+
+    if (finalMatches.length === 0) {
+      return {
+        title: params.pattern,
+        metadata: { matches: 0, truncated: false },
+        output: "No files found",
+      }
+    }
+
+    const totalMatches = matches.length
+    const outputLines = [`Found ${totalMatches}${truncated ? ` (showing first ${limit})` : ""} matches`]
+
+    let currentFile = ""
+    for (const match of finalMatches) {
+      if (currentFile !== match.path) {
+        if (currentFile !== "") {
+          outputLines.push("")
+        }
+        currentFile = match.path
+        outputLines.push(`${match.path}:`)
+      }
+      const truncatedLineText =
+        match.lineText.length > MAX_LINE_LENGTH ? match.lineText.substring(0, MAX_LINE_LENGTH) + "..." : match.lineText
+      outputLines.push(`  Line ${match.lineNum}: ${truncatedLineText}`)
+    }
+
+    if (truncated) {
+      outputLines.push("")
+      outputLines.push(
+        `(Results truncated: showing ${limit} of ${totalMatches} matches (${totalMatches - limit} hidden). Consider using a more specific path or pattern.)`,
+      )
+    }
+
+    if (hasErrors) {
+      outputLines.push("")
+      outputLines.push("(Some paths were inaccessible and skipped)")
+    }
+
+    return {
+      title: params.pattern,
+      metadata: {
+        matches: totalMatches,
+        truncated,
+      },
+      output: outputLines.join("\n"),
+    }
+  },
+})

package/src/tool/grep.txt

@@ -0,0 +1,8 @@
+- Fast content search tool that works with any codebase size
+- Searches file contents using regular expressions
+- Supports full regex syntax (eg. "log.*Error", "function\s+\w+", etc.)
+- Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}")
+- Returns file paths and line numbers with at least one match sorted by modification time
+- Use this tool when you need to find files containing specific patterns
+- If you need to identify/count the number of matches within files, use the Bash tool with `rg` (ripgrep) directly. Do NOT use `grep`.
+- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead

package/src/tool/invalid.ts

@@ -0,0 +1,17 @@
+import z from "zod"
+import { Tool } from "./tool"
+
+export const InvalidTool = Tool.define("invalid", {
+  description: "Do not use",
+  parameters: z.object({
+    tool: z.string(),
+    error: z.string(),
+  }),
+  async execute(params) {
+    return {
+      title: "Invalid Tool",
+      output: `The arguments provided to the tool are invalid: ${params.error}`,
+      metadata: {},
+    }
+  },
+})

package/src/tool/ls.ts

@@ -0,0 +1,116 @@
+import z from "zod"
+import { Tool } from "./tool"
+import * as path from "path"
+import DESCRIPTION from "./ls.txt"
+import { Instance } from "../project/instance"
+import { Ripgrep } from "../file/ripgrep"
+import { assertExternalDirectory } from "./external-directory"
+
+export const IGNORE_PATTERNS = [
+  "node_modules/",
+  "__pycache__/",
+  ".git/",
+  "dist/",
+  "build/",
+  "target/",
+  "vendor/",
+  "bin/",
+  "obj/",
+  ".idea/",
+  ".vscode/",
+  ".zig-cache/",
+  "zig-out",
+  ".coverage",
+  "coverage/",
+  "vendor/",
+  "tmp/",
+  "temp/",
+  ".cache/",
+  "cache/",
+  "logs/",
+  ".venv/",
+  "venv/",
+  "env/",
+]
+
+const LIMIT = 100
+
+export const ListTool = Tool.define("list", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    path: z.string().describe("The absolute path to the directory to list (must be absolute, not relative)").optional(),
+    ignore: z.array(z.string()).describe("List of glob patterns to ignore").optional(),
+  }),
+  async execute(params, ctx) {
+    const searchPath = path.resolve(Instance.directory, params.path || ".")
+    await assertExternalDirectory(ctx, searchPath, { kind: "directory" })
+
+    await ctx.ask({
+      permission: "list",
+      patterns: [searchPath],
+      always: ["*"],
+      metadata: {
+        path: searchPath,
+      },
+    })
+
+    const ignoreGlobs = IGNORE_PATTERNS.map((p) => `!${p}*`).concat(params.ignore?.map((p) => `!${p}`) || [])
+    const files = []
+    for await (const file of Ripgrep.files({ cwd: searchPath, glob: ignoreGlobs })) {
+      files.push(file)
+      if (files.length >= LIMIT) break
+    }
+
+    const dirs = new Set<string>()
+    const filesByDir = new Map<string, string[]>()
+
+    for (const file of files) {
+      const dir = path.dirname(file)
+      const parts = dir === "." ? [] : dir.split("/")
+
+      for (let i = 0; i <= parts.length; i++) {
+        const dirPath = i === 0 ? "." : parts.slice(0, i).join("/")
+        dirs.add(dirPath)
+      }
+
+      if (!filesByDir.has(dir)) filesByDir.set(dir, [])
+      filesByDir.get(dir)!.push(path.basename(file))
+    }
+
+    function renderDir(dirPath: string, depth: number): string {
+      const indent = "  ".repeat(depth)
+      let output = ""
+
+      if (depth > 0) {
+        output += `${indent}${path.basename(dirPath)}/\n`
+      }
+
+      const childIndent = "  ".repeat(depth + 1)
+      const children = Array.from(dirs)
+        .filter((d) => path.dirname(d) === dirPath && d !== dirPath)
+        .sort()
+
+      for (const child of children) {
+        output += renderDir(child, depth + 1)
+      }
+
+      const files = filesByDir.get(dirPath) || []
+      for (const file of files.sort()) {
+        output += `${childIndent}${file}\n`
+      }
+
+      return output
+    }
+
+    const output = `${searchPath}/\n` + renderDir(".", 0)
+
+    return {
+      title: path.relative(Instance.worktree, searchPath),
+      metadata: {
+        count: files.length,
+        truncated: files.length >= LIMIT,
+      },
+      output,
+    }
+  },
+})

package/src/tool/ls.txt

@@ -0,0 +1 @@
+Lists files and directories in a given path. The path parameter must be absolute; omit it to use the current workspace directory. You can optionally provide an array of glob patterns to ignore with the ignore parameter. You should generally prefer the Glob and Grep tools, if you know which directories to search.

package/src/tool/lsp.ts

@@ -0,0 +1,96 @@
+import z from "zod"
+import { Tool } from "./tool"
+import path from "path"
+import { LSP } from "../lsp"
+import DESCRIPTION from "./lsp.txt"
+import { Instance } from "../project/instance"
+import { pathToFileURL } from "url"
+import { assertExternalDirectory } from "./external-directory"
+
+const operations = [
+  "goToDefinition",
+  "findReferences",
+  "hover",
+  "documentSymbol",
+  "workspaceSymbol",
+  "goToImplementation",
+  "prepareCallHierarchy",
+  "incomingCalls",
+  "outgoingCalls",
+] as const
+
+export const LspTool = Tool.define("lsp", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    operation: z.enum(operations).describe("The LSP operation to perform"),
+    filePath: z.string().describe("The absolute or relative path to the file"),
+    line: z.number().int().min(1).describe("The line number (1-based, as shown in editors)"),
+    character: z.number().int().min(1).describe("The character offset (1-based, as shown in editors)"),
+  }),
+  execute: async (args, ctx) => {
+    const file = path.isAbsolute(args.filePath) ? args.filePath : path.join(Instance.directory, args.filePath)
+    await assertExternalDirectory(ctx, file)
+
+    await ctx.ask({
+      permission: "lsp",
+      patterns: ["*"],
+      always: ["*"],
+      metadata: {},
+    })
+    const uri = pathToFileURL(file).href
+    const position = {
+      file,
+      line: args.line - 1,
+      character: args.character - 1,
+    }
+
+    const relPath = path.relative(Instance.worktree, file)
+    const title = `${args.operation} ${relPath}:${args.line}:${args.character}`
+
+    const exists = await Bun.file(file).exists()
+    if (!exists) {
+      throw new Error(`File not found: ${file}`)
+    }
+
+    const available = await LSP.hasClients(file)
+    if (!available) {
+      throw new Error("No LSP server available for this file type.")
+    }
+
+    await LSP.touchFile(file, true)
+
+    const result: unknown[] = await (async () => {
+      switch (args.operation) {
+        case "goToDefinition":
+          return LSP.definition(position)
+        case "findReferences":
+          return LSP.references(position)
+        case "hover":
+          return LSP.hover(position)
+        case "documentSymbol":
+          return LSP.documentSymbol(uri)
+        case "workspaceSymbol":
+          return LSP.workspaceSymbol("")
+        case "goToImplementation":
+          return LSP.implementation(position)
+        case "prepareCallHierarchy":
+          return LSP.prepareCallHierarchy(position)
+        case "incomingCalls":
+          return LSP.incomingCalls(position)
+        case "outgoingCalls":
+          return LSP.outgoingCalls(position)
+      }
+    })()
+
+    const output = (() => {
+      if (result.length === 0) return `No results found for ${args.operation}`
+      return JSON.stringify(result, null, 2)
+    })()
+
+    return {
+      title,
+      metadata: { result },
+      output,
+    }
+  },
+})

package/src/tool/lsp.txt

@@ -0,0 +1,19 @@
+Interact with Language Server Protocol (LSP) servers to get code intelligence features.
+
+Supported operations:
+- goToDefinition: Find where a symbol is defined
+- findReferences: Find all references to a symbol
+- hover: Get hover information (documentation, type info) for a symbol
+- documentSymbol: Get all symbols (functions, classes, variables) in a document
+- workspaceSymbol: Search for symbols across the entire workspace
+- goToImplementation: Find implementations of an interface or abstract method
+- prepareCallHierarchy: Get call hierarchy item at a position (functions/methods)
+- incomingCalls: Find all functions/methods that call the function at a position
+- outgoingCalls: Find all functions/methods called by the function at a position
+
+All operations require:
+- filePath: The file to operate on
+- line: The line number (1-based, as shown in editors)
+- character: The character offset (1-based, as shown in editors)
+
+Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.