docks-kit 0.1.5 → 0.2.0

package/cli/src/engine-native/toolchain.ts

@@ -4,12 +4,13 @@
  */
 import { readFileSync, readSync } from "node:fs"
 
-import { capture, commandExists, isExecutable, p } from "./exec"
+import type { ToolId } from "./deps"
+import { p } from "./exec"
 import type { Ctx } from "./index"
 import { compareCodepoints, isObject, parseJson, type Json } from "./jq"
-import { echo, log, warn } from "./output"
+import type { EngineServices } from "./services"
 
-type InstallFn = (mode: "install" | "upgrade", version: string) => number
+type InstallFn = (mode: "install" | "upgrade", version: string, services: EngineServices) => number
 
 function manifest(ctx: Ctx): { [k: string]: Json } {
   const doc = parseJson(readFileSync(p(ctx.repoDir, "SoT", "toolchain.json"), "utf8"))
@@ -37,15 +38,8 @@ export function isNewer(a: string, b: string): boolean {
   return compareCodepoints(a, b) > 0
 }
 
-export function present(ctx: Ctx, tool: string): boolean {
-  if (tool === "bun") {
-    return (
-      commandExists("bun") ||
-      isExecutable(p(process.env["BUN_INSTALL"] ?? p(ctx.home, ".bun"), "bin", "bun")) ||
-      isExecutable(p(ctx.home, ".bun", "bin", "bun"))
-    )
-  }
-  return commandExists(tool)
+export function present(ctx: Ctx, tool: ToolId): boolean {
+  return ctx.services.deps.probe(tool).state === "present"
 }
 
 function firstLineField(out: string, index: number): string {
@@ -53,67 +47,51 @@ function firstLineField(out: string, index: number): string {
   return fields[index === -1 ? fields.length - 1 : index] ?? ""
 }
 
-export function installedVersion(ctx: Ctx, tool: string): string {
-  if (!present(ctx, tool)) return ""
+export function installedVersion(ctx: Ctx, tool: ToolId): string {
+  const version = (): string => ctx.services.deps.version(tool)
   switch (tool) {
     case "rtk":
-      return firstLineField(capture("rtk", ["--version"]), 1)
+      return firstLineField(version(), 1)
     case "claude":
-      return firstLineField(capture("claude", ["--version"]), 0)
+      return firstLineField(version(), 0)
     case "codex":
-      return firstLineField(capture("codex", ["--version"]), -1)
-    case "bun":
-      return commandExists("bun") ? capture("bun", ["--version"]) : capture(p(ctx.home, ".bun", "bin", "bun"), ["--version"])
     case "agent-browser":
-      return firstLineField(capture("agent-browser", ["--version"]), -1)
-    case "effect-solutions": {
-      const bunbin = commandExists("bun") ? "bun" : p(ctx.home, ".bun", "bin", "bun")
-      if (bunbin !== "bun" && !isExecutable(bunbin)) return ""
-      const m = /effect-solutions@([0-9][0-9.]*)/.exec(capture(bunbin, ["pm", "-g", "ls"]))
-      return m?.[1] ?? ""
-    }
+      return firstLineField(version(), -1)
     case "git":
-      return firstLineField(capture("git", ["--version"]), 2)
+      return firstLineField(version(), 2)
     case "node":
-      return capture("node", ["--version"]).replace(/^v/, "")
-    case "npm":
-      return capture("npm", ["--version"])
+      return version().replace(/^v/, "")
     case "jq":
-      return capture("jq", ["--version"]).replace(/^jq-/, "")
+      return version().replace(/^jq-/, "")
     case "curl":
-      return firstLineField(capture("curl", ["--version"]), 1)
     case "tsc":
-      return firstLineField(capture("tsc", ["--version"]), 1)
+      return firstLineField(version(), 1)
+    case "bun":
+    case "effect-solutions":
+    case "npm":
+      return version()
     default:
       return ""
   }
 }
 
-export function latestVersion(tool: string): string {
-  switch (tool) {
-    case "rtk": {
-      const body = capture("curl", ["-fsSL", "--max-time", "5", "https://api.github.com/repos/rtk-ai/rtk/releases/latest"])
-      const doc = parseJson(body)
-      const tag = doc !== undefined && isObject(doc) && typeof doc["tag_name"] === "string" ? doc["tag_name"] : ""
-      return tag.replace(/^v/, "")
-    }
-    case "agent-browser":
-    case "effect-solutions":
-      return commandExists("npm") ? capture("npm", ["view", tool, "version"]) : ""
-    default:
-      return ""
-  }
+export function latestVersion(ctx: Ctx, tool: ToolId): string {
+  return ctx.services.deps.latest(tool)
 }
 
 /** Blocking TTY prompt matching bash `read -r -p` (prompt on stderr). */
-function promptLine(prompt: string): string {
-  process.stderr.write(prompt)
+export function promptLine(
+  prompt: string,
+  write: (chunk: string) => void = (chunk) => void process.stderr.write(chunk),
+  readByte: (buffer: Buffer) => number = (buffer) => readSync(0, buffer, 0, 1, null)
+): string {
+  write(prompt)
   const buf = Buffer.alloc(1)
   let line = ""
   for (;;) {
     let n: number
     try {
-      n = readSync(0, buf, 0, 1, null)
+      n = readByte(buf)
     } catch {
       break
     }
@@ -127,6 +105,7 @@ function promptLine(prompt: string): string {
 
 /** toolchain::_gate — { proceed, target } ("" target = latest). */
 function gate(ctx: Ctx, tool: string, mode: "install" | "upgrade", latest: string): { proceed: boolean; target: string } {
+  const { warn } = ctx.services.logger
   const verified = field(ctx, tool, "verified")
   const pinnable = field(ctx, tool, "pinnable")
 
@@ -138,7 +117,7 @@ function gate(ctx: Ctx, tool: string, mode: "install" | "upgrade", latest: strin
   }
 
   if (process.stdin.isTTY === true) {
-    process.stderr.write(`\x1b[1;33m[warn]\x1b[0m ${tool} ${latest} is not kit-verified (verified: ${verified}).\n`)
+    ctx.services.logger.warn(`${tool} ${latest} is not kit-verified (verified: ${verified}).`)
     const answer = promptLine(`Install ${tool} ${latest} anyway? [y/N] `)
     if (/^[yY]/.test(answer)) return { proceed: true, target: "" }
   }
@@ -153,11 +132,12 @@ function gate(ctx: Ctx, tool: string, mode: "install" | "upgrade", latest: strin
   return { proceed: false, target: "" }
 }
 
-export function ensure(ctx: Ctx, tool: string, installFn: InstallFn): number {
+export function ensure(ctx: Ctx, tool: ToolId, installFn: InstallFn): number {
+  const { echo, verbose, warn } = ctx.services.logger
   const policy = field(ctx, tool, "policy")
 
   if (!present(ctx, tool)) {
-    const latest = latestVersion(tool)
+    const latest = latestVersion(ctx, tool)
     if (ctx.dryRun) {
       echo(`[dry-run] would install ${tool} (${latest !== "" ? latest : "latest"}, gated by toolchain.json verified pin)`)
       return 0
@@ -176,7 +156,7 @@ export function ensure(ctx: Ctx, tool: string, installFn: InstallFn): number {
       if (!g.proceed) return 0
       target = g.target
     }
-    return installFn("install", target !== "" ? target : latest)
+    return installFn("install", target !== "" ? target : latest, ctx.services)
   }
 
   const installed = installedVersion(ctx, tool)
@@ -187,17 +167,17 @@ export function ensure(ctx: Ctx, tool: string, installFn: InstallFn): number {
       echo(`[dry-run] ${tool} present (${installedLabel})`)
       return 0
     }
-    log(`${tool} present (${installedLabel})`)
+    verbose(`${tool} present (${installedLabel})`)
     return 0
   }
 
-  const latest = latestVersion(tool)
+  const latest = latestVersion(ctx, tool)
   if (latest === "") {
     if (ctx.dryRun) {
       echo(`[dry-run] ${tool} present (${installedLabel}); latest unknown (offline?) — no action`)
       return 0
     }
-    log(`${tool} present (${installedLabel}; latest unknown — no action)`)
+    verbose(`${tool} present (${installedLabel}; latest unknown — no action)`)
     return 0
   }
 
@@ -208,14 +188,14 @@ export function ensure(ctx: Ctx, tool: string, installFn: InstallFn): number {
     }
     const g = gate(ctx, tool, "upgrade", latest)
     if (!g.proceed) return 0
-    return installFn("upgrade", g.target !== "" ? g.target : latest)
+    return installFn("upgrade", g.target !== "" ? g.target : latest, ctx.services)
   }
 
   if (ctx.dryRun) {
     echo(`[dry-run] ${tool} up to date (${installed})`)
     return 0
   }
-  log(`${tool} up to date (${installed})`)
+  verbose(`${tool} up to date (${installed})`)
   return 0
 }
 
@@ -225,9 +205,10 @@ function row(cells: [string, string, string, string, string, string]): string {
 }
 
 export function report(ctx: Ctx): void {
+  const { echo } = ctx.services.logger
   echo(row(["TOOL", "KIND", "INSTALLED", "FLOOR", "VERIFIED", "STATUS"]))
-  const platformOs =
-    process.platform === "linux" ? "linux" : process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : ""
+  const pn = ctx.services.platform.name()
+  const platformOs = pn === "unknown" ? "" : pn
   for (const tool of Object.keys(manifest(ctx)).sort(compareCodepoints)) {
     const os = field(ctx, tool, "os")
     if (os !== "" && platformOs !== "" && os !== platformOs) continue
@@ -241,8 +222,9 @@ export function report(ctx: Ctx): void {
     }
     let installed: string
     let status: string
-    if (present(ctx, tool)) {
-      installed = installedVersion(ctx, tool)
+    const toolId = tool as ToolId
+    if (present(ctx, toolId)) {
+      installed = installedVersion(ctx, toolId)
       status = "ok"
       if (floor !== "" && installed !== "" && isNewer(floor, installed)) {
         status = "below-floor"

package/cli/src/engine.ts

@@ -1,7 +1,13 @@
 import { Console, Effect } from "effect"
 import { spawnSync } from "node:child_process"
 import { runEngineNative } from "./engine-native"
+import { makeEngineServices } from "./engine-native/services"
 import { kitHome } from "./kitHome"
+import { DependencyManagerService, LoggerService, PlatformService } from "./services"
+
+// Same factory as the Effect rim's live layers — this path runs outside the
+// runtime (child-spawn capture), so it takes the services directly.
+const services = makeEngineServices()
 
 /**
  * The single seam between the typed CLI and EngineNative. Engine execution
@@ -24,7 +30,10 @@ export const engine = (args: ReadonlyArray<string>) =>
     if (bashEngineRequested()) {
       yield* bail(bashRemovedMessage, 2)
     }
-    const code = yield* Effect.sync(() => runEngineNative(args))
+    const logger = yield* LoggerService
+    const deps = yield* DependencyManagerService
+    const platform = yield* PlatformService
+    const code = yield* Effect.sync(() => runEngineNative(args, { logger, deps, platform }))
     if (code !== 0) {
       yield* Effect.sync(() => process.exit(code))
     }
@@ -43,7 +52,7 @@ export const engineCapture = (args: ReadonlyArray<string>) =>
         stdio: ["ignore", "pipe", "inherit"]
       })
       if (res.error !== undefined || res.status !== 0) {
-        process.stderr.write(`\x1b[1;33m[warn]\x1b[0m engine capture failed (${args.join(" ")} exited ${res.status ?? "spawn-error"})\n`)
+        services.logger.warn(`engine capture failed (${args.join(" ")} exited ${res.status ?? "spawn-error"})`)
       }
       return res.stdout ?? ""
     })

package/cli/src/main.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env bun
 import { Command } from "@effect/cli"
 import { BunContext, BunRuntime } from "@effect/platform-bun"
-import { Console, Effect } from "effect"
+import { Console, Effect, Layer } from "effect"
+import { EngineServicesLive } from "./services"
 import { docsCommand } from "./commands/docs"
 import { modelCommand } from "./commands/model"
 import { modelsCommand } from "./commands/models"
@@ -70,4 +71,4 @@ const argv = process.argv.flatMap((a) =>
     : [a]
 )
 
-cli(argv).pipe(Effect.provide(BunContext.layer), BunRuntime.runMain)
+cli(argv).pipe(Effect.provide(Layer.mergeAll(BunContext.layer, EngineServicesLive)), BunRuntime.runMain)

package/cli/src/services.ts

@@ -0,0 +1,34 @@
+/**
+ * Effect rim over the engine's injectable capabilities: Context.Tags with
+ * live layers built from the shared factory (engine-native/services.ts) plus
+ * named test-layer constructors. Composed ONCE at main.ts — command code
+ * accesses services via `yield*`, never by re-providing.
+ */
+import { Context, Layer } from "effect"
+import { makeLogger, type Logger, type LoggerSinks } from "./engine-native/logger"
+import { makeEngineServices, makePlatform, type DependencyManager, type Platform } from "./engine-native/services"
+
+export class LoggerService extends Context.Tag("docks-kit/Logger")<LoggerService, Logger>() {}
+
+export class DependencyManagerService extends Context.Tag("docks-kit/DependencyManager")<
+  DependencyManagerService,
+  DependencyManager
+>() {}
+
+export class PlatformService extends Context.Tag("docks-kit/Platform")<PlatformService, Platform>() {}
+
+const live = makeEngineServices()
+
+export const LoggerLive = Layer.succeed(LoggerService, live.logger)
+export const DependencyManagerLive = Layer.succeed(DependencyManagerService, live.deps)
+export const PlatformLive = Layer.succeed(PlatformService, live.platform)
+export const EngineServicesLive = Layer.mergeAll(LoggerLive, DependencyManagerLive, PlatformLive)
+
+export const LoggerTest = (sinks: LoggerSinks): Layer.Layer<LoggerService> =>
+  Layer.succeed(LoggerService, makeLogger(sinks))
+
+export const PlatformTest = (pf: NodeJS.Platform): Layer.Layer<PlatformService> =>
+  Layer.succeed(PlatformService, makePlatform(pf))
+
+export const DependencyManagerTest = (impl: DependencyManager): Layer.Layer<DependencyManagerService> =>
+  Layer.succeed(DependencyManagerService, impl)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docks-kit",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "Portable AI coding agent config kit — SoT sync engine + typed CLI for Claude Code, Codex, and universal agent skills",
   "type": "module",
   "license": "MIT",

package/cli/src/engine-native/output.ts

@@ -1,20 +0,0 @@
-/**
- * Shared log/warn/err and dry-run emitters. Prefixes go to stderr with stable
- * ANSI codes; dry-run lines go to stdout.
- */
-
-export function log(msg: string): void {
-  process.stderr.write(`\x1b[1;32m[ok]\x1b[0m ${msg}\n`)
-}
-
-export function warn(msg: string): void {
-  process.stderr.write(`\x1b[1;33m[warn]\x1b[0m ${msg}\n`)
-}
-
-export function err(msg: string): void {
-  process.stderr.write(`\x1b[1;31m[err]\x1b[0m ${msg}\n`)
-}
-
-export function echo(line: string): void {
-  process.stdout.write(`${line}\n`)
-}