@blogic-cz/agent-tools 0.1.0 → 0.2.1

package/src/k8s-tool/index.ts

@@ -5,80 +5,172 @@ import { Console, Effect, Layer, Option } from "effect";
 
 import type { CommandResult } from "./types";
 
-import { formatOption, formatOutput, renderCauseToStderr, VERSION } from "../shared";
+import { formatOption, formatOutput, renderCauseToStderr, VERSION } from "#src/shared";
 import { K8sService, K8sServiceLayer } from "./service";
-import { ConfigService, ConfigServiceLayer, getToolConfig } from "../config";
-import type { K8sConfig } from "../config";
+import {
+  ConfigService,
+  ConfigServiceLayer,
+  getDefaultEnvironment,
+  getToolConfig,
+} from "#src/config";
+import type { K8sConfig } from "#src/config";
+import { K8sContextError } from "./errors";
+
+/**
+ * Resolve environment from explicit --env flag, config defaultEnvironment, or fail with hint.
+ * Rejects implicit prod: if defaultEnvironment is "prod" and --env was not passed, fail explicitly.
+ */
+const resolveEnv = (
+  envOption: Option.Option<string>,
+  config: Parameters<typeof getDefaultEnvironment>[0],
+) =>
+  Effect.gen(function* () {
+    const explicit = Option.getOrUndefined(envOption);
+    if (explicit) return explicit;
+
+    const defaultEnv = getDefaultEnvironment(config);
+
+    if (defaultEnv === "prod") {
+      return yield* new K8sContextError({
+        message:
+          "Implicit prod access blocked. Config defaultEnvironment is 'prod' but --env was not passed explicitly.",
+        clusterId: "(prod-safety)",
+        hint: "Pass --env prod explicitly to confirm production access, or change defaultEnvironment to a non-prod value.",
+        nextCommand: 'agent-tools-k8s kubectl --env prod --cmd "get pods -n <namespace>"',
+      });
+    }
+
+    if (defaultEnv) return defaultEnv;
+
+    return yield* new K8sContextError({
+      message:
+        "No environment specified. Use --env <name> or set defaultEnvironment in agent-tools.json5.",
+      clusterId: "(not specified)",
+      hint: 'Set defaultEnvironment in agent-tools.json5 (e.g. defaultEnvironment: "test") or pass --env explicitly.',
+      nextCommand: 'agent-tools-k8s kubectl --env test --cmd "get pods -n <namespace>"',
+    });
+  });
+
+type CommonK8sCommandOptions = {
+  readonly env: Option.Option<string>;
+  readonly dryRun: boolean;
+  readonly format: "toon" | "json";
+  readonly profile: Option.Option<string>;
+};
+
+const runK8sCommand = (command: string, options: CommonK8sCommandOptions) =>
+  Effect.gen(function* () {
+    const config = yield* ConfigService;
+    const profileName = Option.getOrUndefined(options.profile);
+    const k8sConfig = getToolConfig<K8sConfig>(config, "kubernetes", profileName);
+
+    if (!k8sConfig) {
+      const result: CommandResult = {
+        success: false,
+        error: "No Kubernetes configuration found",
+        hint: "Add a 'kubernetes' section to agent-tools.json5 with clusterId and namespaces.",
+        nextCommand:
+          "echo '{ kubernetes: { default: { clusterId: \"my-cluster\" } } }' > agent-tools.json5",
+        executionTimeMs: 0,
+      };
+      yield* Console.log(formatOutput(result, options.format));
+      return;
+    }
+
+    const resolvedEnv = yield* resolveEnv(options.env, config);
+
+    const k8sService = yield* K8sService;
+    const result = yield* k8sService.runKubectl(command, options.dryRun).pipe(
+      Effect.catchTags({
+        K8sContextError: (error) => {
+          const errorResult: CommandResult = {
+            success: false,
+            error: error.message,
+            hint: `Verify cluster ID "${k8sConfig.clusterId}" matches a context in kubectl config. Run: kubectl config get-contexts`,
+            nextCommand: "kubectl config get-contexts",
+            executionTimeMs: 0,
+          };
+          return Effect.succeed(errorResult);
+        },
+        K8sCommandError: (error) => {
+          const errorResult: CommandResult = {
+            success: false,
+            error: error.message,
+            command: error.command,
+            hint:
+              error.hint ?? "Check command syntax and ensure the target namespace/resource exists.",
+            executionTimeMs: 0,
+          };
+          return Effect.succeed(errorResult);
+        },
+        K8sTimeoutError: (error) => {
+          const errorResult: CommandResult = {
+            success: false,
+            error: error.message,
+            command: error.command,
+            hint:
+              error.hint ??
+              `Command timed out after ${error.timeoutMs}ms. Consider increasing timeoutMs in config or narrowing the query.`,
+            executionTimeMs: error.timeoutMs,
+          };
+          return Effect.succeed(errorResult);
+        },
+      }),
+    );
+
+    yield* Console.log(formatOutput({ ...result, environment: resolvedEnv }, options.format));
+  });
+
+const commonFlags = {
+  env: Flag.optional(Flag.string("env")).pipe(
+    Flag.withDescription(
+      "Target environment (e.g. test, prod). Falls back to defaultEnvironment in config.",
+    ),
+  ),
+  dryRun: Flag.boolean("dry-run").pipe(
+    Flag.withAlias("d"),
+    Flag.withDescription("Show command without executing"),
+    Flag.withDefault(false),
+  ),
+  format: formatOption,
+  profile: Flag.optional(Flag.string("profile")).pipe(
+    Flag.withDescription("Kubernetes profile name (if multiple configured)"),
+  ),
+};
+
+const buildKubectlCommand = (base: string, args: ReadonlyArray<string>) => {
+  const extras = args.filter((part) => part.length > 0);
+  return extras.length === 0 ? base : `${base} ${extras.join(" ")}`;
+};
+
+const resolveStructuredNamespace = (
+  namespaceOption: Option.Option<string>,
+  envOption: Option.Option<string>,
+  profileOption: Option.Option<string>,
+) =>
+  Effect.gen(function* () {
+    const explicitNamespace = Option.getOrUndefined(namespaceOption);
+    if (explicitNamespace) return explicitNamespace;
+
+    const config = yield* ConfigService;
+    const resolvedEnv = yield* resolveEnv(envOption, config);
+    const profileName = Option.getOrUndefined(profileOption);
+    const k8sConfig = getToolConfig<K8sConfig>(config, "kubernetes", profileName);
+
+    if (!k8sConfig) return undefined;
+
+    return k8sConfig.namespaces[resolvedEnv];
+  });
 
 const kubectlCommand = Command.make(
   "kubectl",
   {
-    env: Flag.choice("env", ["test", "prod"]).pipe(
-      Flag.withDescription("Target environment: test or prod"),
-    ),
+    ...commonFlags,
     cmd: Flag.string("cmd").pipe(
       Flag.withDescription('kubectl command (without "kubectl" prefix)'),
     ),
-    dryRun: Flag.boolean("dry-run").pipe(
-      Flag.withAlias("d"),
-      Flag.withDescription("Show command without executing"),
-      Flag.withDefault(false),
-    ),
-    format: formatOption,
-    profile: Flag.optional(Flag.string("profile")).pipe(
-      Flag.withDescription("Kubernetes profile name (if multiple configured)"),
-    ),
   },
-  ({ cmd, dryRun, format, profile }) =>
-    Effect.gen(function* () {
-      const config = yield* ConfigService;
-      const profileName = profile ? Option.getOrUndefined(profile) : undefined;
-      const k8sConfig = getToolConfig<K8sConfig>(config, "kubernetes", profileName);
-
-      if (!k8sConfig) {
-        const result: CommandResult = {
-          success: false,
-          error: "No Kubernetes configuration found",
-          executionTimeMs: 0,
-        };
-        yield* Console.log(formatOutput(result, format));
-        return;
-      }
-
-      const k8sService = yield* K8sService;
-      const result = yield* k8sService.runKubectl(cmd, dryRun).pipe(
-        Effect.catchTags({
-          K8sContextError: (error) => {
-            const result: CommandResult = {
-              success: false,
-              error: error.message,
-              executionTimeMs: 0,
-            };
-            return Effect.succeed(result);
-          },
-          K8sCommandError: (error) => {
-            const result: CommandResult = {
-              success: false,
-              error: error.message,
-              command: error.command,
-              executionTimeMs: 0,
-            };
-            return Effect.succeed(result);
-          },
-          K8sTimeoutError: (error) => {
-            const result: CommandResult = {
-              success: false,
-              error: error.message,
-              command: error.command,
-              executionTimeMs: error.timeoutMs,
-            };
-            return Effect.succeed(result);
-          },
-        }),
-      );
-
-      yield* Console.log(formatOutput(result, format));
-    }),
+  ({ cmd, dryRun, env, format, profile }) => runK8sCommand(cmd, { dryRun, env, format, profile }),
 ).pipe(
   Command.withDescription(
     `Kubernetes CLI Tool for Coding Agents
@@ -130,9 +222,169 @@ RELATED TOOLS:
   ),
 );
 
+const podsCommand = Command.make(
+  "pods",
+  {
+    ...commonFlags,
+    namespace: Flag.string("namespace").pipe(
+      Flag.withDescription("Namespace to query"),
+      Flag.optional,
+    ),
+    label: Flag.string("label").pipe(
+      Flag.withDescription("Label selector (key=value)"),
+      Flag.optional,
+    ),
+    wide: Flag.boolean("wide").pipe(
+      Flag.withDescription("Show additional pod information"),
+      Flag.withDefault(false),
+    ),
+  },
+  ({ dryRun, env, format, label, namespace, profile, wide }) =>
+    Effect.gen(function* () {
+      const resolvedNamespace = yield* resolveStructuredNamespace(namespace, env, profile);
+      const command = buildKubectlCommand("get pods", [
+        Option.match(label, {
+          onNone: () => "",
+          onSome: (value) => `-l ${value}`,
+        }),
+        resolvedNamespace ? `-n ${resolvedNamespace}` : "",
+        wide ? "-o wide" : "",
+      ]);
+      return yield* runK8sCommand(command, { dryRun, env, format, profile });
+    }),
+).pipe(Command.withDescription("List pods (get pods) with optional namespace/label/wide output"));
+
+const logsCommand = Command.make(
+  "logs",
+  {
+    ...commonFlags,
+    pod: Flag.string("pod").pipe(Flag.withDescription("Pod name")),
+    namespace: Flag.string("namespace").pipe(
+      Flag.withDescription("Namespace containing the pod"),
+      Flag.optional,
+    ),
+    container: Flag.string("container").pipe(
+      Flag.withDescription("Container name (for multi-container pods)"),
+      Flag.optional,
+    ),
+    tail: Flag.integer("tail").pipe(Flag.withDescription("Show last N log lines"), Flag.optional),
+    follow: Flag.boolean("follow").pipe(
+      Flag.withAlias("f"),
+      Flag.withDescription("Stream logs in real time"),
+      Flag.withDefault(false),
+    ),
+  },
+  ({ container, dryRun, env, follow, format, namespace, pod, profile, tail }) =>
+    Effect.gen(function* () {
+      const resolvedNamespace = yield* resolveStructuredNamespace(namespace, env, profile);
+      const command = buildKubectlCommand(`logs ${pod}`, [
+        resolvedNamespace ? `-n ${resolvedNamespace}` : "",
+        Option.match(container, {
+          onNone: () => "",
+          onSome: (value) => `-c ${value}`,
+        }),
+        Option.match(tail, {
+          onNone: () => "",
+          onSome: (value) => `--tail=${value}`,
+        }),
+        follow ? "-f" : "",
+      ]);
+      return yield* runK8sCommand(command, { dryRun, env, format, profile });
+    }),
+).pipe(Command.withDescription("Fetch pod logs with tail/follow/container selectors"));
+
+const describeCommand = Command.make(
+  "describe",
+  {
+    ...commonFlags,
+    resource: Flag.string("resource").pipe(
+      Flag.withDescription("Resource type (pod, deploy, svc, etc.)"),
+    ),
+    name: Flag.string("name").pipe(Flag.withDescription("Resource name")),
+    namespace: Flag.string("namespace").pipe(
+      Flag.withDescription("Namespace containing the resource"),
+      Flag.optional,
+    ),
+  },
+  ({ dryRun, env, format, name, namespace, profile, resource }) =>
+    Effect.gen(function* () {
+      const resolvedNamespace = yield* resolveStructuredNamespace(namespace, env, profile);
+      const command = buildKubectlCommand(`describe ${resource} ${name}`, [
+        resolvedNamespace ? `-n ${resolvedNamespace}` : "",
+      ]);
+      return yield* runK8sCommand(command, { dryRun, env, format, profile });
+    }),
+).pipe(Command.withDescription("Describe a Kubernetes resource by type and name"));
+
+const execCommand = Command.make(
+  "exec",
+  {
+    ...commonFlags,
+    pod: Flag.string("pod").pipe(Flag.withDescription("Pod name")),
+    execCmd: Flag.string("exec-cmd").pipe(
+      Flag.withDescription("Command to run inside the pod; wrap in quotes for spaces"),
+    ),
+    namespace: Flag.string("namespace").pipe(
+      Flag.withDescription("Namespace containing the pod"),
+      Flag.optional,
+    ),
+    container: Flag.string("container").pipe(
+      Flag.withDescription("Container name (for multi-container pods)"),
+      Flag.optional,
+    ),
+  },
+  ({ container, dryRun, env, execCmd, format, namespace, pod, profile }) =>
+    Effect.gen(function* () {
+      const resolvedNamespace = yield* resolveStructuredNamespace(namespace, env, profile);
+      const command = buildKubectlCommand(`exec ${pod}`, [
+        resolvedNamespace ? `-n ${resolvedNamespace}` : "",
+        Option.match(container, {
+          onNone: () => "",
+          onSome: (value) => `-c ${value}`,
+        }),
+        `-- ${execCmd}`,
+      ]);
+      return yield* runK8sCommand(command, { dryRun, env, format, profile });
+    }),
+).pipe(Command.withDescription("Execute a command in a pod (kubectl exec <pod> -- <cmd>)"));
+
+const topCommand = Command.make(
+  "top",
+  {
+    ...commonFlags,
+    namespace: Flag.string("namespace").pipe(
+      Flag.withDescription("Namespace to inspect"),
+      Flag.optional,
+    ),
+    sortBy: Flag.choice("sort-by", ["cpu", "memory"] as const).pipe(
+      Flag.withDescription("Sort metrics output when supported by kubectl"),
+      Flag.optional,
+    ),
+  },
+  ({ dryRun, env, format, namespace, profile, sortBy }) =>
+    Effect.gen(function* () {
+      const resolvedNamespace = yield* resolveStructuredNamespace(namespace, env, profile);
+      const command = buildKubectlCommand("top pod", [
+        resolvedNamespace ? `-n ${resolvedNamespace}` : "",
+        Option.match(sortBy, {
+          onNone: () => "",
+          onSome: (value) => `--sort-by=${value}`,
+        }),
+      ]);
+      return yield* runK8sCommand(command, { dryRun, env, format, profile });
+    }),
+).pipe(Command.withDescription("Show pod CPU/memory usage (kubectl top pod)"));
+
 const mainCommand = Command.make("k8s-tool", {}).pipe(
   Command.withDescription("Kubernetes CLI Tool for Coding Agents"),
-  Command.withSubcommands([kubectlCommand]),
+  Command.withSubcommands([
+    kubectlCommand,
+    podsCommand,
+    logsCommand,
+    describeCommand,
+    execCommand,
+    topCommand,
+  ]),
 );
 
 const cli = Command.run(mainCommand, {

package/src/k8s-tool/service.ts

@@ -4,8 +4,8 @@ import { Effect, Layer, Option, Ref, ServiceMap, Stream } from "effect";
 import type { CommandResult, Environment } from "./types";
 
 import { K8sCommandError, K8sContextError, K8sTimeoutError } from "./errors";
-import { ConfigService, getToolConfig } from "../config";
-import type { K8sConfig } from "../config";
+import { ConfigService, getToolConfig } from "#src/config";
+import type { K8sConfig } from "#src/config";
 
 export class K8sService extends ServiceMap.Service<
   K8sService,

package/src/k8s-tool/types.ts

@@ -6,4 +6,8 @@ export type CommandResult = {
   error?: string;
   command?: string;
   executionTimeMs: number;
+  hint?: string;
+  nextCommand?: string;
+  retryable?: boolean;
+  environment?: string;
 };

package/src/logs-tool/errors.ts

@@ -5,16 +5,25 @@ export class LogsNotFoundError extends Schema.TaggedErrorClass<LogsNotFoundError
   {
     message: Schema.String,
     path: Schema.String,
+    hint: Schema.optionalKey(Schema.String),
+    nextCommand: Schema.optionalKey(Schema.String),
+    retryable: Schema.optionalKey(Schema.Boolean),
   },
 ) {}
 
 export class LogsReadError extends Schema.TaggedErrorClass<LogsReadError>()("LogsReadError", {
   message: Schema.String,
   source: Schema.String,
+  hint: Schema.optionalKey(Schema.String),
+  nextCommand: Schema.optionalKey(Schema.String),
+  retryable: Schema.optionalKey(Schema.Boolean),
 }) {}
 
 export class LogsConfigError extends Schema.TaggedErrorClass<LogsConfigError>()("LogsConfigError", {
   message: Schema.String,
+  hint: Schema.optionalKey(Schema.String),
+  nextCommand: Schema.optionalKey(Schema.String),
+  retryable: Schema.optionalKey(Schema.Boolean),
 }) {}
 
 export class LogsTimeoutError extends Schema.TaggedErrorClass<LogsTimeoutError>()(
@@ -23,6 +32,9 @@ export class LogsTimeoutError extends Schema.TaggedErrorClass<LogsTimeoutError>(
     message: Schema.String,
     source: Schema.String,
     timeoutMs: Schema.Number,
+    hint: Schema.optionalKey(Schema.String),
+    nextCommand: Schema.optionalKey(Schema.String),
+    retryable: Schema.optionalKey(Schema.Boolean),
   },
 ) {}
 

package/src/logs-tool/index.ts

@@ -20,8 +20,9 @@ import { Console, Effect, Layer, Option, Result } from "effect";
 
 import type { Environment, LogResult, ReadOptions } from "./types";
 
-import { formatOption, formatOutput, renderCauseToStderr, VERSION } from "../shared";
-import { LogsNotFoundError } from "./errors";
+import { formatOption, formatOutput, renderCauseToStderr, VERSION } from "#src/shared";
+import { ConfigService, ConfigServiceLayer, getDefaultEnvironment } from "#src/config";
+import { LogsConfigError, LogsNotFoundError, LogsReadError, LogsTimeoutError } from "./errors";
 import { LogsService, LogsServiceLayer } from "./service";
 
 const profileOption = Flag.optional(
@@ -32,6 +33,36 @@ const profileOption = Flag.optional(
   ),
 );
 
+/**
+ * Resolve environment from explicit --env flag, config defaultEnvironment, or fail with hint.
+ */
+const resolveEnv = (envOption: Option.Option<string>) =>
+  Effect.gen(function* () {
+    const explicit = Option.getOrUndefined(envOption);
+    if (explicit) return explicit;
+
+    const config = yield* ConfigService;
+    const defaultEnv = getDefaultEnvironment(config);
+
+    if (defaultEnv === "prod") {
+      return yield* new LogsConfigError({
+        message:
+          "Implicit prod access blocked. Config defaultEnvironment is 'prod' but --env was not passed explicitly.",
+        hint: "Pass --env prod explicitly to confirm production access, or change defaultEnvironment to a non-prod value.",
+        nextCommand: "agent-tools-logs list --env prod",
+      });
+    }
+
+    if (defaultEnv) return defaultEnv;
+
+    return yield* new LogsConfigError({
+      message:
+        "No environment specified. Use --env <name> or set defaultEnvironment in agent-tools.json5.",
+      hint: 'Set defaultEnvironment in agent-tools.json5 (e.g. defaultEnvironment: "local") or pass --env explicitly.',
+      nextCommand: "agent-tools-logs list --env local",
+    });
+  });
+
 const buildSource = (
   mode: "list" | "read",
   env: Environment,
@@ -56,20 +87,23 @@ const buildSource = (
 const listCommand = Command.make(
   "list",
   {
-    env: Flag.choice("env", ["local", "test", "prod"]).pipe(
-      Flag.withDescription("Target environment"),
+    env: Flag.optional(Flag.string("env")).pipe(
+      Flag.withDescription(
+        "Target environment (e.g. local, test, prod). Falls back to defaultEnvironment in config.",
+      ),
     ),
     format: formatOption,
     profile: profileOption,
   },
   ({ env, format, profile }) =>
     Effect.gen(function* () {
+      const resolvedEnv = yield* resolveEnv(env);
       const logsService = yield* LogsService;
       const startTime = Date.now();
       const profileName = Option.getOrUndefined(profile);
 
       const result = yield* logsService
-        .listLogs(env as Environment, profileName)
+        .listLogs(resolvedEnv as Environment, profileName)
         .pipe(Effect.result);
       const executionTimeMs = Date.now() - startTime;
 
@@ -79,11 +113,22 @@ const listCommand = Command.make(
           error: error.message,
           source: error instanceof LogsNotFoundError ? error.path : undefined,
           executionTimeMs,
+          hint:
+            error.hint ??
+            (error instanceof LogsReadError && error.source === "config"
+              ? "Add a 'logs' section to agent-tools.json5 with localDir and remotePath."
+              : undefined),
+          nextCommand:
+            error.nextCommand ??
+            (error instanceof LogsReadError && error.source === "config"
+              ? "agent-tools-logs list --env local"
+              : undefined),
+          retryable: error.retryable ?? (error instanceof LogsTimeoutError ? true : undefined),
         }),
         onSuccess: (data) => ({
           success: true,
           data,
-          source: buildSource("list", env as Environment, undefined, null),
+          source: buildSource("list", resolvedEnv as Environment, undefined, null),
           executionTimeMs,
         }),
       });
@@ -95,8 +140,10 @@ const listCommand = Command.make(
 const readCommand = Command.make(
   "read",
   {
-    env: Flag.choice("env", ["local", "test", "prod"]).pipe(
-      Flag.withDescription("Target environment"),
+    env: Flag.optional(Flag.string("env")).pipe(
+      Flag.withDescription(
+        "Target environment (e.g. local, test, prod). Falls back to defaultEnvironment in config.",
+      ),
     ),
     file: Flag.string("file").pipe(
       Flag.withDescription("Specific log file to read"),
@@ -119,6 +166,7 @@ const readCommand = Command.make(
   },
   ({ env, file, format, grep, pretty, profile, tail }) =>
     Effect.gen(function* () {
+      const resolvedEnv = yield* resolveEnv(env);
       const logsService = yield* LogsService;
       const startTime = Date.now();
       const profileName = Option.getOrUndefined(profile);
@@ -131,7 +179,7 @@ const readCommand = Command.make(
       };
 
       const result = yield* logsService
-        .readLogs(env as Environment, readOptions, profileName)
+        .readLogs(resolvedEnv as Environment, readOptions, profileName)
         .pipe(Effect.result);
       const executionTimeMs = Date.now() - startTime;
 
@@ -141,11 +189,22 @@ const readCommand = Command.make(
           error: error.message,
           source: error instanceof LogsNotFoundError ? error.path : undefined,
           executionTimeMs,
+          hint:
+            error.hint ??
+            (error instanceof LogsReadError && error.source === "config"
+              ? "Add a 'logs' section to agent-tools.json5 with localDir and remotePath."
+              : undefined),
+          nextCommand:
+            error.nextCommand ??
+            (error instanceof LogsReadError && error.source === "config"
+              ? "agent-tools-logs read --env local --file app.log"
+              : undefined),
+          retryable: error.retryable ?? (error instanceof LogsTimeoutError ? true : undefined),
         }),
         onSuccess: (data) => ({
           success: true,
           data,
-          source: buildSource("read", env as Environment, undefined, readOptions),
+          source: buildSource("read", resolvedEnv as Environment, undefined, readOptions),
           executionTimeMs,
         }),
       });
@@ -167,7 +226,10 @@ export const run = Command.runWith(mainCommand, {
   version: VERSION,
 });
 
-const MainLayer = LogsServiceLayer.pipe(Layer.provideMerge(BunServices.layer));
+const MainLayer = LogsServiceLayer.pipe(
+  Layer.provideMerge(ConfigServiceLayer),
+  Layer.provideMerge(BunServices.layer),
+);
 
 const program = cli.pipe(Effect.provide(MainLayer), Effect.tapCause(renderCauseToStderr));
 

package/src/logs-tool/service.ts

@@ -3,10 +3,10 @@ import { Effect, Layer, Result, ServiceMap, Stream } from "effect";
 
 import type { Environment, LogFile, ReadOptions } from "./types";
 
-import { K8sCommandError } from "../k8s-tool/errors";
-import { K8sService, K8sServiceLayer } from "../k8s-tool/service";
-import { ConfigService, ConfigServiceLayer, getToolConfig } from "../config/loader";
-import type { LogsConfig } from "../config/types";
+import { K8sCommandError } from "#src/k8s-tool/errors";
+import { K8sService, K8sServiceLayer } from "#src/k8s-tool/service";
+import { ConfigService, ConfigServiceLayer, getToolConfig } from "#src/config/loader";
+import type { LogsConfig } from "#src/config/types";
 import { LogsNotFoundError, LogsReadError, type LogsError } from "./errors";
 
 export const parseLogFiles = (output: string): LogFile[] => {

package/src/logs-tool/types.ts

@@ -1,4 +1,4 @@
-import type { Environment, OutputFormat } from "../shared";
+import type { Environment, OutputFormat } from "#src/shared";
 export type { Environment, OutputFormat };
 
 export type LogFile = {
@@ -20,6 +20,9 @@ export type LogResult = {
   error?: string;
   source?: string;
   executionTimeMs: number;
+  hint?: string;
+  nextCommand?: string;
+  retryable?: boolean;
 };
 
 export type ParsedArgs =

package/src/session-tool/config.ts

@@ -2,7 +2,7 @@ import { Effect, Layer, ServiceMap } from "effect";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import { loadConfig } from "../config/loader";
+import { loadConfig } from "#src/config/loader";
 
 /**
  * Resolves the OpenCode storage base path from config or default.

package/src/session-tool/index.ts

@@ -13,7 +13,7 @@ import { Console, Effect, Layer, Result } from "effect";
 
 import type { MessageSummary, SessionResult } from "./types";
 
-import { formatOption, formatOutput, VERSION } from "../shared";
+import { formatOption, formatOutput, VERSION } from "#src/shared";
 import { ResolvedPaths, ResolvedPathsLayer } from "./config";
 import { SessionStorageNotFoundError } from "./errors";
 import { formatDate, SessionService, SessionServiceLayer, truncate } from "./service";