@vikasitai/vikasit-code 2.0.4 → 2.0.5

package/src/tool/worktree-enter.ts

@@ -0,0 +1,38 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./worktree-enter.txt"
+import z from "zod"
+import { Worktree } from "../worktree"
+
+export const WorktreeEnterTool = Tool.define("worktree_enter", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    name: z.string().optional().describe("Name for the worktree branch. Auto-generated if omitted."),
+    start_command: z
+      .string()
+      .optional()
+      .describe("Additional startup script to run after the project's start command"),
+  }),
+  async execute(params, ctx) {
+    const info = await Worktree.create({
+      name: params.name,
+      startCommand: params.start_command,
+    })
+
+    return {
+      title: `Created worktree: ${info.name}`,
+      metadata: {
+        worktreeName: info.name,
+        worktreeBranch: info.branch,
+        worktreeDirectory: info.directory,
+      },
+      output: [
+        `Worktree created successfully.`,
+        `  Name: ${info.name}`,
+        `  Branch: ${info.branch}`,
+        `  Directory: ${info.directory}`,
+        ``,
+        `You are now working in an isolated worktree. Use worktree_exit when done.`,
+      ].join("\n"),
+    }
+  },
+})

package/src/tool/worktree-enter.txt

@@ -0,0 +1,8 @@
+Create an isolated git worktree for parallel work. The worktree gives you a separate copy of the repository on a new branch, so you can make changes without affecting the main working directory.
+
+Use this when:
+- You need to work on multiple tasks in parallel
+- You want to isolate experimental changes
+- A subagent needs its own branch to work on
+
+The worktree will be created in .vikasit/worktrees/ with its own branch. Use ExitWorktree when done.

package/src/tool/worktree-exit.ts

@@ -0,0 +1,43 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./worktree-exit.txt"
+import z from "zod"
+import { Worktree } from "../worktree"
+
+export const WorktreeExitTool = Tool.define("worktree_exit", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    directory: z.string().describe("The directory path of the worktree to exit (returned by worktree_enter)"),
+    keep: z
+      .boolean()
+      .default(false)
+      .optional()
+      .describe("Keep the worktree on disk (true) or remove it (false)"),
+  }),
+  async execute(params, ctx) {
+    if (params.keep) {
+      return {
+        title: `Kept worktree: ${params.directory}`,
+        metadata: { directory: params.directory, action: "keep" },
+        output: `Worktree "${params.directory}" kept on disk. You can return to it later.`,
+      }
+    }
+
+    const removed = await Worktree.remove({
+      directory: params.directory,
+    })
+
+    if (!removed) {
+      return {
+        title: `Failed to remove worktree`,
+        metadata: { directory: params.directory, action: "remove_failed" },
+        output: `Could not remove worktree "${params.directory}". It may have uncommitted changes.`,
+      }
+    }
+
+    return {
+      title: `Removed worktree: ${params.directory}`,
+      metadata: { directory: params.directory, action: "remove" },
+      output: `Worktree "${params.directory}" has been removed. Returned to main working directory.`,
+    }
+  },
+})

package/src/tool/worktree-exit.txt

@@ -0,0 +1,3 @@
+Exit a git worktree by its directory path (returned by worktree_enter). You can choose to keep the worktree on disk or remove it.
+
+Use this after finishing work in an isolated worktree to return to the main working directory.

package/src/tool/write.ts

@@ -0,0 +1,84 @@
+import z from "zod"
+import * as path from "path"
+import { Tool } from "./tool"
+import { LSP } from "../lsp"
+import { createTwoFilesPatch } from "diff"
+import DESCRIPTION from "./write.txt"
+import { Bus } from "../bus"
+import { File } from "../file"
+import { FileWatcher } from "../file/watcher"
+import { Format } from "../format"
+import { FileTime } from "../file/time"
+import { Filesystem } from "../util/filesystem"
+import { Instance } from "../project/instance"
+import { trimDiff } from "./edit"
+import { assertExternalDirectory } from "./external-directory"
+
+const MAX_DIAGNOSTICS_PER_FILE = 20
+const MAX_PROJECT_DIAGNOSTICS_FILES = 5
+
+export const WriteTool = Tool.define("write", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    content: z.string().describe("The content to write to the file"),
+    filePath: z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+  }),
+  async execute(params, ctx) {
+    const filepath = path.isAbsolute(params.filePath) ? params.filePath : path.join(Instance.directory, params.filePath)
+    await assertExternalDirectory(ctx, filepath)
+
+    const exists = await Filesystem.exists(filepath)
+    const contentOld = exists ? await Filesystem.readText(filepath) : ""
+    if (exists) await FileTime.assert(ctx.sessionID, filepath)
+
+    const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, params.content))
+    await ctx.ask({
+      permission: "edit",
+      patterns: [path.relative(Instance.worktree, filepath)],
+      always: ["*"],
+      metadata: {
+        filepath,
+        diff,
+      },
+    })
+
+    await Filesystem.write(filepath, params.content)
+    await Format.file(filepath)
+    Bus.publish(File.Event.Edited, { file: filepath })
+    await Bus.publish(FileWatcher.Event.Updated, {
+      file: filepath,
+      event: exists ? "change" : "add",
+    })
+    await FileTime.read(ctx.sessionID, filepath)
+
+    let output = "Wrote file successfully."
+    await LSP.touchFile(filepath, true)
+    const diagnostics = await LSP.diagnostics()
+    const normalizedFilepath = Filesystem.normalizePath(filepath)
+    let projectDiagnosticsCount = 0
+    for (const [file, issues] of Object.entries(diagnostics)) {
+      const errors = issues.filter((item) => item.severity === 1)
+      if (errors.length === 0) continue
+      const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE)
+      const suffix =
+        errors.length > MAX_DIAGNOSTICS_PER_FILE ? `\n... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE} more` : ""
+      if (file === normalizedFilepath) {
+        output += `\n\nLSP errors detected in this file, please fix:\n<diagnostics file="${filepath}">\n${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}\n</diagnostics>`
+        continue
+      }
+      if (projectDiagnosticsCount >= MAX_PROJECT_DIAGNOSTICS_FILES) continue
+      projectDiagnosticsCount++
+      output += `\n\nLSP errors detected in other files:\n<diagnostics file="${file}">\n${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}\n</diagnostics>`
+    }
+
+    return {
+      title: path.relative(Instance.worktree, filepath),
+      metadata: {
+        diagnostics,
+        filepath,
+        exists: exists,
+      },
+      output,
+    }
+  },
+})

package/src/tool/write.txt

@@ -0,0 +1,8 @@
+Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.

package/src/util/abort.ts

@@ -0,0 +1,35 @@
+/**
+ * Creates an AbortController that automatically aborts after a timeout.
+ *
+ * Uses bind() instead of arrow functions to avoid capturing the surrounding
+ * scope in closures. Arrow functions like `() => controller.abort()` capture
+ * request bodies and other large objects, preventing GC for the timer lifetime.
+ *
+ * @param ms Timeout in milliseconds
+ * @returns Object with controller, signal, and clearTimeout function
+ */
+export function abortAfter(ms: number) {
+  const controller = new AbortController()
+  const id = setTimeout(controller.abort.bind(controller), ms)
+  return {
+    controller,
+    signal: controller.signal,
+    clearTimeout: () => globalThis.clearTimeout(id),
+  }
+}
+
+/**
+ * Combines multiple AbortSignals with a timeout.
+ *
+ * @param ms Timeout in milliseconds
+ * @param signals Additional signals to combine
+ * @returns Combined signal that aborts on timeout or when any input signal aborts
+ */
+export function abortAfterAny(ms: number, ...signals: AbortSignal[]) {
+  const timeout = abortAfter(ms)
+  const signal = AbortSignal.any([timeout.signal, ...signals])
+  return {
+    signal,
+    clearTimeout: timeout.clearTimeout,
+  }
+}

package/src/util/archive.ts

@@ -0,0 +1,17 @@
+import path from "path"
+import { Process } from "./process"
+
+export namespace Archive {
+  export async function extractZip(zipPath: string, destDir: string) {
+    if (process.platform === "win32") {
+      const winZipPath = path.resolve(zipPath)
+      const winDestDir = path.resolve(destDir)
+      // $global:ProgressPreference suppresses PowerShell's blue progress bar popup
+      const cmd = `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -Path '${winZipPath}' -DestinationPath '${winDestDir}' -Force`
+      await Process.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd])
+      return
+    }
+
+    await Process.run(["unzip", "-o", "-q", zipPath, "-d", destDir])
+  }
+}

package/src/util/color.ts

@@ -0,0 +1,19 @@
+export namespace Color {
+  export function isValidHex(hex?: string): hex is string {
+    if (!hex) return false
+    return /^#[0-9a-fA-F]{6}$/.test(hex)
+  }
+
+  export function hexToRgb(hex: string): { r: number; g: number; b: number } {
+    const r = parseInt(hex.slice(1, 3), 16)
+    const g = parseInt(hex.slice(3, 5), 16)
+    const b = parseInt(hex.slice(5, 7), 16)
+    return { r, g, b }
+  }
+
+  export function hexToAnsiBold(hex?: string): string | undefined {
+    if (!isValidHex(hex)) return undefined
+    const { r, g, b } = hexToRgb(hex)
+    return `\x1b[38;2;${r};${g};${b}m\x1b[1m`
+  }
+}

package/src/util/context.ts

@@ -0,0 +1,25 @@
+import { AsyncLocalStorage } from "async_hooks"
+
+export namespace Context {
+  export class NotFound extends Error {
+    constructor(public override readonly name: string) {
+      super(`No context found for ${name}`)
+    }
+  }
+
+  export function create<T>(name: string) {
+    const storage = new AsyncLocalStorage<T>()
+    return {
+      use() {
+        const result = storage.getStore()
+        if (!result) {
+          throw new NotFound(name)
+        }
+        return result
+      },
+      provide<R>(value: T, fn: () => R) {
+        return storage.run(value, fn)
+      },
+    }
+  }
+}

package/src/util/data-url.ts

@@ -0,0 +1,9 @@
+export function decodeDataUrl(url: string) {
+  const idx = url.indexOf(",")
+  if (idx === -1) return ""
+
+  const head = url.slice(0, idx)
+  const body = url.slice(idx + 1)
+  if (head.includes(";base64")) return Buffer.from(body, "base64").toString("utf8")
+  return decodeURIComponent(body)
+}

package/src/util/defer.ts

@@ -0,0 +1,12 @@
+export function defer<T extends () => void | Promise<void>>(
+  fn: T,
+): T extends () => Promise<void> ? { [Symbol.asyncDispose]: () => Promise<void> } : { [Symbol.dispose]: () => void } {
+  return {
+    [Symbol.dispose]() {
+      fn()
+    },
+    [Symbol.asyncDispose]() {
+      return Promise.resolve(fn())
+    },
+  } as any
+}

package/src/util/effect-http-client.ts

@@ -0,0 +1,11 @@
+import { Schedule } from "effect"
+import { HttpClient } from "effect/unstable/http"
+
+export const withTransientReadRetry = <E, R>(client: HttpClient.HttpClient.With<E, R>) =>
+  client.pipe(
+    HttpClient.retryTransient({
+      retryOn: "errors-and-responses",
+      times: 2,
+      schedule: Schedule.exponential(200).pipe(Schedule.jittered),
+    }),
+  )

package/src/util/effect-zod.ts

@@ -0,0 +1,98 @@
+import { Schema, SchemaAST } from "effect"
+import z from "zod"
+
+export function zod<S extends Schema.Top>(schema: S): z.ZodType<Schema.Schema.Type<S>> {
+  return walk(schema.ast) as z.ZodType<Schema.Schema.Type<S>>
+}
+
+function walk(ast: SchemaAST.AST): z.ZodTypeAny {
+  const out = body(ast)
+  const desc = SchemaAST.resolveDescription(ast)
+  const ref = SchemaAST.resolveIdentifier(ast)
+  const next = desc ? out.describe(desc) : out
+  return ref ? next.meta({ ref }) : next
+}
+
+function body(ast: SchemaAST.AST): z.ZodTypeAny {
+  if (SchemaAST.isOptional(ast)) return opt(ast)
+
+  switch (ast._tag) {
+    case "String":
+      return z.string()
+    case "Number":
+      return z.number()
+    case "Boolean":
+      return z.boolean()
+    case "Null":
+      return z.null()
+    case "Undefined":
+      return z.undefined()
+    case "Any":
+    case "Unknown":
+      return z.unknown()
+    case "Never":
+      return z.never()
+    case "Literal":
+      return z.literal(ast.literal)
+    case "Union":
+      return union(ast)
+    case "Objects":
+      return object(ast)
+    case "Arrays":
+      return array(ast)
+    case "Declaration":
+      return decl(ast)
+    default:
+      return fail(ast)
+  }
+}
+
+function opt(ast: SchemaAST.AST): z.ZodTypeAny {
+  if (ast._tag !== "Union") return fail(ast)
+  const items = ast.types.filter((item) => item._tag !== "Undefined")
+  if (items.length === 1) return walk(items[0]).optional()
+  if (items.length > 1)
+    return z.union(items.map(walk) as [z.ZodTypeAny, z.ZodTypeAny, ...Array<z.ZodTypeAny>]).optional()
+  return z.undefined().optional()
+}
+
+function union(ast: SchemaAST.Union): z.ZodTypeAny {
+  const items = ast.types.map(walk)
+  if (items.length === 1) return items[0]
+  if (items.length < 2) return fail(ast)
+
+  const discriminator = (ast as any).annotations?.discriminator
+  if (discriminator) {
+    return z.discriminatedUnion(discriminator, items as [z.ZodObject<any>, z.ZodObject<any>, ...z.ZodObject<any>[]])
+  }
+
+  return z.union(items as [z.ZodTypeAny, z.ZodTypeAny, ...Array<z.ZodTypeAny>])
+}
+
+function object(ast: SchemaAST.Objects): z.ZodTypeAny {
+  if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 1) {
+    const sig = ast.indexSignatures[0]
+    if (sig.parameter._tag !== "String") return fail(ast)
+    return z.record(z.string(), walk(sig.type))
+  }
+
+  if (ast.indexSignatures.length > 0) return fail(ast)
+
+  return z.object(Object.fromEntries(ast.propertySignatures.map((sig) => [String(sig.name), walk(sig.type)])))
+}
+
+function array(ast: SchemaAST.Arrays): z.ZodTypeAny {
+  if (ast.elements.length > 0) return fail(ast)
+  if (ast.rest.length !== 1) return fail(ast)
+  return z.array(walk(ast.rest[0]))
+}
+
+function decl(ast: SchemaAST.Declaration): z.ZodTypeAny {
+  if (ast.typeParameters.length !== 1) return fail(ast)
+  return walk(ast.typeParameters[0])
+}
+
+function fail(ast: SchemaAST.AST): never {
+  const ref = SchemaAST.resolveIdentifier(ast)
+  throw new Error(`unsupported effect schema: ${ref ?? ast._tag}`)
+}

package/src/util/error.ts

@@ -0,0 +1,77 @@
+import { isRecord } from "./record"
+
+export function errorFormat(error: unknown): string {
+  if (error instanceof Error) {
+    return error.stack ?? `${error.name}: ${error.message}`
+  }
+
+  if (typeof error === "object" && error !== null) {
+    try {
+      return JSON.stringify(error, null, 2)
+    } catch {
+      return "Unexpected error (unserializable)"
+    }
+  }
+
+  return String(error)
+}
+
+export function errorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    if (error.message) return error.message
+    if (error.name) return error.name
+  }
+
+  if (isRecord(error) && typeof error.message === "string" && error.message) {
+    return error.message
+  }
+
+  const text = String(error)
+  if (text && text !== "[object Object]") return text
+
+  const formatted = errorFormat(error)
+  if (formatted && formatted !== "{}") return formatted
+  return "unknown error"
+}
+
+export function errorData(error: unknown) {
+  if (error instanceof Error) {
+    return {
+      type: error.name,
+      message: errorMessage(error),
+      stack: error.stack,
+      cause: error.cause === undefined ? undefined : errorFormat(error.cause),
+      formatted: errorFormatted(error),
+    }
+  }
+
+  if (!isRecord(error)) {
+    return {
+      type: typeof error,
+      message: errorMessage(error),
+      formatted: errorFormatted(error),
+    }
+  }
+
+  const data = Object.getOwnPropertyNames(error).reduce<Record<string, unknown>>((acc, key) => {
+    const value = error[key]
+    if (value === undefined) return acc
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      acc[key] = value
+      return acc
+    }
+    acc[key] = value instanceof Error ? value.message : String(value)
+    return acc
+  }, {})
+
+  if (typeof data.message !== "string") data.message = errorMessage(error)
+  if (typeof data.type !== "string") data.type = error.constructor?.name
+  data.formatted = errorFormatted(error)
+  return data
+}
+
+function errorFormatted(error: unknown) {
+  const formatted = errorFormat(error)
+  if (formatted !== "{}") return formatted
+  return String(error)
+}