@blogic-cz/agent-tools 0.1.0

package/src/shared/exec.ts

@@ -0,0 +1,62 @@
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { Effect, Schema, Stream } from "effect";
+
+const DEFAULT_TIMEOUT_MS = 30000;
+
+export class ExecError extends Schema.TaggedErrorClass<ExecError>()("ExecError", {
+  message: Schema.String,
+  command: Schema.String,
+  exitCode: Schema.Number,
+  stderr: Schema.String,
+}) {}
+
+export const execEffect = (
+  commandStr: string,
+  timeoutMs: number = DEFAULT_TIMEOUT_MS,
+): Effect.Effect<
+  { stdout: string; stderr: string; exitCode: number },
+  ExecError,
+  ChildProcessSpawner.ChildProcessSpawner
+> =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const executor = yield* ChildProcessSpawner.ChildProcessSpawner;
+
+      const command = ChildProcess.make("sh", ["-c", commandStr], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const process = yield* executor.spawn(command);
+
+      const stdoutChunk = yield* process.stdout.pipe(Stream.decodeText(), Stream.runCollect);
+      const stderrChunk = yield* process.stderr.pipe(Stream.decodeText(), Stream.runCollect);
+
+      const stdout = stdoutChunk.join("");
+      const stderr = stderrChunk.join("");
+      const exitCode = yield* process.exitCode;
+
+      if (exitCode !== 0) {
+        return yield* new ExecError({
+          message: stderr || `Command failed with exit code ${exitCode}`,
+          command: commandStr,
+          exitCode,
+          stderr,
+        });
+      }
+
+      return { stdout, stderr, exitCode };
+    }),
+  ).pipe(
+    Effect.timeout(timeoutMs),
+    Effect.catch((error: unknown) =>
+      Effect.fail(
+        new ExecError({
+          message: `Command execution failed: ${String(error)}`,
+          command: commandStr,
+          exitCode: -1,
+          stderr: String(error),
+        }),
+      ),
+    ),
+  );

package/src/shared/format.ts

@@ -0,0 +1,27 @@
+import { Flag } from "effect/unstable/cli";
+import { encode as encodeToon } from "@toon-format/toon";
+import { Console } from "effect";
+
+import type { BaseResult, OutputFormat } from "./types";
+
+export const formatOption = Flag.choice("format", ["toon", "json"]).pipe(
+  Flag.withDescription("Output format: toon (default, token-efficient) or json"),
+  Flag.withDefault("toon"),
+);
+
+export function formatOutput<T extends BaseResult>(result: T, format: OutputFormat): string {
+  if (format === "toon") {
+    return encodeToon(result);
+  }
+  return JSON.stringify(result, null, 2);
+}
+
+export function formatAny<T>(data: T, format: OutputFormat): string {
+  if (format === "toon") {
+    return encodeToon(data);
+  }
+  return JSON.stringify(data, null, 2);
+}
+
+export const logFormatted = <T>(data: T, format: OutputFormat) =>
+  Console.log(formatAny(data, format));

package/src/shared/index.ts

@@ -0,0 +1,16 @@
+export type { BaseResult, CommandOptions, CommandResult, Environment, OutputFormat } from "./types";
+
+export { formatAny, formatOption, formatOutput, logFormatted } from "./format";
+
+export { expandPath, runCommand, runShellCommand } from "./bun";
+
+export { commonArgOptions, parseCommonArgs } from "./cli";
+
+export { renderCauseToStderr } from "./error-renderer";
+
+import pkg from "../../package.json" with { type: "json" };
+export const VERSION = pkg.version;
+
+export { execEffect, type ExecError } from "./exec";
+
+export { createThrottle, type ThrottleError } from "./throttle";

package/src/shared/throttle.ts

@@ -0,0 +1,35 @@
+import { Effect, Ref, Schema } from "effect";
+
+const WINDOW_MS = 60000;
+
+export class ThrottleError extends Schema.TaggedErrorClass<ThrottleError>()("ThrottleError", {
+  message: Schema.String,
+  label: Schema.String,
+  limit: Schema.Number,
+  windowMs: Schema.Number,
+}) {}
+
+export const createThrottle = (opts: { maxPerMinute: number; label: string }) => {
+  const timestampsRef = Effect.runSync(Ref.make<number[]>([]));
+
+  const check = (): Effect.Effect<void, ThrottleError> =>
+    Effect.gen(function* () {
+      const now = Date.now();
+      const windowStart = now - WINDOW_MS;
+      const timestamps = yield* Ref.get(timestampsRef);
+      const recentTimestamps = timestamps.filter((timestamp) => timestamp >= windowStart);
+
+      if (recentTimestamps.length >= opts.maxPerMinute) {
+        return yield* new ThrottleError({
+          message: `Rate limit exceeded for ${opts.label}`,
+          label: opts.label,
+          limit: opts.maxPerMinute,
+          windowMs: WINDOW_MS,
+        });
+      }
+
+      yield* Ref.set(timestampsRef, [...recentTimestamps, now]);
+    });
+
+  return { check };
+};

package/src/shared/types.ts

@@ -0,0 +1,25 @@
+export type OutputFormat = "json" | "toon";
+export type Environment = "local" | "test" | "prod";
+
+export type BaseResult = {
+  success: boolean;
+  error?: string;
+  executionTimeMs: number;
+};
+
+export type CommandOptions = {
+  cwd?: string;
+  env?: Record<string, string>;
+  timeout?: number;
+  killSignal?: NodeJS.Signals;
+};
+
+export type CommandResult = {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  signalCode: NodeJS.Signals | null;
+  timedOut: boolean;
+  executionTimeMs: number;
+};