@dreki-gg/pi-datadog 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @dreki-gg/pi-datadog
+
+## 0.2.0
+
+### Minor Changes
+
+- New Datadog extension — search production logs from within pi with project-aware context via `.pi/datadog.json`.

package/README.md

@@ -0,0 +1,109 @@
+# @dreki-gg/pi-datadog
+
+Datadog log search tools for [pi](https://github.com/earendil-works/pi) — query production logs with project-aware context.
+
+## Setup
+
+### 1. Install
+
+```bash
+pi install npm:@dreki-gg/pi-datadog
+```
+
+### 2. Set credentials
+
+Export your Datadog API and Application keys as environment variables:
+
+```bash
+export DD_API_KEY="your-datadog-api-key"
+export DD_APP_KEY="your-datadog-app-key"
+```
+
+> **Tip:** Add these to your shell profile (`~/.zshrc`, `~/.bashrc`) or use a `.env` manager. Never commit credentials to version control.
+
+You need an **Application Key** (not just an API key) because log search uses Datadog's read endpoints.
+
+### 3. Configure your project (optional)
+
+Create `.pi/datadog.json` in your project root to set defaults:
+
+```json
+{
+  "service": "my-api",
+  "env": "production",
+  "site": "datadoghq.com",
+  "defaultTags": ["team:backend"],
+  "defaultTimeRange": "1h"
+}
+```
+
+| Field | Description | Default |
+|-------|-------------|---------|
+| `service` | Default service name for queries | _(none)_ |
+| `env` | Default environment | _(none)_ |
+| `site` | Datadog site | `datadoghq.com` |
+| `defaultTags` | Tags auto-appended to every query | `[]` |
+| `defaultTimeRange` | Default lookback window | `1h` |
+
+**Supported sites:** `datadoghq.com` (US1), `us3.datadoghq.com`, `us5.datadoghq.com`, `datadoghq.eu` (EU).
+
+## Usage
+
+### Natural language
+
+Just ask pi to search your logs:
+
+```
+> Show me the errors in production from the last 30 minutes
+> What's causing the 500 errors on the payments service?
+> Find logs with "timeout" in staging from the past 24 hours
+```
+
+The agent uses your `.pi/datadog.json` defaults automatically — you don't need to specify service or environment unless you want to override them.
+
+### Tool: `datadog_logs_search`
+
+The agent calls this tool with [Datadog query syntax](https://docs.datadoghq.com/logs/explorer/search_syntax/):
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `query` | `string` | **Required.** Datadog log query (e.g. `status:error`, `@http.status_code:500`) |
+| `from` | `string` | Start time — relative (`15m`, `1h`, `7d`) or ISO 8601 |
+| `to` | `string` | End time — relative, ISO 8601, or `now` |
+| `limit` | `number` | Max results (1–100, default 25) |
+| `sort` | `string` | `newest` or `oldest` |
+| `service` | `string` | Override project default service |
+| `env` | `string` | Override project default environment |
+
+### Command: `/datadog`
+
+Check your configuration and connection status:
+
+```
+/datadog
+```
+
+Shows: credential status (set/missing), project config (service, env, site, tags).
+
+## Query Syntax Examples
+
+```
+status:error                          # All errors
+service:my-api status:error           # Errors for a specific service
+@http.status_code:500                 # 500 errors
+"connection refused"                  # Full-text search
+service:my-api env:production @duration:>5000  # Slow requests
+```
+
+See the [Datadog Log Search Syntax docs](https://docs.datadoghq.com/logs/explorer/search_syntax/) for the full reference.
+
+## How It Works
+
+1. The extension loads `.pi/datadog.json` from your project on session start
+2. When the agent calls `datadog_logs_search`, it merges your query with project defaults (service, env, tags)
+3. Results are formatted as markdown with status icons, truncated messages, and key attributes
+4. The agent receives structured metadata (status breakdown, services found) to summarize intelligently
+
+## License
+
+MIT

package/extensions/datadog/client.ts

@@ -0,0 +1,161 @@
+import { client, v2 } from '@datadog/datadog-api-client';
+import type { DatadogCredentials, DatadogProjectConfig } from './config.js';
+
+export interface LogSearchParams {
+  query: string;
+  from?: string;
+  to?: string;
+  limit?: number;
+  sort?: 'newest' | 'oldest';
+  service?: string;
+  env?: string;
+}
+
+export interface LogEntry {
+  id: string;
+  timestamp: string;
+  status: string;
+  service: string;
+  host: string;
+  message: string;
+  tags: string[];
+  attributes: Record<string, unknown>;
+}
+
+export interface LogSearchResult {
+  logs: LogEntry[];
+  totalCount: number;
+  query: string;
+  from: string;
+  to: string;
+  cursor?: string;
+}
+
+/**
+ * Parses a relative time string (e.g. "15m", "1h", "7d") into a Date.
+ * Returns null if the string is not a recognized relative format.
+ */
+export function parseRelativeTime(input: string): Date | null {
+  const match = input.match(/^(\d+)([mhd])$/);
+  if (!match) return null;
+
+  const amount = Number(match[1]);
+  const unit = match[2];
+
+  const multipliers: Record<string, number> = {
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+  };
+
+  return new Date(Date.now() - amount * multipliers[unit]);
+}
+
+/**
+ * Resolves a time input to a Date.
+ * Accepts: relative ("15m", "1h"), ISO 8601, or "now".
+ */
+export function resolveTime(input: string): Date {
+  if (input === 'now') return new Date();
+
+  const relative = parseRelativeTime(input);
+  if (relative) return relative;
+
+  const date = new Date(input);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(
+      `Invalid time format: "${input}". Use relative (15m, 1h, 7d), ISO 8601, or "now".`,
+    );
+  }
+  return date;
+}
+
+/**
+ * Builds the full Datadog query by merging the user query with config defaults.
+ */
+export function buildQuery(params: LogSearchParams, config: DatadogProjectConfig): string {
+  const parts: string[] = [params.query];
+
+  const service = params.service ?? config.service;
+  if (service && !params.query.includes('service:')) {
+    parts.push(`service:${service}`);
+  }
+
+  const env = params.env ?? config.env;
+  if (env && !params.query.includes('env:')) {
+    parts.push(`env:${env}`);
+  }
+
+  if (config.defaultTags) {
+    for (const tag of config.defaultTags) {
+      const tagKey = tag.split(':')[0];
+      if (!params.query.includes(`${tagKey}:`)) {
+        parts.push(tag);
+      }
+    }
+  }
+
+  return parts.join(' ');
+}
+
+function createApiInstance(credentials: DatadogCredentials, site: string): v2.LogsApi {
+  const configuration = client.createConfiguration({
+    authMethods: {
+      apiKeyAuth: credentials.apiKey,
+      appKeyAuth: credentials.appKey,
+    },
+  });
+  configuration.setServerVariables({ site });
+
+  return new v2.LogsApi(configuration);
+}
+
+function normalizeLogEntry(log: v2.Log): LogEntry {
+  const attrs = log.attributes;
+  return {
+    id: log.id ?? 'unknown',
+    timestamp: attrs?.timestamp?.toISOString() ?? 'unknown',
+    status: attrs?.status ?? 'unknown',
+    service: attrs?.service ?? 'unknown',
+    host: attrs?.host ?? 'unknown',
+    message: attrs?.message ?? '',
+    tags: attrs?.tags ?? [],
+    attributes: (attrs?.attributes as Record<string, unknown>) ?? {},
+  };
+}
+
+/**
+ * Searches Datadog logs using the v2 API.
+ */
+export async function searchLogs(
+  params: LogSearchParams,
+  config: DatadogProjectConfig,
+  credentials: DatadogCredentials,
+): Promise<LogSearchResult> {
+  const fullQuery = buildQuery(params, config);
+  const fromTime = resolveTime(params.from ?? config.defaultTimeRange);
+  const toTime = resolveTime(params.to ?? 'now');
+  const limit = Math.min(params.limit ?? 25, 100);
+  const sortOrder = params.sort === 'oldest' ? 'timestamp' : '-timestamp';
+
+  const api = createApiInstance(credentials, config.site);
+
+  const response = await api.listLogsGet({
+    filterQuery: fullQuery,
+    filterFrom: fromTime,
+    filterTo: toTime,
+    pageLimit: limit,
+    sort: sortOrder as v2.LogsSort,
+  });
+
+  const logs = (response.data ?? []).map(normalizeLogEntry);
+
+  return {
+    logs,
+    totalCount: logs.length,
+    query: fullQuery,
+    from: fromTime.toISOString(),
+    to: toTime.toISOString(),
+    cursor: response.meta?.page?.after,
+  };
+}

package/extensions/datadog/config.ts

@@ -0,0 +1,124 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export interface DatadogProjectConfig {
+  service?: string;
+  env?: string;
+  site: string;
+  defaultTags?: string[];
+  defaultTimeRange: string;
+}
+
+interface RawConfig {
+  service?: unknown;
+  env?: unknown;
+  site?: unknown;
+  defaultTags?: unknown;
+  defaultTimeRange?: unknown;
+}
+
+const DEFAULT_CONFIG: DatadogProjectConfig = {
+  site: 'datadoghq.com',
+  defaultTimeRange: '1h',
+};
+
+export interface DatadogCredentials {
+  apiKey: string;
+  appKey: string;
+}
+
+/**
+ * Reads credentials from environment variables.
+ * Returns null if either key is missing.
+ */
+export function getCredentials(): DatadogCredentials | null {
+  const apiKey = process.env.DD_API_KEY;
+  const appKey = process.env.DD_APP_KEY;
+
+  if (!apiKey || !appKey) return null;
+
+  return { apiKey, appKey };
+}
+
+/**
+ * Checks which credential keys are present (without exposing values).
+ */
+export function getCredentialStatus(): { hasApiKey: boolean; hasAppKey: boolean } {
+  return {
+    hasApiKey: Boolean(process.env.DD_API_KEY),
+    hasAppKey: Boolean(process.env.DD_APP_KEY),
+  };
+}
+
+/**
+ * Loads and validates .pi/datadog.json from the project root.
+ * Returns defaults if the file doesn't exist.
+ * Throws on invalid JSON or invalid field types.
+ */
+export async function loadProjectConfig(cwd: string): Promise<DatadogProjectConfig> {
+  const configPath = join(cwd, '.pi', 'datadog.json');
+
+  let raw: string;
+  try {
+    raw = await readFile(configPath, 'utf-8');
+  } catch (err: unknown) {
+    if (err instanceof Error && 'code' in err && (err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return { ...DEFAULT_CONFIG };
+    }
+    throw new Error(`Failed to read ${configPath}: ${(err as Error).message}`);
+  }
+
+  let parsed: RawConfig;
+  try {
+    parsed = JSON.parse(raw) as RawConfig;
+  } catch {
+    throw new Error(`Invalid JSON in ${configPath}`);
+  }
+
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${configPath} must be a JSON object`);
+  }
+
+  return validateConfig(parsed, configPath);
+}
+
+function validateConfig(raw: RawConfig, configPath: string): DatadogProjectConfig {
+  const config: DatadogProjectConfig = { ...DEFAULT_CONFIG };
+
+  if (raw.service !== undefined) {
+    if (typeof raw.service !== 'string') {
+      throw new Error(`${configPath}: "service" must be a string`);
+    }
+    config.service = raw.service;
+  }
+
+  if (raw.env !== undefined) {
+    if (typeof raw.env !== 'string') {
+      throw new Error(`${configPath}: "env" must be a string`);
+    }
+    config.env = raw.env;
+  }
+
+  if (raw.site !== undefined) {
+    if (typeof raw.site !== 'string') {
+      throw new Error(`${configPath}: "site" must be a string`);
+    }
+    config.site = raw.site;
+  }
+
+  if (raw.defaultTags !== undefined) {
+    if (!Array.isArray(raw.defaultTags) || !raw.defaultTags.every((t) => typeof t === 'string')) {
+      throw new Error(`${configPath}: "defaultTags" must be an array of strings`);
+    }
+    config.defaultTags = raw.defaultTags as string[];
+  }
+
+  if (raw.defaultTimeRange !== undefined) {
+    if (typeof raw.defaultTimeRange !== 'string') {
+      throw new Error(`${configPath}: "defaultTimeRange" must be a string`);
+    }
+    config.defaultTimeRange = raw.defaultTimeRange;
+  }
+
+  return config;
+}

package/extensions/datadog/format.ts

@@ -0,0 +1,115 @@
+import type { LogEntry, LogSearchResult } from './client.js';
+
+const MAX_MESSAGE_LENGTH = 500;
+const MAX_ATTRIBUTES_LENGTH = 300;
+
+/**
+ * Truncates a string to the given max length, appending "…" if truncated.
+ */
+function truncate(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 1)}…`;
+}
+
+/**
+ * Formats a single log entry as a compact markdown block.
+ */
+function formatLogEntry(log: LogEntry, index: number): string {
+  const statusIcon = getStatusIcon(log.status);
+  const header = `### ${index + 1}. ${statusIcon} \`${log.status}\` — ${log.timestamp}`;
+
+  const lines: string[] = [header];
+
+  if (log.service !== 'unknown') lines.push(`**Service:** ${log.service}`);
+  if (log.host !== 'unknown') lines.push(`**Host:** ${log.host}`);
+
+  if (log.message) {
+    lines.push(`**Message:**\n\`\`\`\n${truncate(log.message, MAX_MESSAGE_LENGTH)}\n\`\`\``);
+  }
+
+  const attrKeys = Object.keys(log.attributes);
+  if (attrKeys.length > 0) {
+    const attrStr = truncate(JSON.stringify(log.attributes, null, 2), MAX_ATTRIBUTES_LENGTH);
+    lines.push(`**Attributes:**\n\`\`\`json\n${attrStr}\n\`\`\``);
+  }
+
+  if (log.tags.length > 0) {
+    lines.push(`**Tags:** ${log.tags.map((t) => `\`${t}\``).join(', ')}`);
+  }
+
+  return lines.join('\n');
+}
+
+function getStatusIcon(status: string): string {
+  const lower = status.toLowerCase();
+  if (lower === 'error' || lower === 'critical' || lower === 'emergency' || lower === 'alert') {
+    return '🔴';
+  }
+  if (lower === 'warn' || lower === 'warning') return '🟡';
+  if (lower === 'info' || lower === 'notice') return '🔵';
+  return '⚪';
+}
+
+/**
+ * Formats the full search result for LLM consumption.
+ */
+export function formatSearchResult(result: LogSearchResult): string {
+  const lines: string[] = [];
+
+  lines.push(`## Datadog Log Search Results`);
+  lines.push('');
+  lines.push(`**Query:** \`${result.query}\``);
+  lines.push(`**Time range:** ${result.from} → ${result.to}`);
+  lines.push(`**Results:** ${result.totalCount} logs returned`);
+
+  if (result.cursor) {
+    lines.push(`**Pagination:** More results available (cursor present)`);
+  }
+
+  lines.push('');
+
+  if (result.logs.length === 0) {
+    lines.push('No logs found matching the query.');
+    return lines.join('\n');
+  }
+
+  lines.push('---');
+  lines.push('');
+
+  for (let i = 0; i < result.logs.length; i++) {
+    lines.push(formatLogEntry(result.logs[i], i));
+    if (i < result.logs.length - 1) lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Formats a summary of the search result for tool details.
+ */
+export function formatSearchSummary(result: LogSearchResult): {
+  totalCount: number;
+  query: string;
+  timeRange: { from: string; to: string };
+  statusBreakdown: Record<string, number>;
+  services: string[];
+  hasCursor: boolean;
+} {
+  const statusBreakdown: Record<string, number> = {};
+  const services = new Set<string>();
+
+  for (const log of result.logs) {
+    const status = log.status.toLowerCase();
+    statusBreakdown[status] = (statusBreakdown[status] ?? 0) + 1;
+    if (log.service !== 'unknown') services.add(log.service);
+  }
+
+  return {
+    totalCount: result.totalCount,
+    query: result.query,
+    timeRange: { from: result.from, to: result.to },
+    statusBreakdown,
+    services: [...services],
+    hasCursor: Boolean(result.cursor),
+  };
+}

package/extensions/datadog/index.ts

@@ -0,0 +1,192 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Type } from 'typebox';
+import { StringEnum } from '@earendil-works/pi-ai';
+import {
+  type DatadogProjectConfig,
+  getCredentials,
+  getCredentialStatus,
+  loadProjectConfig,
+} from './config.js';
+import { searchLogs } from './client.js';
+import { formatSearchResult, formatSearchSummary } from './format.js';
+
+const SORT_ENUM = ['newest', 'oldest'] as const;
+
+const TOOL_GUIDELINES = [
+  'Use `datadog_logs_search` to search production logs in Datadog. It uses Datadog query syntax (e.g. `status:error`, `@http.status_code:500`, `service:my-api`).',
+  '`datadog_logs_search` auto-applies project defaults for service and environment from `.pi/datadog.json` — only override when the user explicitly asks for a different service or env.',
+  'When `datadog_logs_search` returns many results, summarize the patterns (error types, frequency, affected services) instead of listing every log entry.',
+  'Use appropriate time ranges with `datadog_logs_search`: "15m" for recent issues, "1h" for general debugging, "24h" or "7d" for trend analysis.',
+];
+
+export default function datadogExtension(pi: ExtensionAPI) {
+  let projectConfig: DatadogProjectConfig | null = null;
+
+  pi.on('session_start', async (_event, ctx) => {
+    try {
+      projectConfig = await loadProjectConfig(ctx.cwd);
+    } catch (err) {
+      ctx.ui.notify(`Datadog config error: ${(err as Error).message}`, 'warning');
+      projectConfig = null;
+    }
+  });
+
+  pi.registerTool({
+    name: 'datadog_logs_search',
+    label: 'Datadog Log Search',
+    description:
+      'Search Datadog logs with query syntax. Uses project defaults from .pi/datadog.json for service, environment, and time range.',
+    promptSnippet: 'Search Datadog logs with query syntax and project-aware defaults',
+    promptGuidelines: TOOL_GUIDELINES,
+    parameters: Type.Object({
+      query: Type.String({
+        description:
+          'Datadog log query syntax (e.g. "status:error", "@http.status_code:500", "error connecting to database")',
+      }),
+      from: Type.Optional(
+        Type.String({
+          description:
+            'Start time — relative (15m, 1h, 7d) or ISO 8601. Defaults to project config or 1h.',
+        }),
+      ),
+      to: Type.Optional(
+        Type.String({
+          description: 'End time — relative, ISO 8601, or "now". Defaults to "now".',
+        }),
+      ),
+      limit: Type.Optional(
+        Type.Number({
+          description: 'Max logs to return (1-100). Default 25.',
+          minimum: 1,
+          maximum: 100,
+        }),
+      ),
+      sort: Type.Optional(
+        StringEnum(SORT_ENUM, {
+          description: 'Sort order by timestamp. Default "newest".',
+        }),
+      ),
+      service: Type.Optional(
+        Type.String({
+          description: 'Service name — overrides project default from .pi/datadog.json.',
+        }),
+      ),
+      env: Type.Optional(
+        Type.String({
+          description: 'Environment — overrides project default from .pi/datadog.json.',
+        }),
+      ),
+    }),
+
+    async execute(
+      _toolCallId: string,
+      params: {
+        query: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+        sort?: (typeof SORT_ENUM)[number];
+        service?: string;
+        env?: string;
+      },
+      _signal?: AbortSignal,
+      _onUpdate?: unknown,
+      ctx?: { cwd: string },
+    ) {
+      const credentials = getCredentials();
+      if (!credentials) {
+        const status = getCredentialStatus();
+        const missing = [
+          !status.hasApiKey && 'DD_API_KEY',
+          !status.hasAppKey && 'DD_APP_KEY',
+        ].filter(Boolean);
+
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `❌ Missing Datadog credentials: ${missing.join(', ')}.\n\nSet these environment variables to enable Datadog log search.`,
+            },
+          ],
+          details: { error: 'missing_credentials', missing } as Record<string, unknown>,
+          isError: true,
+        };
+      }
+
+      // Reload config if not loaded yet (e.g. tool called before session_start)
+      if (!projectConfig && ctx?.cwd) {
+        try {
+          projectConfig = await loadProjectConfig(ctx.cwd);
+        } catch {
+          // Use defaults
+          projectConfig = { site: 'datadoghq.com', defaultTimeRange: '1h' };
+        }
+      }
+
+      const config = projectConfig ?? { site: 'datadoghq.com', defaultTimeRange: '1h' };
+
+      try {
+        const result = await searchLogs(params, config, credentials);
+        const formatted = formatSearchResult(result);
+        const summary = formatSearchSummary(result);
+
+        return {
+          content: [{ type: 'text' as const, text: formatted }],
+          details: summary as Record<string, unknown>,
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `❌ Datadog API error: ${message}`,
+            },
+          ],
+          details: { error: 'api_error', message } as Record<string, unknown>,
+          isError: true,
+        };
+      }
+    },
+  });
+
+  pi.registerCommand('datadog', {
+    description: 'Show Datadog configuration and connection status',
+    handler: async (
+      _args: string,
+      ctx: {
+        cwd: string;
+        hasUI: boolean;
+        ui: { notify(message: string, level: 'info' | 'warning' | 'error'): void };
+      },
+    ) => {
+      const credStatus = getCredentialStatus();
+      const config = projectConfig ?? (await loadProjectConfig(ctx.cwd).catch(() => null));
+
+      const lines: string[] = ['Datadog Extension Status', ''];
+
+      // Credentials
+      lines.push(`API Key: ${credStatus.hasApiKey ? '✅ Set' : '❌ Missing (DD_API_KEY)'}`);
+      lines.push(`App Key: ${credStatus.hasAppKey ? '✅ Set' : '❌ Missing (DD_APP_KEY)'}`);
+      lines.push('');
+
+      // Config
+      if (config) {
+        lines.push('Project Config (.pi/datadog.json):');
+        lines.push(`  Site: ${config.site}`);
+        lines.push(`  Service: ${config.service ?? '(not set)'}`);
+        lines.push(`  Env: ${config.env ?? '(not set)'}`);
+        lines.push(`  Default time range: ${config.defaultTimeRange}`);
+        if (config.defaultTags?.length) {
+          lines.push(`  Default tags: ${config.defaultTags.join(', ')}`);
+        }
+      } else {
+        lines.push('No .pi/datadog.json found — using defaults.');
+      }
+
+      if (ctx.hasUI) {
+        ctx.ui.notify(lines.join('\n'), 'info');
+      }
+    },
+  });
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@dreki-gg/pi-datadog",
+  "version": "0.2.0",
+  "description": "Datadog log search tools for pi — query production logs with project-aware context",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "datadog",
+    "logs",
+    "observability"
+  ],
+  "author": "Juan Albarran <jalbarrandev@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dreki-gg/pi-extensions",
+    "directory": "packages/datadog"
+  },
+  "type": "module",
+  "files": [
+    "extensions",
+    "README.md",
+    "CHANGELOG.md",
+    "package.json"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "lint": "oxlint extensions test",
+    "format": "oxfmt --write extensions test",
+    "format:check": "oxfmt --check extensions test"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/datadog"
+    ]
+  },
+  "dependencies": {
+    "@datadog/datadog-api-client": "^1.34.0"
+  },
+  "devDependencies": {
+    "@types/node": "24",
+    "bun-types": "^1.3.14",
+    "oxfmt": "^0.43.0",
+    "oxlint": "^1.58.0",
+    "typescript": "^6.0.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
+    }
+  }
+}