@blogic-cz/agent-tools 0.14.45 → 0.14.47

package/README.md

@@ -312,7 +312,19 @@ All settings are optional — audit works out of the box with sensible defaults.
 
 ## Configuration
 
-Config is loaded from `agent-tools.json5` (or `agent-tools.json`) by walking up from the current working directory. Missing config = zero-config mode (works for `gh-tool`; others require config).
+Config is loaded by walking up from the current working directory to the nearest regular config file:
+
+1. `agent-tools.json`
+2. `agent-tools.json5`
+
+That nearest regular config is the base. Local override files are then merged from that directory down to the current working directory:
+
+1. `agent-tools.local.json`
+2. `agent-tools.local.json5`
+
+Later files override earlier files. Objects are merged deeply; arrays and primitive values are replaced. Missing config = zero-config mode (works for `gh-tool`; others require config).
+
+Use `agent-tools.local.json5` for machine-specific ports, paths, and worktree overrides. Keep local files gitignored.
 
 ### Global Settings
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.14.45",
+  "version": "0.14.47",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",

package/src/config/loader.ts

@@ -194,8 +194,12 @@ const AgentToolsConfigSchema = Schema.Struct({
   github: Schema.optionalKey(Schema.Record(Schema.String, GitHubRepoConfigSchema)),
 });
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 function stripUnknownTopLevelKeys(parsed: unknown): unknown {
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+  if (!isRecord(parsed)) {
     return parsed;
   }
 
@@ -223,40 +227,101 @@ export function decodeConfig(
   }
 }
 
-async function findConfigFile(startDirectory: string = process.cwd()): Promise<string | undefined> {
+const BASE_CONFIG_FILES = ["agent-tools.json", "agent-tools.json5"] as const;
+const LOCAL_CONFIG_FILES = ["agent-tools.local.json", "agent-tools.local.json5"] as const;
+
+async function existingFile(filePath: string): Promise<string | undefined> {
+  return (await Bun.file(filePath).exists()) ? filePath : undefined;
+}
+
+async function findBaseConfigDirectory(
+  startDirectory: string = process.cwd(),
+): Promise<string | undefined> {
   let currentDirectory = startDirectory;
 
   while (true) {
-    const json5Path = `${currentDirectory}/agent-tools.json5`;
-    // eslint-disable-next-line eslint/no-await-in-loop -- sequential directory walk, each iteration may short-circuit
-    if (await Bun.file(json5Path).exists()) {
-      return json5Path;
+    for (const fileName of BASE_CONFIG_FILES) {
+      // eslint-disable-next-line eslint/no-await-in-loop -- sequential directory walk, each iteration may short-circuit
+      if (await Bun.file(`${currentDirectory}/${fileName}`).exists()) {
+        return currentDirectory;
+      }
     }
 
-    const jsonPath = `${currentDirectory}/agent-tools.json`;
-    // eslint-disable-next-line eslint/no-await-in-loop -- sequential directory walk, each iteration may short-circuit
-    if (await Bun.file(jsonPath).exists()) {
-      return jsonPath;
+    const parentDirectory = dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      return undefined;
+    }
+    currentDirectory = parentDirectory;
+  }
+}
+
+async function findConfigFiles(startDirectory: string = process.cwd()): Promise<readonly string[]> {
+  const baseDirectory = await findBaseConfigDirectory(startDirectory);
+  if (!baseDirectory) {
+    return [];
+  }
+
+  const directories: string[] = [];
+  let currentDirectory = startDirectory;
+  while (true) {
+    directories.push(currentDirectory);
+    if (currentDirectory === baseDirectory) {
+      break;
     }
 
     const parentDirectory = dirname(currentDirectory);
     if (parentDirectory === currentDirectory) {
-      return undefined;
+      return [];
     }
     currentDirectory = parentDirectory;
   }
+  directories.reverse();
+
+  const configFiles: string[] = [];
+  for (const directory of directories) {
+    const fileNames =
+      directory === baseDirectory
+        ? [...BASE_CONFIG_FILES, ...LOCAL_CONFIG_FILES]
+        : LOCAL_CONFIG_FILES;
+
+    for (const fileName of fileNames) {
+      // eslint-disable-next-line eslint/no-await-in-loop -- config precedence is directory/file order
+      const filePath = await existingFile(`${directory}/${fileName}`);
+      if (filePath) {
+        configFiles.push(filePath);
+      }
+    }
+  }
+
+  return configFiles;
+}
+
+function mergeConfigValue(left: unknown, right: unknown): unknown {
+  if (!isRecord(left) || !isRecord(right)) {
+    return right;
+  }
+
+  const merged: Record<string, unknown> = { ...left };
+  for (const [key, value] of Object.entries(right)) {
+    merged[key] = key in merged ? mergeConfigValue(merged[key], value) : value;
+  }
+  return merged;
 }
 
 export async function loadConfig(): Promise<AgentToolsConfig | undefined> {
-  const configPath = await findConfigFile();
-  if (!configPath) {
+  const configPaths = await findConfigFiles();
+  if (configPaths.length === 0) {
     return undefined;
   }
 
-  const fileContent = await Bun.file(configPath).text();
-  const parsed = Bun.JSON5.parse(fileContent);
+  let parsed: unknown = {};
+  for (const configPath of configPaths) {
+    // eslint-disable-next-line eslint/no-await-in-loop -- config precedence is file order
+    const fileContent = await Bun.file(configPath).text();
+    parsed = mergeConfigValue(parsed, Bun.JSON5.parse(fileContent));
+  }
 
-  return decodeConfig(parsed, configPath);
+  return decodeConfig(parsed, configPaths.join(", "));
 }
 
 export class ConfigService extends Context.Service<ConfigService, AgentToolsConfig | undefined>()(

package/src/db-tool/index.ts

@@ -64,16 +64,21 @@ const sqlCommand = Command.make(
       ),
     ),
     sql: Flag.string("sql").pipe(Flag.withDescription("SQL query to execute")),
+    limit: Flag.optional(Flag.integer("limit")).pipe(
+      Flag.withDescription(
+        "Max rows to return (default 50). Use 0 for no cap. Prefer a SQL LIMIT for large tables.",
+      ),
+    ),
     format: formatOption,
     profile: Flag.optional(Flag.string("profile")).pipe(
       Flag.withDescription("Database profile name from agent-tools.json5 (if multiple configured)"),
     ),
   },
-  ({ env, sql, format }) =>
+  ({ env, sql, limit, format }) =>
     Effect.gen(function* () {
       const resolvedEnv = yield* resolveEnv(env);
       const db = yield* DbService;
-      const result = yield* db.executeQuery(resolvedEnv, sql);
+      const result = yield* db.executeQuery(resolvedEnv, sql, Option.getOrUndefined(limit));
       yield* Console.log(formatOutput(result, format));
     }),
 ).pipe(Command.withDescription("Execute a SQL query"));

package/src/db-tool/service.ts

@@ -59,7 +59,11 @@ export { buildApiProbeArgs } from "#shared/k8s-probe";
 export class DbService extends Context.Service<
   DbService,
   {
-    readonly executeQuery: (env: string, sql: string) => Effect.Effect<QueryResult, DbError>;
+    readonly executeQuery: (
+      env: string,
+      sql: string,
+      limit?: number,
+    ) => Effect.Effect<QueryResult, DbError>;
     readonly executeSchemaQuery: (
       env: string,
       mode: SchemaMode,
@@ -83,7 +87,8 @@ export class DbService extends Context.Service<
               environment: env,
             });
           return {
-            executeQuery: (env: string, _sql: string) => Effect.fail(noConfigError(env)),
+            executeQuery: (env: string, _sql: string, _limit?: number) =>
+              Effect.fail(noConfigError(env)),
             executeSchemaQuery: (env: string, _mode: SchemaMode, _table?: string) =>
               Effect.fail(noConfigError(env)),
           };
@@ -468,6 +473,7 @@ export class DbService extends Context.Service<
           password: string,
           startTimeMs: number,
           applyTransform = false,
+          limit?: number,
         ) {
           const selectSql = sql.trim().replace(/;\s*$/, "");
           const wrappedSql = `SELECT json_agg(t) FROM (${selectSql}) t;`;
@@ -532,7 +538,7 @@ export class DbService extends Context.Service<
           });
 
           const transformed = applyTransform
-            ? transformQueryResult(rawData)
+            ? transformQueryResult(rawData, limit)
             : {
                 data: rawData,
                 showing: rawData.length,
@@ -720,6 +726,7 @@ export class DbService extends Context.Service<
         const executeQuery = Effect.fn("DbService.executeQuery")(function* (
           env: string,
           sql: string,
+          limit?: number,
         ) {
           const config = yield* getConfigForEnv(env);
           const startTimeMs = yield* Clock.currentTimeMillis;
@@ -753,7 +760,7 @@ export class DbService extends Context.Service<
 
           const queryEffect = mutation
             ? executeMutationQuery(resolvedConfig, sql, password, Number(startTimeMs))
-            : executeSelectQuery(resolvedConfig, sql, password, Number(startTimeMs), true);
+            : executeSelectQuery(resolvedConfig, sql, password, Number(startTimeMs), true, limit);
 
           return yield* runWithVpnPrerequisites(
             resolvedConfig.port,

package/src/db-tool/transformers.ts

@@ -22,12 +22,17 @@ function truncateValue(value: unknown): unknown {
   return `${value.slice(0, MAX_VALUE_LENGTH)}...`;
 }
 
-export function transformQueryResult(data: Record<string, unknown>[]): TransformResult {
+export function transformQueryResult(
+  data: Record<string, unknown>[],
+  // limit 0 (or negative) means "no row cap".
+  limit: number = DEFAULT_ROW_LIMIT,
+): TransformResult {
   const withoutEmptyColumns = stripEmptyColumns(data);
   const truncatedValues = withoutEmptyColumns.map((record) =>
     Object.fromEntries(Object.entries(record).map(([key, value]) => [key, truncateValue(value)])),
   );
-  const { rows, truncated, total, showing } = truncateRows(truncatedValues, DEFAULT_ROW_LIMIT);
+  const effectiveLimit = limit > 0 ? limit : Number.POSITIVE_INFINITY;
+  const { rows, truncated, total, showing } = truncateRows(truncatedValues, effectiveLimit);
 
   return {
     data: rows,