@miaws/miaw 1.18.5 → 1.18.6

package/src/tool/edit.txt

@@ -1,10 +0,0 @@
-Performs exact string replacements in files. 
-
-Usage:
-- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
-- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: line number + colon + space (e.g., `1: `). Everything after that space is the actual file content to match. Never include any part of the line number prefix in the oldString or newString.
-- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
-- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
-- The edit will FAIL if `oldString` is not found in the file with an error "oldString not found in content".
-- The edit will FAIL if `oldString` is found multiple times in the file with an error "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match." Either provide a larger string with more surrounding context to make it unique or use `replaceAll` to change every instance of `oldString`. 
-- Use `replaceAll` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.

package/src/tool/external-directory.ts

@@ -1,49 +0,0 @@
-import path from "path"
-import { Effect } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import type * as Tool from "./tool"
-import { containsPath } from "../project/instance-context"
-import { FSUtil } from "@miaw/core/fs-util"
-
-type Kind = "file" | "directory"
-
-type Options = {
-  bypass?: boolean
-  kind?: Kind
-}
-
-export const assertExternalDirectoryEffect = Effect.fn("Tool.assertExternalDirectory")(function* (
-  ctx: Tool.Context,
-  target?: string,
-  options?: Options,
-) {
-  if (!target) return false
-
-  if (options?.bypass) return false
-
-  const ins = yield* InstanceState.context
-  const full = process.platform === "win32" ? FSUtil.normalizePath(target) : target
-  if (containsPath(full, ins)) return false
-
-  const kind = options?.kind ?? "file"
-  const dir = kind === "directory" ? full : path.dirname(full)
-  const glob =
-    process.platform === "win32"
-      ? FSUtil.normalizePathPattern(path.join(dir, "*"))
-      : path.join(dir, "*").replaceAll("\\", "/")
-
-  yield* ctx.ask({
-    permission: "external_directory",
-    patterns: [glob],
-    always: [glob],
-    metadata: {
-      filepath: full,
-      parentDir: dir,
-    },
-  })
-  return true
-})
-
-export async function assertExternalDirectory(ctx: Tool.Context, target?: string, options?: Options) {
-  return Effect.runPromise(assertExternalDirectoryEffect(ctx, target, options))
-}

package/src/tool/glob.ts

@@ -1,76 +0,0 @@
-import path from "path"
-import { Effect, Schema } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { FSUtil } from "@miaw/core/fs-util"
-import { Ripgrep } from "@miaw/core/ripgrep"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import DESCRIPTION from "./glob.txt"
-import * as Tool from "./tool"
-
-export const Parameters = Schema.Struct({
-  pattern: Schema.String.annotate({ description: "The glob pattern to match files against" }),
-  path: Schema.optional(Schema.String).annotate({
-    description: `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.`,
-  }),
-})
-
-export const GlobTool = Tool.define(
-  "glob",
-  Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const ripgrep = yield* Ripgrep.Service
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: { pattern: string; path?: string }, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const ins = yield* InstanceState.context
-          yield* ctx.ask({
-            permission: "glob",
-            patterns: [params.pattern],
-            always: ["*"],
-            metadata: {
-              pattern: params.pattern,
-              path: params.path,
-            },
-          })
-
-          let search = params.path ?? ins.directory
-          search = path.isAbsolute(search) ? search : path.resolve(ins.directory, search)
-          const info = yield* fs.stat(search).pipe(Effect.catch(() => Effect.succeed(undefined)))
-          if (info?.type === "File") {
-            throw new Error(`glob path must be a directory: ${search}`)
-          }
-          yield* assertExternalDirectoryEffect(ctx, search, {
-            bypass: false,
-            kind: "directory",
-          })
-
-          const limit = 100
-          const files = yield* ripgrep.glob({ cwd: search, pattern: params.pattern, limit })
-          const truncated = files.length === limit
-
-          const output = []
-          if (files.length === 0) output.push("No files found")
-          if (files.length > 0) {
-            output.push(...files.map((file) => path.resolve(search, file.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(ins.worktree, search),
-            metadata: {
-              count: files.length,
-              truncated,
-            },
-            output: output.join("\n"),
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/glob.txt

@@ -1,6 +0,0 @@
-- Fast file pattern matching tool that works with any codebase size
-- Supports glob patterns like "**/*.js" or "src/**/*.ts"
-- Returns matching file paths
-- 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

@@ -1,112 +0,0 @@
-import path from "path"
-import { Effect, Schema } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { FSUtil } from "@miaw/core/fs-util"
-import { Ripgrep } from "@miaw/core/ripgrep"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import DESCRIPTION from "./grep.txt"
-import * as Tool from "./tool"
-
-export const Parameters = Schema.Struct({
-  pattern: Schema.String.annotate({ description: "The regex pattern to search for in file contents" }),
-  path: Schema.optional(Schema.String).annotate({
-    description: "The directory to search in. Defaults to the current working directory.",
-  }),
-  include: Schema.optional(Schema.String).annotate({
-    description: 'File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")',
-  }),
-})
-
-export const GrepTool = Tool.define(
-  "grep",
-  Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const ripgrep = yield* Ripgrep.Service
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: { pattern: string; path?: string; include?: string }, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const empty = {
-            title: params.pattern,
-            metadata: { matches: 0, truncated: false },
-            output: "No files found",
-          }
-          if (!params.pattern) {
-            throw new Error("pattern is required")
-          }
-
-          yield* ctx.ask({
-            permission: "grep",
-            patterns: [params.pattern],
-            always: ["*"],
-            metadata: {
-              pattern: params.pattern,
-              path: params.path,
-              include: params.include,
-            },
-          })
-
-          const ins = yield* InstanceState.context
-          const requested = path.isAbsolute(params.path ?? ins.directory)
-            ? (params.path ?? ins.directory)
-            : path.join(ins.directory, params.path ?? ".")
-          const requestedInfo = yield* fs.stat(requested).pipe(Effect.catch(() => Effect.succeed(undefined)))
-          yield* assertExternalDirectoryEffect(ctx, requested, {
-            bypass: false,
-            kind: requestedInfo?.type === "Directory" ? "directory" : "file",
-          })
-
-          const search = FSUtil.resolve(requested)
-          const info = yield* fs.stat(search).pipe(Effect.catch(() => Effect.succeed(undefined)))
-          const cwd = info?.type === "Directory" ? search : path.dirname(search)
-          const result = yield* ripgrep.grep({
-            cwd,
-            pattern: params.pattern,
-            include: params.include,
-            limit: 100,
-          })
-          if (result.length === 0) return empty
-
-          const rows = result.map((item) => ({
-            path: path.resolve(cwd, item.entry.path),
-            line: item.line,
-            text: item.text,
-          }))
-
-          const limit = 100
-          const truncated = rows.length === limit
-          const final = rows
-          if (final.length === 0) return empty
-
-          const total = rows.length
-          const hasMore = truncated || result.length === limit
-          const output = [`Found ${total} matches${hasMore ? " (more matches available)" : ""}`]
-
-          let current = ""
-          for (const match of final) {
-            if (current !== match.path) {
-              if (current !== "") output.push("")
-              current = match.path
-              output.push(`${match.path}:`)
-            }
-            output.push(`  Line ${match.line}: ${match.text}`)
-          }
-
-          if (truncated) {
-            output.push("")
-            output.push("(Results truncated. Consider using a more specific path or pattern.)")
-          }
-
-          return {
-            title: params.pattern,
-            metadata: {
-              matches: total,
-              truncated,
-            },
-            output: output.join("\n"),
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/grep.txt

@@ -1,8 +0,0 @@
-- 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 matching lines
-- 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

@@ -1,21 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-
-export const Parameters = Schema.Struct({
-  tool: Schema.String,
-  error: Schema.String,
-})
-
-export const InvalidTool = Tool.define(
-  "invalid",
-  Effect.succeed({
-    description: "Do not use",
-    parameters: Parameters,
-    execute: (params: { tool: string; error: string }) =>
-      Effect.succeed({
-        title: "Invalid Tool",
-        output: `The arguments provided to the tool are invalid: ${params.error}`,
-        metadata: {},
-      }),
-  }),
-)

package/src/tool/json-schema.ts

@@ -1,164 +0,0 @@
-import type { JSONSchema7 } from "@ai-sdk/provider"
-import { JsonSchema, Schema } from "effect"
-import type * as Tool from "./tool"
-
-type JsonObject = Record<string, unknown>
-const cache = new WeakMap<Schema.Top, JSONSchema7>()
-
-export function fromSchema(schema: Schema.Top): JSONSchema7 {
-  const cached = cache.get(schema)
-  if (cached) return cached
-
-  const document = Schema.toJsonSchemaDocument(schema, { additionalProperties: true })
-  const result = normalize({
-    $schema: JsonSchema.META_SCHEMA_URI_DRAFT_2020_12,
-    ...document.schema,
-    ...(Object.keys(document.definitions).length > 0 ? { $defs: document.definitions } : {}),
-  })
-  const inlined = dropDefinitionsIfResolved(inlineLocalReferences(result))
-  if (!isJsonSchema(inlined)) throw new Error("tool JSON Schema helper produced a non-schema value")
-  cache.set(schema, inlined)
-  return inlined
-}
-
-export function fromTool(tool: Tool.Def): JSONSchema7 {
-  return tool.jsonSchema ?? fromSchema(tool.parameters as Schema.Top)
-}
-
-function normalize(value: unknown, options: { stripNull?: boolean } = {}): unknown {
-  if (Array.isArray(value)) return value.map((item) => normalize(item))
-  if (!isRecord(value)) return value
-
-  const required = Array.isArray(value.required)
-    ? new Set(value.required.filter((item) => typeof item === "string"))
-    : undefined
-  const schema = Object.fromEntries(
-    Object.entries(value).map(([key, item]) => [
-      key,
-      key === "properties" && isRecord(item)
-        ? Object.fromEntries(
-            Object.entries(item).map(([name, property]) => [
-              name,
-              normalize(property, { stripNull: !required?.has(name) }),
-            ]),
-          )
-        : normalize(item),
-    ]),
-  )
-
-  if (schema.additionalProperties === true) delete schema.additionalProperties
-
-  if (options.stripNull && Array.isArray(schema.anyOf)) {
-    const withoutNull = schema.anyOf.filter((item) => !isRecord(item) || item.type !== "null")
-    if (withoutNull.length !== schema.anyOf.length) return normalize({ ...schema, anyOf: withoutNull })
-  }
-
-  if (Array.isArray(schema.anyOf)) {
-    const withoutNull = schema.anyOf
-    const number = withoutNull.find((item) => isRecord(item) && item.type === "number")
-    const nonFinite = withoutNull.filter(
-      (item) => isRecord(item) && Array.isArray(item.enum) && item.enum.every((entry) => isNonFiniteNumber(entry)),
-    )
-    if (number && nonFinite.length === withoutNull.length - 1) {
-      const { anyOf: _, ...rest } = schema
-      return normalize({ ...number, ...rest })
-    }
-
-    if (isEmptyStructUnion(withoutNull)) {
-      const { anyOf: _, ...rest } = schema
-      return normalize({ type: "object", properties: {}, ...rest })
-    }
-
-    if (withoutNull.length === 1 && isRecord(withoutNull[0])) {
-      const { anyOf: _, ...rest } = schema
-      return normalize({ ...withoutNull[0], ...rest })
-    }
-  }
-
-  if (Array.isArray(schema.allOf) && schema.allOf.every(isRecord) && canFlattenAllOf(schema.allOf, schema)) {
-    const { allOf, ...rest } = schema
-    return normalize({ ...Object.assign({}, ...allOf), ...rest })
-  }
-
-  if (schema.type === "integer" && schema.maximum === undefined) {
-    return { minimum: Number.MIN_SAFE_INTEGER, ...schema, maximum: Number.MAX_SAFE_INTEGER }
-  }
-
-  return schema
-}
-
-function isRecord(value: unknown): value is JsonObject {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function isJsonSchema(value: unknown): value is JSONSchema7 {
-  return typeof value === "boolean" || isRecord(value)
-}
-
-function isNonFiniteNumber(value: unknown) {
-  return value === "NaN" || value === "Infinity" || value === "-Infinity"
-}
-
-function isEmptyStructUnion(items: unknown[]) {
-  return (
-    items.length === 2 &&
-    items.some((item) => isRecord(item) && item.type === "object" && item.properties === undefined) &&
-    items.some((item) => isRecord(item) && item.type === "array" && item.items === undefined)
-  )
-}
-
-function canFlattenAllOf(allOf: JsonObject[], parent: JsonObject) {
-  const keys = new Set(Object.keys(parent).filter((key) => key !== "allOf"))
-  return allOf.every((item) =>
-    Object.keys(item).every((key) => {
-      if (keys.has(key)) return false
-      keys.add(key)
-      return true
-    }),
-  )
-}
-
-function inlineLocalReferences(value: unknown, definitions?: JsonObject, seen = new Set<string>()): unknown {
-  if (Array.isArray(value)) return value.map((item) => inlineLocalReferences(item, definitions, seen))
-  if (!isRecord(value)) return value
-
-  const localDefinitions = definitions ?? (isRecord(value.$defs) ? value.$defs : undefined)
-  if (typeof value.$ref === "string" && localDefinitions) {
-    const name = value.$ref.match(/^#\/\$defs\/(.+)$/)?.[1] ?? value.$ref.match(/^#\/definitions\/(.+)$/)?.[1]
-    if (name && !seen.has(name)) {
-      const target = localDefinitions[name]
-      if (target) {
-        const { $ref: _, ...rest } = value
-        return inlineLocalReferences(
-          { ...(isRecord(target) ? target : {}), ...rest },
-          localDefinitions,
-          new Set(seen).add(name),
-        )
-      }
-    }
-  }
-
-  return Object.fromEntries(
-    Object.entries(value).map(([key, item]) => [key, inlineLocalReferences(item, localDefinitions, seen)]),
-  )
-}
-
-function dropDefinitionsIfResolved(value: unknown): unknown {
-  if (!isRecord(value) || hasLocalReference(value)) return value
-  const { $defs: _, definitions: __, ...rest } = value
-  return rest
-}
-
-function hasLocalReference(value: unknown): boolean {
-  if (Array.isArray(value)) return value.some(hasLocalReference)
-  if (!isRecord(value)) return false
-  if (
-    typeof value.$ref === "string" &&
-    (value.$ref.startsWith("#/$defs/") || value.$ref.startsWith("#/definitions/"))
-  ) {
-    return true
-  }
-  return Object.values(value).some(hasLocalReference)
-}
-
-export * as ToolJsonSchema from "./json-schema"

package/src/tool/lsp.ts

@@ -1,113 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import path from "path"
-import { LSP } from "@/lsp/lsp"
-import DESCRIPTION from "./lsp.txt"
-import { InstanceState } from "@/effect/instance-state"
-import { pathToFileURL } from "url"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import { FSUtil } from "@miaw/core/fs-util"
-
-const operations = [
-  "goToDefinition",
-  "findReferences",
-  "hover",
-  "documentSymbol",
-  "workspaceSymbol",
-  "goToImplementation",
-  "prepareCallHierarchy",
-  "incomingCalls",
-  "outgoingCalls",
-] as const
-
-export const Parameters = Schema.Struct({
-  operation: Schema.Literals(operations).annotate({ description: "The LSP operation to perform" }),
-  filePath: Schema.String.annotate({ description: "The absolute or relative path to the file" }),
-  line: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).annotate({
-    description: "The line number (1-based, as shown in editors)",
-  }),
-  character: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).annotate({
-    description: "The character offset (1-based, as shown in editors)",
-  }),
-  query: Schema.optional(Schema.String).annotate({
-    description: "Search query for workspaceSymbol. Empty string requests all symbols.",
-  }),
-})
-
-export const LspTool = Tool.define(
-  "lsp",
-  Effect.gen(function* () {
-    const lsp = yield* LSP.Service
-    const fs = yield* FSUtil.Service
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (args: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const instance = yield* InstanceState.context
-          const file = path.isAbsolute(args.filePath) ? args.filePath : path.join(instance.directory, args.filePath)
-          yield* assertExternalDirectoryEffect(ctx, file)
-          const meta =
-            args.operation === "workspaceSymbol"
-              ? { operation: args.operation }
-              : args.operation === "documentSymbol"
-                ? { operation: args.operation, filePath: file }
-                : { operation: args.operation, filePath: file, line: args.line, character: args.character }
-          yield* ctx.ask({
-            permission: "lsp",
-            patterns: ["*"],
-            always: ["*"],
-            metadata: meta,
-          })
-
-          const uri = pathToFileURL(file).href
-          const position = { file, line: args.line - 1, character: args.character - 1 }
-          const relPath = path.relative(instance.worktree, file)
-          const detail =
-            args.operation === "workspaceSymbol"
-              ? ""
-              : args.operation === "documentSymbol"
-                ? relPath
-                : `${relPath}:${args.line}:${args.character}`
-          const title = detail ? `${args.operation} ${detail}` : args.operation
-
-          const exists = yield* fs.existsSafe(file)
-          if (!exists) throw new Error(`File not found: ${file}`)
-
-          const available = yield* lsp.hasClients(file)
-          if (!available) throw new Error("No LSP server available for this file type.")
-
-          yield* lsp.touchFile(file, "document")
-
-          const result: unknown[] = yield* (() => {
-            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(args.query ?? "")
-              case "goToImplementation":
-                return lsp.implementation(position)
-              case "prepareCallHierarchy":
-                return lsp.prepareCallHierarchy(position)
-              case "incomingCalls":
-                return lsp.incomingCalls(position)
-              case "outgoingCalls":
-                return lsp.outgoingCalls(position)
-            }
-          })()
-
-          return {
-            title,
-            metadata: { result },
-            output: result.length === 0 ? `No results found for ${args.operation}` : JSON.stringify(result, null, 2),
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/lsp.txt

@@ -1,24 +0,0 @@
-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: List project-wide symbols matching a query string
-- 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)
-
-workspaceSymbol also accepts:
-- query: A query string to filter symbols by. Empty string requests all symbols.
-
-For workspaceSymbol, filePath is not sent in the LSP workspace/symbol request. It is used by miaw to select and start the matching LSP server.
-
-Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.