@blogic-cz/agent-tools 0.14.10 → 0.14.11

package/package.json

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

package/src/db-tool/schema.ts

@@ -5,18 +5,39 @@
  * This is a known limitation — callers must validate the table name
  * via `isValidTableName()` before calling `getColumns()`.
  */
+export const SYSTEM_SCHEMAS_SQL = "'pg_catalog', 'information_schema'";
+
+export function parseTableReference(tableName: string): { schemaName?: string; tableName: string } {
+  const [schemaName, name, ...extra] = tableName.split(".");
+
+  if (name && extra.length === 0) {
+    return { schemaName, tableName: name };
+  }
+
+  return { tableName };
+}
+
 export const SCHEMA_QUERIES = {
   tables: `
-    SELECT tablename as name
+    SELECT
+      schemaname as schema,
+      tablename as name,
+      schemaname || '.' || tablename as qualified_name
     FROM pg_tables
-    WHERE schemaname = 'public'
-    ORDER BY tablename
+    WHERE schemaname NOT IN (${SYSTEM_SCHEMAS_SQL})
+    ORDER BY schemaname, tablename
   `,
   columns: (tableName: string) => {
-    const escapedTableName = tableName.replaceAll("'", "''");
+    const tableReference = parseTableReference(tableName);
+    const escapedTableName = tableReference.tableName.replaceAll("'", "''");
+    const schemaFilter = tableReference.schemaName
+      ? `AND c.table_schema = '${tableReference.schemaName.replaceAll("'", "''")}'`
+      : `AND c.table_schema NOT IN (${SYSTEM_SCHEMAS_SQL})`;
 
     return `
     SELECT
+      c.table_schema as schema,
+      c.table_name as table,
       c.column_name as name,
       c.data_type as type,
       c.is_nullable = 'YES' as nullable,
@@ -32,14 +53,16 @@ export const SCHEMA_QUERIES = {
       ) as is_primary_key
     FROM information_schema.columns c
     WHERE c.table_name = '${escapedTableName}'
-    AND c.table_schema = 'public'
-    ORDER BY c.ordinal_position
+    ${schemaFilter}
+    ORDER BY c.table_schema, c.ordinal_position
   `;
   },
   relationships: `
     SELECT
+      tc.table_schema as from_schema,
       tc.table_name as from_table,
       kcu.column_name as from_column,
+      ccu.table_schema as to_schema,
       ccu.table_name as to_table,
       ccu.column_name as to_column,
       tc.constraint_name
@@ -49,10 +72,10 @@ export const SCHEMA_QUERIES = {
       AND tc.table_schema = kcu.table_schema
     JOIN information_schema.constraint_column_usage ccu
       ON ccu.constraint_name = tc.constraint_name
-      AND ccu.table_schema = tc.table_schema
+      AND ccu.constraint_schema = tc.constraint_schema
     WHERE tc.constraint_type = 'FOREIGN KEY'
-    AND tc.table_schema = 'public'
-    ORDER BY tc.table_name, kcu.column_name
+    AND tc.table_schema NOT IN (${SYSTEM_SCHEMAS_SQL})
+    ORDER BY tc.table_schema, tc.table_name, kcu.column_name
   `,
 };
 

package/src/db-tool/security.ts

@@ -10,7 +10,7 @@ const MUTATION_PATTERNS = [
   /^\s*CREATE\s+/i,
 ];
 
-const TABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const TABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)?$/;
 
 /**
  * Strip SQL comments (block and line) while preserving string literals.

package/src/db-tool/service.ts

@@ -15,7 +15,13 @@ import {
   DbTunnelError,
   type DbError,
 } from "./errors";
-import { getColumns, getRelationships, getTableNames } from "./schema";
+import {
+  getColumns,
+  getRelationships,
+  getTableNames,
+  parseTableReference,
+  SYSTEM_SCHEMAS_SQL,
+} from "./schema";
 import { detectSchemaError, isValidTableName, isMutationQuery } from "./security";
 import { transformQueryResult } from "./transformers";
 
@@ -324,7 +330,7 @@ export class DbService extends Context.Service<
         ) {
           const command = buildPsqlCommand(
             config,
-            "SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename;",
+            `SELECT schemaname || '.' || tablename FROM pg_tables WHERE schemaname NOT IN (${SYSTEM_SCHEMAS_SQL}) ORDER BY schemaname, tablename;`,
             password,
             true,
           );
@@ -356,11 +362,16 @@ export class DbService extends Context.Service<
             return [] as string[];
           }
 
-          const escapedTableName = tableName.replaceAll("'", "''");
+          const tableReference = parseTableReference(tableName);
+          const escapedSchemaName = tableReference.schemaName?.replaceAll("'", "''");
+          const escapedTableName = tableReference.tableName.replaceAll("'", "''");
+          const schemaFilter = escapedSchemaName
+            ? `AND table_schema = '${escapedSchemaName}'`
+            : `AND table_schema NOT IN (${SYSTEM_SCHEMAS_SQL})`;
 
           const command = buildPsqlCommand(
             config,
-            `SELECT column_name FROM information_schema.columns WHERE table_name = '${escapedTableName}' AND table_schema = 'public' ORDER BY ordinal_position;`,
+            `SELECT column_name FROM information_schema.columns WHERE table_name = '${escapedTableName}' ${schemaFilter} ORDER BY table_schema, ordinal_position;`,
             password,
             true,
           );
@@ -516,21 +527,25 @@ export class DbService extends Context.Service<
           }
 
           const tables = tablesResult.data as {
+            schema?: string;
             name: string;
+            qualified_name?: string;
           }[];
           const fullSchema: Record<string, unknown>[] = [];
 
           for (const table of tables) {
             const columnsResult = yield* executeSelectQuery(
               config,
-              getColumns(table.name),
+              getColumns(table.qualified_name ?? table.name),
               password,
               startTimeMs,
             ).pipe(Effect.catch(() => Effect.succeed(null)));
 
             if (columnsResult && columnsResult.success && columnsResult.data) {
               fullSchema.push({
+                schema: table.schema,
                 table: table.name,
+                qualified_name: table.qualified_name ?? table.name,
                 columns: columnsResult.data,
               });
             }
@@ -668,7 +683,7 @@ export class DbService extends Context.Service<
               return {
                 success: false,
                 error:
-                  "Invalid table name. Use only letters, numbers, and underscores, and start with a letter or underscore.",
+                  "Invalid table name. Use only letters, numbers, underscores, and an optional schema prefix, and start each identifier with a letter or underscore.",
                 executionTimeMs: Number(endTime) - Number(startTimeMs),
               };
             }

package/src/observability-tool/index.ts

@@ -10,7 +10,6 @@ import { AuditServiceLayer, withAudit } from "#shared/audit";
 import { VERSION } from "#shared";
 
 import { metricsCommand } from "./metrics";
-import { logsCommand } from "./logs";
 import { traceCommand } from "./trace";
 
 const renderCauseToStderr = (cause: Cause.Cause<unknown>) => Console.error(cause.toString());
@@ -19,7 +18,7 @@ const mainCommand = Command.make("observability-tool", {}).pipe(
   Command.withDescription(
     "LGTM observability queries — Tempo traces, Loki logs, Prometheus metrics",
   ),
-  Command.withSubcommands([traceCommand, metricsCommand, logsCommand]),
+  Command.withSubcommands([traceCommand, metricsCommand]),
 );
 
 const cli = Command.run(mainCommand, { version: VERSION });

package/src/observability-tool/trace.ts

@@ -13,7 +13,6 @@ import {
   profileOption,
   resolveConfig,
 } from "./shared";
-import { extractLogsFromDsQuery } from "./logs";
 import type {
   FlattenedSpan,
   ObservabilityEnvConfig,
@@ -222,6 +221,18 @@ function summarizeTrace(traceId: string, spans: readonly FlattenedSpan[]): Trace
   };
 }
 
+function parseLabel(value: string | Record<string, string>): Record<string, string> {
+  if (typeof value === "object" && value !== null) {
+    return value;
+  }
+
+  try {
+    return JSON.parse(value) as Record<string, string>;
+  } catch {
+    return {};
+  }
+}
+
 type ResolvedTrace = {
   readonly resolution: SpanResolution;
   readonly spans: FlattenedSpan[];
@@ -471,7 +482,34 @@ const logsCommand = Command.make(
         });
       }
 
-      const logs = extractLogsFromDsQuery(response);
+      const logs: Array<{ timestamp: string; line: string; labels: Record<string, string> }> = [];
+      for (const frame of response.results.A.frames ?? []) {
+        const fields = frame.schema.fields;
+        const values = frame.data.values;
+        const timeIndex = fields.findIndex(
+          (field) => field.name === "timestamp" || field.type === "time",
+        );
+        const lineIndex = fields.findIndex(
+          (field) => field.name === "body" || field.name === "Line" || field.name === "line",
+        );
+        const labelsIndex = fields.findIndex(
+          (field) => field.name === "labels" || field.name === "labelTypes",
+        );
+
+        const timestamps = (timeIndex >= 0 ? values[timeIndex] : []) as Array<string | number>;
+        const lines = (lineIndex >= 0 ? values[lineIndex] : []) as string[];
+        const labelValues = (labelsIndex >= 0 ? values[labelsIndex] : []) as Array<
+          string | Record<string, string>
+        >;
+
+        for (const [index, line] of lines.entries()) {
+          logs.push({
+            timestamp: String(timestamps[index] ?? ""),
+            line,
+            labels: labelValues[index] ? parseLabel(labelValues[index]) : {},
+          });
+        }
+      }
 
       const result = {
         success: true,

package/src/observability-tool/logs.ts

@@ -1,185 +0,0 @@
-import { Console, Effect } from "effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
-
-import { formatOption, formatOutput } from "#shared";
-
-import { ObservabilityToolError } from "./errors";
-import {
-  envOption,
-  formatObservabilityError,
-  observabilityDsQuery,
-  profileOption,
-  resolveConfig,
-} from "./shared";
-
-type LogLine = {
-  readonly timestamp: string;
-  readonly line: string;
-  readonly body?: string;
-  readonly severity?: string;
-  readonly attributes?: Record<string, unknown>;
-  readonly labels: Record<string, string>;
-};
-
-type StructuredLogLine = {
-  readonly body?: string;
-  readonly severity?: string;
-  readonly attributes?: Record<string, unknown>;
-};
-
-function parseLabel(value: string | Record<string, string>): Record<string, string> {
-  if (typeof value === "object" && value !== null) {
-    return value;
-  }
-
-  try {
-    return JSON.parse(value) as Record<string, string>;
-  } catch {
-    return {};
-  }
-}
-
-function parseStructuredLogLine(line: string): StructuredLogLine {
-  try {
-    const parsed = JSON.parse(line) as unknown;
-    if (typeof parsed !== "object" || parsed === null) {
-      return {};
-    }
-
-    const record = parsed as Record<string, unknown>;
-    return {
-      body: typeof record.body === "string" ? record.body : undefined,
-      severity: typeof record.severity === "string" ? record.severity : undefined,
-      attributes:
-        typeof record.attributes === "object" && record.attributes !== null
-          ? (record.attributes as Record<string, unknown>)
-          : undefined,
-    };
-  } catch {
-    return {};
-  }
-}
-
-export function extractLogsFromDsQuery(response: {
-  results: {
-    A: {
-      frames?: Array<{
-        schema: { fields: Array<{ name: string; type?: string }> };
-        data: { values: unknown[][] };
-      }>;
-    };
-  };
-}): LogLine[] {
-  const logs: LogLine[] = [];
-
-  for (const frame of response.results.A.frames ?? []) {
-    const fields = frame.schema.fields;
-    const values = frame.data.values;
-    const timeIndex = fields.findIndex(
-      (field) => field.name === "timestamp" || field.name === "Time" || field.type === "time",
-    );
-    const lineIndex = fields.findIndex(
-      (field) => field.name === "body" || field.name === "Line" || field.name === "line",
-    );
-    const labelsIndex = fields.findIndex(
-      (field) => field.name === "labels" || field.name === "labelTypes",
-    );
-
-    const timestamps = (timeIndex >= 0 ? values[timeIndex] : []) as Array<string | number>;
-    const lines = (lineIndex >= 0 ? values[lineIndex] : []) as string[];
-    const labelValues = (labelsIndex >= 0 ? values[labelsIndex] : []) as Array<
-      string | Record<string, string>
-    >;
-
-    for (const [index, line] of lines.entries()) {
-      const structured = parseStructuredLogLine(line);
-      logs.push({
-        timestamp: String(timestamps[index] ?? ""),
-        line,
-        ...structured,
-        labels: labelValues[index] ? parseLabel(labelValues[index]) : {},
-      });
-    }
-  }
-
-  return logs;
-}
-
-const queryCommand = Command.make(
-  "query",
-  {
-    logql: Argument.string("logql"),
-    format: formatOption,
-    env: envOption,
-    profile: profileOption,
-    start: Flag.string("start").pipe(
-      Flag.withDescription("Start time (default: now-1h)"),
-      Flag.withDefault("now-1h"),
-    ),
-    end: Flag.string("end").pipe(
-      Flag.withDescription("End time (default: now)"),
-      Flag.withDefault("now"),
-    ),
-    limit: Flag.integer("limit").pipe(
-      Flag.withDescription("Max log lines (default: 100)"),
-      Flag.withDefault(100),
-    ),
-  },
-  ({ logql, format, env, profile, start, end, limit }) => {
-    const startedAt = Date.now();
-
-    return Effect.gen(function* () {
-      const config = yield* resolveConfig(env, profile);
-      const response = yield* observabilityDsQuery(config, config.lokiUid, "loki", logql, {
-        from: start,
-        to: end,
-        maxLines: limit,
-      });
-
-      if (response.results.A.error) {
-        return yield* new ObservabilityToolError({ cause: new Error(response.results.A.error) });
-      }
-
-      const logs = extractLogsFromDsQuery(response).toSorted((left, right) =>
-        right.timestamp.localeCompare(left.timestamp),
-      );
-
-      const result = {
-        success: true,
-        message: `Found ${logs.length} Loki log line(s)`,
-        data: {
-          environment: env,
-          grafanaUrl: config.url,
-          lokiDatasourceUid: config.lokiUid,
-          query: logql,
-          start,
-          end,
-          limit,
-          logCount: logs.length,
-          logs,
-        },
-        executionTimeMs: Date.now() - startedAt,
-      };
-
-      yield* Console.log(formatOutput(result, format));
-    }).pipe(
-      Effect.catch((error) =>
-        Effect.gen(function* () {
-          const result = {
-            success: false,
-            message: "Failed to execute LogQL query",
-            error: formatObservabilityError(error),
-            hint: "Check LogQL syntax and Grafana/Loki connectivity",
-            executionTimeMs: Date.now() - startedAt,
-          };
-          yield* Console.log(formatOutput(result, format));
-        }),
-      ),
-    );
-  },
-).pipe(Command.withDescription("Execute LogQL range query via Grafana/Loki"));
-
-export const logsCommand = Command.make("logs", {}).pipe(
-  Command.withDescription("Loki log operations via Grafana"),
-  Command.withSubcommands([queryCommand]),
-);