@miaws/miaw 1.18.3 → 1.18.5

package/src/cli/cmd/debug/agent.ts

@@ -0,0 +1,27 @@
+import { Effect } from "effect"
+import { effectCmd } from "../../effect-cmd"
+
+export const AgentCommand = effectCmd({
+  command: "agent <name>",
+  describe: "show agent configuration details",
+  builder: (yargs) =>
+    yargs
+      .positional("name", {
+        type: "string",
+        demandOption: true,
+        description: "Agent name",
+      })
+      .option("tool", {
+        type: "string",
+        description: "Tool id to execute",
+      })
+      .option("params", {
+        type: "string",
+        description: "Tool params as JSON or a JS object literal",
+      }),
+  handler: (args) =>
+    Effect.gen(function* () {
+      const { debugAgent } = yield* Effect.promise(() => import("./agent.handler"))
+      return yield* debugAgent(args)
+    }),
+})

package/src/cli/cmd/debug/config.ts

@@ -0,0 +1,14 @@
+import { EOL } from "os"
+import { Effect } from "effect"
+import { effectCmd } from "../../effect-cmd"
+
+export const ConfigCommand = effectCmd({
+  command: "config",
+  describe: "show resolved configuration",
+  builder: (yargs) => yargs,
+  handler: Effect.fn("Cli.debug.config")(function* () {
+    const { Config } = yield* Effect.promise(() => import("@/config/config"))
+    const config = yield* Config.Service.use((cfg) => cfg.get())
+    process.stdout.write(JSON.stringify(config, null, 2) + EOL)
+  }),
+})

package/src/cli/cmd/debug/file.ts

@@ -0,0 +1,73 @@
+import { EOL } from "os"
+import { Effect } from "effect"
+import { FileSystem } from "@miaw/core/filesystem"
+import { LocationServiceMap } from "@miaw/core/location-layer"
+import { Location } from "@miaw/core/location"
+import { AbsolutePath, RelativePath } from "@miaw/core/schema"
+import { effectCmd } from "../../effect-cmd"
+import { cmd } from "../cmd"
+
+const filesystem = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  effect.pipe(
+    Effect.provide(LocationServiceMap.get(Location.Ref.make({ directory: AbsolutePath.make(process.cwd()) }))),
+    Effect.provide(LocationServiceMap.layer),
+  )
+
+const FileSearchCommand = effectCmd({
+  command: "search <query>",
+  describe: "search files by query",
+  builder: (yargs) =>
+    yargs.positional("query", {
+      type: "string",
+      demandOption: true,
+      description: "Search query",
+    }),
+  handler: Effect.fn("Cli.debug.file.search")(function* (args) {
+    const results = yield* Effect.orDie(filesystem(FileSystem.Service.use((svc) => svc.find({ query: args.query }))))
+    process.stdout.write(results.map((item) => item.path).join(EOL) + EOL)
+  }),
+})
+
+const FileReadCommand = effectCmd({
+  command: "read <path>",
+  describe: "read file contents as JSON",
+  builder: (yargs) =>
+    yargs.positional("path", {
+      type: "string",
+      demandOption: true,
+      description: "File path to read",
+    }),
+  handler: Effect.fn("Cli.debug.file.read")(function* (args) {
+    const file = yield* filesystem(FileSystem.Service.use((svc) => svc.read({ path: RelativePath.make(args.path) })))
+    process.stdout.write(
+      JSON.stringify(
+        { content: Buffer.from(file.content).toString("base64"), encoding: "base64", mime: file.mime },
+        null,
+        2,
+      ) + EOL,
+    )
+  }),
+})
+
+const FileListCommand = effectCmd({
+  command: "list <path>",
+  describe: "list files in a directory",
+  builder: (yargs) =>
+    yargs.positional("path", {
+      type: "string",
+      demandOption: true,
+      description: "File path to list",
+    }),
+  handler: Effect.fn("Cli.debug.file.list")(function* (args) {
+    const files = yield* filesystem(FileSystem.Service.use((svc) => svc.list({ path: RelativePath.make(args.path) })))
+    process.stdout.write(JSON.stringify(files, null, 2) + EOL)
+  }),
+})
+
+export const FileCommand = cmd({
+  command: "file",
+  describe: "file system debugging utilities",
+  builder: (yargs) =>
+    yargs.command(FileReadCommand).command(FileListCommand).command(FileSearchCommand).demandCommand(),
+  async handler() {},
+})

package/src/cli/cmd/debug/index.ts

@@ -0,0 +1,87 @@
+import { Global } from "@miaw/core/global"
+import { InstallationVersion } from "@miaw/core/installation/version"
+import { Flag } from "@miaw/core/flag/flag"
+import os from "os"
+import { Duration, Effect } from "effect"
+import { effectCmd } from "../../effect-cmd"
+import { cmd } from "../cmd"
+import { ConfigCommand } from "./config"
+import { FileCommand } from "./file"
+import { LSPCommand } from "./lsp"
+import { RipgrepCommand } from "./ripgrep"
+import { ScrapCommand } from "./scrap"
+import { SkillCommand } from "./skill"
+import { SnapshotCommand } from "./snapshot"
+import { AgentCommand } from "./agent"
+import { StartupCommand } from "./startup"
+import { V2Command } from "./v2"
+
+export const DebugCommand = cmd({
+  command: "debug",
+  describe: "debugging and troubleshooting tools",
+  builder: (yargs) =>
+    yargs
+      .command(ConfigCommand)
+      .command(LSPCommand)
+      .command(RipgrepCommand)
+      .command(FileCommand)
+      .command(ScrapCommand)
+      .command(SkillCommand)
+      .command(SnapshotCommand)
+      .command(StartupCommand)
+      .command(AgentCommand)
+      .command(V2Command)
+      .command(InfoCommand)
+      .command(PathsCommand)
+      .command(WaitCommand)
+      .demandCommand(),
+  async handler() {},
+})
+
+const WaitCommand = effectCmd({
+  command: "wait",
+  describe: "wait indefinitely (for debugging)",
+  handler: Effect.fn("Cli.debug.wait")(function* () {
+    yield* Effect.sleep(Duration.days(1))
+  }),
+})
+
+const InfoCommand = effectCmd({
+  command: "info",
+  describe: "show debug information",
+  handler: Effect.fn("Cli.debug.info")(function* () {
+    const { Config } = yield* Effect.promise(() => import("@/config/config"))
+    const { ConfigPlugin } = yield* Effect.promise(() => import("@/config/plugin"))
+    const config = yield* Config.Service.use((cfg) => cfg.get())
+    const termProgram = process.env.TERM_PROGRAM
+      ? `${process.env.TERM_PROGRAM}${process.env.TERM_PROGRAM_VERSION ? ` ${process.env.TERM_PROGRAM_VERSION}` : ""}`
+      : undefined
+    const terminal = [termProgram, process.env.TERM].filter((item): item is string => Boolean(item)).join(" / ")
+
+    console.log(`miaw version: ${InstallationVersion}`)
+    console.log(`os: ${os.type()} ${os.release()} ${os.arch()}`)
+    console.log(`terminal: ${terminal || "unknown"}`)
+    console.log("plugins:")
+    if (Flag.MIAW_PURE) {
+      console.log("external plugins disabled (--pure)")
+      return
+    }
+    if (!config.plugin_origins?.length) {
+      console.log("none")
+      return
+    }
+    for (const plugin of config.plugin_origins) {
+      console.log(`- ${ConfigPlugin.pluginSpecifier(plugin.spec)}`)
+    }
+  }),
+})
+
+const PathsCommand = cmd({
+  command: "paths",
+  describe: "show global paths (data, config, cache, state)",
+  handler() {
+    for (const [key, value] of Object.entries(Global.Path)) {
+      console.log(key.padEnd(10), value)
+    }
+  },
+})

package/src/cli/cmd/debug/lsp.ts

@@ -0,0 +1,50 @@
+import { LSP } from "@/lsp/lsp"
+import { Effect } from "effect"
+import { effectCmd } from "../../effect-cmd"
+import { cmd } from "../cmd"
+import { EOL } from "os"
+
+export const LSPCommand = cmd({
+  command: "lsp",
+  describe: "LSP debugging utilities",
+  builder: (yargs) =>
+    yargs.command(DiagnosticsCommand).command(SymbolsCommand).command(DocumentSymbolsCommand).demandCommand(),
+  async handler() {},
+})
+
+const DiagnosticsCommand = effectCmd({
+  command: "diagnostics <file>",
+  describe: "get diagnostics for a file",
+  builder: (yargs) => yargs.positional("file", { type: "string", demandOption: true }),
+  handler: Effect.fn("Cli.debug.lsp.diagnostics")(function* (args) {
+    const out = yield* LSP.Service.use((lsp) =>
+      Effect.gen(function* () {
+        yield* lsp.touchFile(args.file, "full")
+        return yield* lsp.diagnostics()
+      }),
+    )
+    process.stdout.write(JSON.stringify(out, null, 2) + EOL)
+  }),
+})
+
+export const SymbolsCommand = effectCmd({
+  command: "symbols <query>",
+  describe: "search workspace symbols",
+  builder: (yargs) => yargs.positional("query", { type: "string", demandOption: true }),
+  handler: Effect.fn("Cli.debug.lsp.symbols")(function* (args) {
+    yield* Effect.logInfo("symbols")
+    const results = yield* LSP.Service.use((lsp) => lsp.workspaceSymbol(args.query))
+    process.stdout.write(JSON.stringify(results, null, 2) + EOL)
+  }),
+})
+
+export const DocumentSymbolsCommand = effectCmd({
+  command: "document-symbols <uri>",
+  describe: "get symbols from a document",
+  builder: (yargs) => yargs.positional("uri", { type: "string", demandOption: true }),
+  handler: Effect.fn("Cli.debug.lsp.documentSymbols")(function* (args) {
+    yield* Effect.logInfo("document-symbols")
+    const results = yield* LSP.Service.use((lsp) => lsp.documentSymbol(args.uri))
+    process.stdout.write(JSON.stringify(results, null, 2) + EOL)
+  }),
+})

package/src/cli/cmd/debug/ripgrep.ts

@@ -0,0 +1,79 @@
+import { EOL } from "os"
+import { Effect } from "effect"
+import { Ripgrep } from "@miaw/core/ripgrep"
+import { effectCmd } from "../../effect-cmd"
+import { cmd } from "../cmd"
+import { InstanceRef } from "@/effect/instance-ref"
+
+export const RipgrepCommand = cmd({
+  command: "rg",
+  describe: "ripgrep debugging utilities",
+  builder: (yargs) => yargs.command(FilesCommand).command(SearchCommand).demandCommand(),
+  async handler() {},
+})
+
+const FilesCommand = effectCmd({
+  command: "files",
+  describe: "list files using ripgrep",
+  builder: (yargs) =>
+    yargs
+      .option("query", {
+        type: "string",
+        description: "Filter files by query",
+      })
+      .option("glob", {
+        type: "string",
+        description: "Glob pattern to match files",
+      })
+      .option("limit", {
+        type: "number",
+        description: "Limit number of results",
+      }),
+  handler: Effect.fn("Cli.debug.rg.files")(function* (args) {
+    const ctx = yield* InstanceRef
+    if (!ctx) return
+    const ripgrep = yield* Ripgrep.Service
+    const files = yield* ripgrep
+      .glob({
+        cwd: ctx.directory,
+        pattern: args.glob ?? "**/*",
+        limit: args.limit ?? 10_000,
+      })
+      .pipe(Effect.orDie)
+    process.stdout.write(files.map((file) => file.path).join(EOL) + EOL)
+  }),
+})
+
+const SearchCommand = effectCmd({
+  command: "search <pattern>",
+  describe: "search file contents using ripgrep",
+  builder: (yargs) =>
+    yargs
+      .positional("pattern", {
+        type: "string",
+        demandOption: true,
+        description: "Search pattern",
+      })
+      .option("glob", {
+        type: "array",
+        description: "File glob patterns",
+      })
+      .option("limit", {
+        type: "number",
+        description: "Limit number of results",
+      }),
+  handler: Effect.fn("Cli.debug.rg.search")(function* (args) {
+    const ctx = yield* InstanceRef
+    if (!ctx) return
+    const ripgrep = yield* Ripgrep.Service
+    const results = yield* ripgrep
+      .grep({
+        cwd: ctx.directory,
+        pattern: args.pattern,
+        include: args.glob?.[0],
+        limit: args.limit ?? 10_000,
+      })
+      .pipe(Effect.orDie)
+    process.stdout.write(JSON.stringify(results, null, 2) + EOL)
+  }),
+})

package/src/cli/cmd/debug/scrap.ts

@@ -0,0 +1,15 @@
+import { EOL } from "os"
+import { cmd } from "../cmd"
+
+export const ScrapCommand = cmd({
+  command: "scrap",
+  describe: "list all known projects",
+  builder: (yargs) => yargs,
+  async handler() {
+    const { Project } = await import("@/project/project")
+    const { makeRuntime } = await import("@miaw/core/effect/runtime")
+    const runtime = makeRuntime(Project.Service, Project.defaultLayer)
+    const list = await runtime.runPromise((project) => project.list())
+    process.stdout.write(JSON.stringify(list, null, 2) + EOL)
+  },
+})

package/src/cli/cmd/debug/skill.ts

@@ -0,0 +1,15 @@
+import { EOL } from "os"
+import { Effect } from "effect"
+import { Skill } from "../../../skill"
+import { effectCmd } from "../../effect-cmd"
+
+export const SkillCommand = effectCmd({
+  command: "skill",
+  describe: "list all available skills",
+  builder: (yargs) => yargs,
+  handler: Effect.fn("Cli.debug.skill")(function* () {
+    const skill = yield* Skill.Service
+    const skills = yield* skill.all()
+    process.stdout.write(JSON.stringify(skills, null, 2) + EOL)
+  }),
+})

package/src/cli/cmd/debug/snapshot.ts

@@ -0,0 +1,50 @@
+import { Effect } from "effect"
+import { Snapshot } from "../../../snapshot"
+import { effectCmd } from "../../effect-cmd"
+import { cmd } from "../cmd"
+
+export const SnapshotCommand = cmd({
+  command: "snapshot",
+  describe: "snapshot debugging utilities",
+  builder: (yargs) => yargs.command(TrackCommand).command(PatchCommand).command(DiffCommand).demandCommand(),
+  async handler() {},
+})
+
+const TrackCommand = effectCmd({
+  command: "track",
+  describe: "track current snapshot state",
+  handler: Effect.fn("Cli.debug.snapshot.track")(function* () {
+    const out = yield* Snapshot.Service.use((svc) => svc.track())
+    console.log(out)
+  }),
+})
+
+const PatchCommand = effectCmd({
+  command: "patch <hash>",
+  describe: "show patch for a snapshot hash",
+  builder: (yargs) =>
+    yargs.positional("hash", {
+      type: "string",
+      description: "hash",
+      demandOption: true,
+    }),
+  handler: Effect.fn("Cli.debug.snapshot.patch")(function* (args) {
+    const out = yield* Snapshot.Service.use((svc) => svc.patch(args.hash))
+    console.log(out)
+  }),
+})
+
+const DiffCommand = effectCmd({
+  command: "diff <hash>",
+  describe: "show diff for a snapshot hash",
+  builder: (yargs) =>
+    yargs.positional("hash", {
+      type: "string",
+      description: "hash",
+      demandOption: true,
+    }),
+  handler: Effect.fn("Cli.debug.snapshot.diff")(function* (args) {
+    const out = yield* Snapshot.Service.use((svc) => svc.diff(args.hash))
+    console.log(out)
+  }),
+})

package/src/cli/cmd/debug/startup.ts

@@ -0,0 +1,11 @@
+import { EOL } from "os"
+import { cmd } from "../cmd"
+
+export const StartupCommand = cmd({
+  command: "startup",
+  describe: "print startup timing",
+  builder: (yargs) => yargs,
+  handler() {
+    process.stdout.write(performance.now().toString() + EOL)
+  },
+})

package/src/cli/cmd/debug/v2.ts

@@ -0,0 +1,49 @@
+import { EOL } from "os"
+import { Effect, Option } from "effect"
+import { Catalog } from "@miaw/core/catalog"
+import { LocationServiceMap } from "@miaw/core/location-layer"
+import { Location } from "@miaw/core/location"
+import { PluginBoot } from "@miaw/core/plugin/boot"
+import { AbsolutePath } from "@miaw/core/schema"
+import { effectCmd } from "../../effect-cmd"
+
+export const V2Command = effectCmd({
+  command: "v2",
+  describe: "debug v2 catalog and built-in plugins",
+  instance: false,
+  handler: () =>
+    Effect.gen(function* () {
+      yield* PluginBoot.Service.use((service) => service.wait())
+      const catalog = yield* Catalog.Service
+      const providers = (yield* catalog.provider.available()).sort((a, b) => a.id.localeCompare(b.id))
+      const all = (yield* catalog.provider.all()).sort((a, b) => a.id.localeCompare(b.id))
+      const result = {
+        providers,
+        default: catalog.model
+          .default()
+          .pipe(Effect.map(Option.map((item) => item.id)), Effect.map(Option.getOrUndefined)),
+        small: Object.fromEntries(
+          yield* Effect.all(
+            all.map((provider) =>
+              Effect.map(
+                catalog.model.small(provider.id),
+                (model) => [provider.id, Option.getOrUndefined(Option.map(model, (item) => item.id))] as const,
+              ),
+            ),
+            { concurrency: "unbounded" },
+          ),
+        ),
+      }
+      process.stdout.write(JSON.stringify(result, null, 2) + EOL)
+    }).pipe(
+      Effect.withSpan("Cli.debug.v2"),
+      Effect.provide(
+        LocationServiceMap.get(
+          Location.Ref.make({
+            directory: AbsolutePath.make(process.cwd()),
+          }),
+        ),
+      ),
+      Effect.provide(LocationServiceMap.layer),
+    ),
+})