glitchcode-cli 0.1.1

package/src/tool/websearch/mimo.ts

@@ -0,0 +1,118 @@
+import { Duration, Effect, Schema, Stream } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+
+const DEFAULT_BASE_URL = "https://api.xiaomimimo.com/v1"
+
+export const QUOTA_EXCEEDED =
+  "Web search quota exhausted (free tier limit reached). Top up or manage your plan at https://platform.xiaomimimo.com/console/plugin, or use `webfetch` with a relevant URL instead."
+
+const Annotation = Schema.Struct({
+  type: Schema.optional(Schema.NullOr(Schema.String)),
+  url: Schema.optional(Schema.NullOr(Schema.String)),
+  title: Schema.optional(Schema.NullOr(Schema.String)),
+  summary: Schema.optional(Schema.NullOr(Schema.String)),
+  site_name: Schema.optional(Schema.NullOr(Schema.String)),
+  publish_time: Schema.optional(Schema.NullOr(Schema.String)),
+})
+type Annotation = Schema.Schema.Type<typeof Annotation>
+
+const Annotations = Schema.Array(Annotation)
+
+const Frame = Schema.Struct({
+  choices: Schema.optional(
+    Schema.Array(
+      Schema.Struct({
+        delta: Schema.optional(
+          Schema.NullOr(
+            Schema.Struct({
+              annotations: Schema.optional(Schema.NullOr(Annotations)),
+            }),
+          ),
+        ),
+        message: Schema.optional(
+          Schema.NullOr(
+            Schema.Struct({
+              annotations: Schema.optional(Schema.NullOr(Annotations)),
+            }),
+          ),
+        ),
+      }),
+    ),
+  ),
+})
+
+const decodeFrame = Schema.decodeUnknownEffect(Schema.fromJsonString(Frame))
+
+function buildUrl(baseUrl: string) {
+  const base = (baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "")
+  if (base.endsWith("/chat/completions")) return base
+  return (base.endsWith("/v1") ? base : `${base}/v1`) + "/chat/completions"
+}
+
+function formatSources(annotations: ReadonlyArray<Annotation>) {
+  const lines = annotations.flatMap((a) => {
+    if (!a.url) return []
+    const head = [a.title, a.site_name, a.publish_time].filter(Boolean).join(" · ")
+    return [`- ${head || a.url}`, `  ${a.url}`, ...(a.summary ? [`  ${a.summary}`] : [])]
+  })
+  return lines.length > 0 ? ["Sources:", ...lines].join("\n") : undefined
+}
+
+function extractAnnotations(line: string): Effect.Effect<ReadonlyArray<Annotation> | undefined> {
+  if (!line.startsWith("data:")) return Effect.succeed(undefined)
+  const payload = line.slice(5).trim()
+  if (!payload || payload === "[DONE]") return Effect.succeed(undefined)
+  return decodeFrame(payload).pipe(
+    Effect.map((frame) => {
+      const choice = frame.choices?.[0]
+      const list = choice?.delta?.annotations ?? choice?.message?.annotations
+      return list && list.length > 0 ? list : undefined
+    }),
+    Effect.orElseSucceed(() => undefined),
+  )
+}
+
+export const call = (
+  http: HttpClient.HttpClient,
+  baseUrl: string,
+  apiKey: string,
+  query: string,
+  modelId: string,
+  timeout: Duration.Input,
+) =>
+  Effect.gen(function* () {
+    const request = HttpClientRequest.post(buildUrl(baseUrl)).pipe(
+      HttpClientRequest.setHeader("api-key", apiKey),
+      HttpClientRequest.accept("text/event-stream"),
+      HttpClientRequest.bodyJsonUnsafe({
+        model: modelId,
+        messages: [{ role: "user", content: query }],
+        tools: [{ type: "web_search", max_keyword: 3, force_search: true, limit: 5 }],
+        max_completion_tokens: 256,
+        temperature: 1.0,
+        top_p: 0.95,
+        stream: true,
+        thinking: { type: "disabled" },
+      }),
+    )
+
+    const annotations = yield* HttpClientResponse.stream(HttpClient.filterStatusOk(http).execute(request)).pipe(
+      Stream.decodeText(),
+      Stream.splitLines,
+      Stream.mapEffect(extractAnnotations),
+      Stream.filter((value): value is ReadonlyArray<Annotation> => value !== undefined),
+      Stream.runHead,
+      Effect.catchIf(
+        (err) => err.reason._tag === "StatusCodeError" && err.reason.response.status === 409,
+        () => Effect.succeed(QUOTA_EXCEEDED),
+      ),
+      Effect.timeoutOrElse({
+        duration: timeout,
+        orElse: () => Effect.die(new Error("xiaomi web_search request timed out")),
+      }),
+    )
+
+    if (typeof annotations === "string") return annotations
+    if (annotations._tag === "None") return undefined
+    return formatSources(annotations.value)
+  })

package/src/tool/websearch/websearch.txt

@@ -0,0 +1,14 @@
+- Search the web - performs real-time web searches and can scrape content from specific URLs
+- Provides up-to-date information for current events and recent data
+- Supports configurable result counts and returns the content from the most relevant websites
+- Use this tool for accessing information beyond knowledge cutoff
+- Searches are performed automatically within a single API call
+
+Usage notes:
+  - Supports live crawling modes: 'fallback' (backup if cached unavailable) or 'preferred' (prioritize live crawling)
+  - Search types: 'auto' (balanced), 'fast' (quick results), 'deep' (comprehensive search)
+  - Configurable context length for optimal LLM integration
+  - Domain filtering and advanced search options available
+
+The current year is {{year}}. You MUST use this year when searching for recent information or current events
+- Example: If the current year is 2026 and the user asks for "latest AI news", search for "AI news 2026", NOT "AI news 2025"

package/src/tool/workflow.ts

@@ -0,0 +1,164 @@
+import * as Tool from "./tool"
+import DESCRIPTION from "./workflow.txt"
+import z from "zod"
+import { Effect } from "effect"
+import { Config } from "../config"
+import { workflowRef } from "@/workflow/runtime-ref"
+import { BuiltinWorkflow } from "@/workflow/builtin"
+import type { SessionID } from "../session/schema"
+
+const id = "workflow"
+
+const runSchema = z.strictObject({
+  operation: z.literal("run"),
+  name: z
+    .string()
+    .min(1)
+    .optional()
+    .describe(
+      '(optional) Name of a built-in workflow to run (e.g. "deep-research"). Provide EITHER name OR script, not both.',
+    ),
+  script: z
+    .string()
+    .min(1)
+    .optional()
+    .describe(
+      "(optional) Inline JS workflow script; must begin with `export const meta = {...}`. Provide EITHER name OR script, not both.",
+    ),
+  args: z.any().optional().describe("(optional) JSON value exposed to the script as `args`."),
+  workspace: z
+    .string()
+    .optional()
+    .describe(
+      "(optional) Absolute dir the script's file primitives (readFile/writeFile/glob/exists) are jailed to. Defaults to the project worktree.",
+    ),
+})
+const statusSchema = z.strictObject({ operation: z.literal("status"), run_id: z.string().min(1) })
+const waitSchema = z.strictObject({
+  operation: z.literal("wait"),
+  run_id: z.string().min(1),
+  timeout_ms: z.number().int().positive().optional(),
+})
+const cancelSchema = z.strictObject({ operation: z.literal("cancel"), run_id: z.string().min(1) })
+const resumeSchema = z.strictObject({ operation: z.literal("resume"), run_id: z.string().min(1) })
+
+export const parameters = z.discriminatedUnion("operation", [
+  runSchema,
+  statusSchema,
+  waitSchema,
+  cancelSchema,
+  resumeSchema,
+])
+
+type Metadata = { runID?: string; status?: string }
+
+export const WorkflowTool = Tool.define<typeof parameters, Metadata, Config.Service>(
+  id,
+  Effect.gen(function* () {
+    const config = yield* Config.Service
+
+    // Resolve the WorkflowRuntime through the late-bound workflowRef rather than as
+    // a Layer dependency: pulling WorkflowRuntime.Service in here would push that
+    // requirement onto ToolRegistry.layer, forcing every layer that builds the
+    // registry to provide it. The ref is populated by WorkflowRuntime.layer's
+    // initialiser (see workflow/runtime-ref.ts) — mirrors the actor tool's spawnRef.
+    const requireRuntime = () => {
+      const runtime = workflowRef.current
+      if (!runtime) {
+        return Effect.fail(
+          new Error(
+            "Workflow runtime unavailable — WorkflowRuntime.defaultLayer must be running for the workflow tool",
+          ),
+        )
+      }
+      return Effect.succeed(runtime)
+    }
+
+    const run = Effect.fn("WorkflowTool.execute")(function* (
+      input: z.infer<typeof parameters>,
+      ctx: Tool.Context<Metadata>,
+    ) {
+      const runtime = yield* requireRuntime()
+
+      if (input.operation === "run") {
+        const cfg = yield* config.get()
+        // The schema keeps both `name` and `script` optional; enforce the xor
+        // here. Both-provided is a caller mistake (the schema docstring says
+        // "EITHER name OR script, not both") — fail loudly rather than silently
+        // picking one. Effect.orDie surfaces it to the model.
+        if (input.name && input.script) {
+          return yield* Effect.fail(
+            new Error("workflow run: provide either `name` (a built-in) or `script` (inline), not both."),
+          )
+        }
+        const script = input.name ? BuiltinWorkflow.get(input.name)?.script : input.script
+        if (!script) {
+          const known = BuiltinWorkflow.list()
+            .map((w) => w.name)
+            .join(", ")
+          return yield* Effect.fail(
+            new Error(
+              input.name
+                ? `Unknown built-in workflow "${input.name}". Known: ${known || "(none)"}.`
+                : "workflow run requires either `name` (a built-in) or `script` (inline).",
+            ),
+          )
+        }
+        const started = yield* runtime.start({
+          script,
+          sessionID: ctx.sessionID as SessionID,
+          parentActorID: ctx.agent ?? "main",
+          args: input.args,
+          workspace: input.workspace,
+          maxConcurrentAgents: cfg.workflow?.maxConcurrentAgents,
+          scriptDeadlineMs: cfg.workflow?.scriptDeadlineMs,
+        })
+        return {
+          title: "workflow started",
+          output: `Workflow started. run_id: ${started.runID}\nThe result will be delivered as a notification when complete.`,
+          metadata: { runID: started.runID } satisfies Metadata,
+        }
+      }
+      if (input.operation === "status") {
+        const snapshot = yield* runtime.status({ runID: input.run_id })
+        return {
+          title: `workflow ${snapshot.status}`,
+          output: JSON.stringify(snapshot),
+          metadata: { runID: input.run_id, status: snapshot.status } satisfies Metadata,
+        }
+      }
+      if (input.operation === "wait") {
+        const outcome = yield* runtime.wait({ runID: input.run_id, timeoutMs: input.timeout_ms })
+        return {
+          title: `workflow ${outcome.status}`,
+          output: JSON.stringify(outcome),
+          metadata: { runID: input.run_id, status: outcome.status } satisfies Metadata,
+        }
+      }
+      if (input.operation === "cancel") {
+        yield* runtime.cancel({ runID: input.run_id })
+        return {
+          title: "workflow cancelled",
+          output: `Cancelled ${input.run_id}`,
+          metadata: { runID: input.run_id, status: "cancelled" } satisfies Metadata,
+        }
+      }
+      if (input.operation === "resume") {
+        const resumed = yield* runtime.resume({ runID: input.run_id })
+        return {
+          title: resumed.resumed ? "workflow resumed" : "workflow not resumable",
+          output: JSON.stringify(resumed),
+          metadata: { runID: input.run_id } satisfies Metadata,
+        }
+      }
+      input satisfies never
+      throw new Error(`unhandled workflow operation: ${(input as { operation: string }).operation}`)
+    })
+
+    return {
+      description: DESCRIPTION,
+      parameters,
+      execute: (input: z.infer<typeof parameters>, ctx: Tool.Context<Metadata>) => run(input, ctx).pipe(Effect.orDie),
+    } satisfies Tool.DefWithoutID<typeof parameters, Metadata>
+  }),
+)

package/src/tool/workflow.txt

@@ -0,0 +1,25 @@
+Execute a workflow script that orchestrates multiple subagents deterministically. The script is plain JavaScript that runs in a sandbox and fans out subagents via agent(), parallel(), and pipeline(). This tool returns immediately with a run_id and runs in the background; the result is delivered as a notification when the workflow completes.
+
+operation "run": start a workflow. Provide either `name` (a built-in workflow, see the catalog below) or `script` (inline JS; must begin with `export const meta = { name, description }`). Returns a run_id immediately. Optionally provide `workspace` (a dir the script's file primitives are jailed to; defaults to the worktree).
+operation "status": check a run's status by run_id.
+operation "wait": block until a run completes (or times out), returning its result.
+operation "cancel": cancel a running workflow by run_id (best-effort; in-flight subagents stop at their next safe point, not instantly).
+operation "resume": re-launch a persisted workflow by run_id under the same run_id (re-runs its script; a convergent script does less work the second time).
+
+Inside the script you can call:
+- agent(prompt, opts?) -> Promise: spawn one subagent; resolves to its result (a validated object if opts.schema given, else its final text) or null on failure. Never throws.
+- parallel(thunks) -> Promise<any[]>: run thunks concurrently; a thunk that throws resolves to null.
+- pipeline(items, ...stages) -> Promise<any[]>: run each item through all stages; no barrier between stages.
+- workflow(nameOrScript, args?, opts?) -> Promise: run a CHILD workflow as its own sub-run and await its result. nameOrScript is either an inline script (starts with `export const meta`) or a saved workflow name resolved from .mimocode/workflows/ or .claude/workflows/. args is passed to the child as its `args`. opts: { workspace?, maxConcurrentAgents? }. A failed child resolves to null (never throws); an unknown name or a cycle/over-depth throws (fails the run). Children share the process-wide concurrency ceiling and inherit the parent workspace by default.
+- readFile(path) -> Promise<string|null>: read a file in the workspace (null if absent).
+- writeFile(path, content) -> Promise: write a file in the workspace (parent dirs auto-created).
+- glob(pattern) -> Promise<string[]>: list workspace paths matching the glob, sorted, files and dirs. Use this to enumerate work units — do NOT spawn an agent to list files.
+- exists(path) -> Promise<boolean>: whether a workspace path exists.
+- phase(title), log(message): progress reporting.
+- args: the JSON value passed when starting the workflow.
+
+Concurrency is capped by the host (default min(16, 2x cores)); excess agent() calls queue automatically.
+
+Communicate between workflows by dataflow: return a value from a child and pass it as args to the next (or write a shared file via writeFile and read it in a later phase). Workflows do not message each other directly. File primitives are jailed to the workspace root (the project worktree by default, or the `workspace` you pass to the run op) by a LEXICAL name check — it blocks `..` and absolute escapes, but does not resolve symlinks, so treat it as scoping, not a hard security boundary.
+
+workflow() cycle detection is asymmetric: a SAVED name is checked by name (so A calling A is a cycle regardless of args), while an INLINE script is checked by content+args (so an inline body that calls itself with DIFFERENT args is not flagged as a cycle and is bounded only by maxDepth). A cycle, over-maxDepth, or unknown name THROWS at the workflow() call site, which fails the run if uncaught — but a try/catch around workflow() in the guest will silence those throws, so don't wrap workflow() in try/catch unless you intend to ignore configuration bugs.

package/src/tool/write.ts

@@ -0,0 +1,88 @@
+import z from "zod"
+import * as path from "path"
+import { Effect } from "effect"
+import * as 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 { AppFileSystem } from "@mimo-ai/shared/filesystem"
+import { Instance } from "../project/instance"
+import { SessionCwd } from "./session-cwd"
+import { trimDiff } from "./edit"
+import { assertWriteAllowed, askEditUnlessMemory } from "./external-directory"
+
+const MAX_PROJECT_DIAGNOSTICS_FILES = 5
+
+export const WriteTool = Tool.define(
+  "write",
+  Effect.gen(function* () {
+    const lsp = yield* LSP.Service
+    const fs = yield* AppFileSystem.Service
+    const bus = yield* Bus.Service
+    const format = yield* Format.Service
+
+    return {
+      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)"),
+      }),
+      execute: (params: { content: string; filePath: string }, ctx: Tool.Context) =>
+        Effect.gen(function* () {
+          const filepath = path.isAbsolute(params.filePath)
+            ? params.filePath
+            : path.join(SessionCwd.get(ctx.sessionID), params.filePath)
+          yield* assertWriteAllowed(ctx, filepath)
+
+          const exists = yield* fs.existsSafe(filepath)
+          const contentOld = exists ? yield* fs.readFileString(filepath) : ""
+
+          const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, params.content))
+          yield* askEditUnlessMemory(ctx, filepath, {
+            patterns: [path.relative(Instance.worktree, filepath)],
+            diff,
+          })
+
+          yield* fs.writeWithDirs(filepath, params.content)
+          yield* format.file(filepath)
+          yield* bus.publish(File.Event.Edited, { file: filepath })
+          yield* bus.publish(FileWatcher.Event.Updated, {
+            file: filepath,
+            event: exists ? "change" : "add",
+          })
+
+          let output = "Wrote file successfully."
+          yield* lsp.touchFile(filepath, true)
+          const diagnostics = yield* lsp.diagnostics()
+          const normalizedFilepath = AppFileSystem.normalizePath(filepath)
+          let projectDiagnosticsCount = 0
+          for (const [file, issues] of Object.entries(diagnostics)) {
+            const current = file === normalizedFilepath
+            if (!current && projectDiagnosticsCount >= MAX_PROJECT_DIAGNOSTICS_FILES) continue
+            const block = LSP.Diagnostic.report(current ? filepath : file, issues)
+            if (!block) continue
+            if (current) {
+              output += `\n\nLSP errors detected in this file, please fix:\n${block}`
+              continue
+            }
+            projectDiagnosticsCount++
+            output += `\n\nLSP errors detected in other files:\n${block}`
+          }
+
+          return {
+            title: path.relative(Instance.worktree, filepath),
+            metadata: {
+              diagnostics,
+              filepath,
+              exists: exists,
+            },
+            output,
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/write.txt

@@ -0,0 +1,9 @@
+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.
+- For large files, prefer writing the content in multiple smaller steps rather than one big call: a single very large write may exceed the output limit and get truncated, leaving the file incomplete or corrupted. Write an initial portion with this tool, then add the remaining sections with follow-up Edit calls.

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,15 @@
+import path from "path"
+import * as Process from "./process"
+
+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,17 @@
+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/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,10 @@
+export function defer(fn: () => void | Promise<void>): AsyncDisposable & Disposable {
+  return {
+    [Symbol.dispose]() {
+      void fn()
+    },
+    [Symbol.asyncDispose]() {
+      return Promise.resolve(fn())
+    },
+  }
+}

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),
+    }),
+  )