soraacode 0.1.7 → 0.2.1

package/src/tool/edit.txt

@@ -1,13 +0,0 @@
-Exact string replacement.
-
-Read the file first.
-
-Preserve indentation after line number prefix.
-
-Prefer editing existing files. Do not create new files unless required.
-
-Emojis only if explicitly requested.
-
-Fails if oldString is absent or matches multiple locations. Add context or use replaceAll.
-
-Use replaceAll for file-wide renames.

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 "@soraacode/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 "@soraacode/core/fs-util"
-import { Ripgrep } from "@soraacode/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,7 +0,0 @@
-Fast filename/pattern search for any codebase. Supports patterns such as **/*.js, src/**/*.ts.
-
-Use for locating files by name.
-
-For open-ended multi-round searching, use task.
-
-Batch speculative searches when useful.

package/src/tool/grep.ts

@@ -1,115 +0,0 @@
-import path from "path"
-import { Effect, Schema } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { FSUtil } from "@soraacode/core/fs-util"
-import { Ripgrep } from "@soraacode/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(
-              requestedInfo?.type === "Directory" ? requested : path.dirname(requested),
-              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,7 +0,0 @@
-Fast regex content search. Supports regex and include patterns such as *.js, *.{ts,tsx}.
-
-Returns matching paths and line numbers.
-
-For counting matches, use Bash + rg, not grep.
-
-Use task for open-ended multi-round searches.

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 "@soraacode/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 +0,0 @@
-Code intelligence via LSP: goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, prepareCallHierarchy, incomingCalls, outgoingCalls. All require filePath, 1-based line, and 1-based character. workspaceSymbol also accepts query. LSP must be configured for the file type.

package/src/tool/mcp-websearch.ts

@@ -1,96 +0,0 @@
-import { Duration, Effect, Schema } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
-
-export const EXA_URL = process.env.EXA_API_KEY
-  ? `https://mcp.exa.ai/mcp?exaApiKey=${encodeURIComponent(process.env.EXA_API_KEY)}`
-  : "https://mcp.exa.ai/mcp"
-export const PARALLEL_URL = "https://search.parallel.ai/mcp"
-
-const McpResult = Schema.Struct({
-  result: Schema.Struct({
-    content: Schema.Array(
-      Schema.Struct({
-        type: Schema.String,
-        text: Schema.String,
-      }),
-    ),
-  }),
-})
-
-const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(McpResult))
-
-const parsePayload = (payload: string) =>
-  Effect.gen(function* () {
-    const trimmed = payload.trim()
-    if (!trimmed.startsWith("{")) return undefined
-    const data = yield* decode(trimmed)
-    return data.result.content.find((item) => item.text)?.text
-  })
-
-export const parseResponse = Effect.fn("McpWebSearch.parseResponse")(function* (body: string) {
-  const trimmed = body.trim()
-  const direct = trimmed ? yield* parsePayload(trimmed) : undefined
-  if (direct) return direct
-
-  for (const line of body.split("\n")) {
-    if (!line.startsWith("data: ")) continue
-    const data = yield* parsePayload(line.substring(6))
-    if (data) return data
-  }
-  return undefined
-})
-
-export const SearchArgs = Schema.Struct({
-  query: Schema.String,
-  type: Schema.String,
-  numResults: Schema.Number,
-  livecrawl: Schema.String,
-  contextMaxCharacters: Schema.optional(Schema.Number),
-})
-
-export const ParallelSearchArgs = Schema.Struct({
-  objective: Schema.String,
-  search_queries: Schema.Array(Schema.String),
-  session_id: Schema.optional(Schema.String),
-  model_name: Schema.optional(Schema.String),
-})
-
-const McpRequest = <F extends Schema.Struct.Fields>(args: Schema.Struct<F>) =>
-  Schema.Struct({
-    jsonrpc: Schema.Literal("2.0"),
-    id: Schema.Literal(1),
-    method: Schema.Literal("tools/call"),
-    params: Schema.Struct({
-      name: Schema.String,
-      arguments: args,
-    }),
-  })
-
-export const call = <F extends Schema.Struct.Fields>(
-  http: HttpClient.HttpClient,
-  url: string,
-  tool: string,
-  args: Schema.Struct<F>,
-  value: Schema.Struct.Type<F>,
-  timeout: Duration.Input,
-  headers?: Record<string, string>,
-) =>
-  Effect.gen(function* () {
-    const request = yield* HttpClientRequest.post(url).pipe(
-      HttpClientRequest.accept("application/json, text/event-stream"),
-      HttpClientRequest.setHeaders(headers ?? {}),
-      HttpClientRequest.schemaBodyJson(McpRequest(args))({
-        jsonrpc: "2.0" as const,
-        id: 1 as const,
-        method: "tools/call" as const,
-        params: { name: tool, arguments: value },
-      }),
-    )
-    const response = yield* HttpClient.filterStatusOk(http)
-      .execute(request)
-      .pipe(
-        Effect.timeoutOrElse({ duration: timeout, orElse: () => Effect.die(new Error(`${tool} request timed out`)) }),
-      )
-    const body = yield* response.text
-    return yield* parseResponse(body)
-  })

package/src/tool/plan-enter.txt

@@ -1 +0,0 @@
-Suggest switching to a plan agent before implementation. Use for complex tasks, research/design, multi-file work, or major architecture decisions. If the user explicitly requests a plan, always call first. Do not use for simple tasks or when immediate implementation is explicitly requested.

package/src/tool/plan-exit.txt

@@ -1 +0,0 @@
-Use after the plan is complete and questions are resolved. Prompts the user to switch from planning to implementation. Do not use while planning is incomplete or questions remain.