@stackmemoryai/stackmemory 1.3.0 → 1.3.1

package/dist/src/core/database/sqlite-adapter.js

@@ -292,11 +292,16 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     logger.info("FTS5 index rebuilt");
   }
   /**
-   * Incremental garbage collection: delete expired frames and cascade to related tables.
-   * Respects retention_policy per frame:
+   * Incremental garbage collection with generational compression.
+   *
+   * Phase 1 — Compress: Apply generational strategies to mature/old frames.
+   *   - 'digest_only': Strip inputs/outputs/events, keep digest + anchors
+   *   - 'anchors_only': Strip inputs/outputs/events/digest_json, keep digest_text + anchors
+   *   - 'keep_all': No compression
+   *
+   * Phase 2 — Delete: Remove frames past retention cutoffs.
    *   - 'keep_forever': never deleted
-   *   - 'default': deleted after retentionDays (default 90)
-   *   - 'archive': same as default
+   *   - 'default'/'archive': deleted after retentionDays (default 90)
    *   - 'ttl_30d': deleted after 30 days
    *   - 'ttl_7d': deleted after 7 days
    */
@@ -314,6 +319,62 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     const defaultCutoff = nowSec - retentionDays * 86400;
     const ttl30dCutoff = nowSec - 30 * 86400;
     const ttl7dCutoff = nowSec - 7 * 86400;
+    let framesCompressed = 0;
+    const gc = options.generationalGc;
+    if (gc && !dryRun) {
+      const youngDays = gc.youngCutoffDays ?? 1;
+      const matureDays = gc.matureCutoffDays ?? 7;
+      const oldDays = gc.oldCutoffDays ?? 30;
+      const youngCutoff = nowSec - youngDays * 86400;
+      const matureCutoff = nowSec - matureDays * 86400;
+      const matureStrategy = gc.mature_strategy ?? "digest_only";
+      if (matureStrategy !== "keep_all") {
+        const matureFrames = this.db.prepare(
+          `SELECT frame_id FROM frames
+             WHERE created_at < ? AND created_at >= ?
+             AND state = 'closed'
+             AND retention_policy != 'keep_forever'
+             AND inputs != '{}'
+             AND run_id NOT IN (SELECT value FROM json_each(?))
+             LIMIT ?`
+        ).all(
+          youngCutoff,
+          matureCutoff,
+          JSON.stringify(protectedRunIds),
+          batchSize
+        );
+        if (matureFrames.length > 0) {
+          framesCompressed += this.compressFrames(
+            matureFrames.map((f) => f.frame_id),
+            matureStrategy
+          );
+        }
+      }
+      const oldStrategy = gc.old_strategy ?? "anchors_only";
+      if (oldStrategy !== "keep_all") {
+        const oldCutoff = nowSec - oldDays * 86400;
+        const oldFrames = this.db.prepare(
+          `SELECT frame_id FROM frames
+             WHERE created_at < ? AND created_at >= ?
+             AND state = 'closed'
+             AND retention_policy != 'keep_forever'
+             AND inputs != '{}'
+             AND run_id NOT IN (SELECT value FROM json_each(?))
+             LIMIT ?`
+        ).all(
+          matureCutoff,
+          oldCutoff,
+          JSON.stringify(protectedRunIds),
+          batchSize
+        );
+        if (oldFrames.length > 0) {
+          framesCompressed += this.compressFrames(
+            oldFrames.map((f) => f.frame_id),
+            oldStrategy
+          );
+        }
+      }
+    }
     const candidates = this.db.prepare(
       `SELECT frame_id FROM frames
          WHERE (
@@ -340,7 +401,8 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
         eventsDeleted: 0,
         anchorsDeleted: 0,
         embeddingsDeleted: 0,
-        ftsEntriesDeleted: 0
+        ftsEntriesDeleted: 0,
+        framesCompressed
       };
     }
     if (dryRun) {
@@ -362,8 +424,9 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
         eventsDeleted: eventsCount,
         anchorsDeleted: anchorsCount,
         embeddingsDeleted: embeddingsCount,
-        ftsEntriesDeleted: frameIds.length
+        ftsEntriesDeleted: frameIds.length,
         // FTS has one entry per frame
+        framesCompressed
       };
     }
     const placeholders = frameIds.map(() => "?").join(",");
@@ -392,14 +455,16 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
       framesDeleted: frameIds.length,
       eventsDeleted,
       anchorsDeleted,
-      embeddingsDeleted
+      embeddingsDeleted,
+      framesCompressed
     });
     return {
       framesDeleted: frameIds.length,
       eventsDeleted,
       anchorsDeleted,
       embeddingsDeleted,
-      ftsEntriesDeleted: frameIds.length
+      ftsEntriesDeleted: frameIds.length,
+      framesCompressed
     };
   }
   /**
@@ -432,6 +497,85 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     if (nowSec - frame.created_at < 86400) score += 0.1;
     return Math.round(Math.min(score, 1) * 100) / 100;
   }
+  /**
+   * Compress a frame by stripping data according to strategy.
+   *
+   * - 'digest_only': Remove inputs, outputs, events. Keep digest_text, digest_json, anchors.
+   * - 'anchors_only': Remove inputs, outputs, events, digest_json. Keep digest_text, anchors.
+   *
+   * Returns true if the frame was compressed, false if not found.
+   */
+  compressFrame(frameId, strategy) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const frame = this.db.prepare("SELECT frame_id FROM frames WHERE frame_id = ?").get(frameId);
+    if (!frame) return false;
+    this.db.prepare("BEGIN").run();
+    try {
+      if (strategy === "digest_only") {
+        this.db.prepare(
+          "UPDATE frames SET inputs = '{}', outputs = '{}' WHERE frame_id = ?"
+        ).run(frameId);
+      } else {
+        this.db.prepare(
+          "UPDATE frames SET inputs = '{}', outputs = '{}', digest_json = '{}' WHERE frame_id = ?"
+        ).run(frameId);
+      }
+      this.db.prepare("DELETE FROM events WHERE frame_id = ?").run(frameId);
+      if (this.vecEnabled) {
+        this.db.prepare("DELETE FROM frame_embeddings WHERE frame_id = ?").run(frameId);
+      }
+      this.db.prepare("COMMIT").run();
+      return true;
+    } catch (error) {
+      this.db.prepare("ROLLBACK").run();
+      throw error;
+    }
+  }
+  /**
+   * Compress multiple frames in a single transaction.
+   * Returns count of frames compressed.
+   */
+  compressFrames(frameIds, strategy) {
+    if (!this.db || frameIds.length === 0) return 0;
+    const placeholders = frameIds.map(() => "?").join(",");
+    this.db.prepare("BEGIN").run();
+    try {
+      if (strategy === "digest_only") {
+        this.db.prepare(
+          `UPDATE frames SET inputs = '{}', outputs = '{}' WHERE frame_id IN (${placeholders})`
+        ).run(...frameIds);
+      } else {
+        this.db.prepare(
+          `UPDATE frames SET inputs = '{}', outputs = '{}', digest_json = '{}' WHERE frame_id IN (${placeholders})`
+        ).run(...frameIds);
+      }
+      this.db.prepare(`DELETE FROM events WHERE frame_id IN (${placeholders})`).run(...frameIds);
+      if (this.vecEnabled) {
+        this.db.prepare(
+          `DELETE FROM frame_embeddings WHERE frame_id IN (${placeholders})`
+        ).run(...frameIds);
+      }
+      this.db.prepare("COMMIT").run();
+      return frameIds.length;
+    } catch (error) {
+      this.db.prepare("ROLLBACK").run();
+      throw error;
+    }
+  }
+  /**
+   * Get database file size in bytes.
+   */
+  getDatabaseSize() {
+    if (!this.db) return 0;
+    const result = this.db.prepare(
+      "SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()"
+    ).get();
+    return result?.size ?? 0;
+  }
   /**
    * Recompute importance scores for frames still at default score (0.5).
    * Processes oldest frames first in batches.

package/dist/src/integrations/claude-code/subagent-client.js

@@ -4,8 +4,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../../core/monitoring/logger.js";
 import { STRUCTURED_RESPONSE_SUFFIX } from "../../orchestrators/multimodal/constants.js";
-import { exec } from "child_process";
-import { promisify } from "util";
+import { spawn } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -18,12 +17,11 @@ import {
   createProvider
 } from "../../core/extensions/provider-adapter.js";
 import { AnthropicBatchClient } from "../anthropic/batch-client.js";
-const execAsync = promisify(exec);
 class ClaudeCodeSubagentClient {
   tempDir;
   activeSubagents = /* @__PURE__ */ new Map();
   mockMode;
-  constructor(mockMode = true) {
+  constructor(mockMode = false) {
     this.mockMode = mockMode;
     this.tempDir = path.join(os.tmpdir(), "stackmemory-rlm");
     if (!fs.existsSync(this.tempDir)) {
@@ -148,7 +146,8 @@ class ClaudeCodeSubagentClient {
     }
   }
   /**
-   * Original CLI-based subagent execution (unchanged behavior)
+   * Execute subagent via Claude Code CLI (`claude -p --output-format stream-json`).
+   * Spawns a real Claude Code process with full tool use.
    */
   async executeSubagentViaCLI(request, startTime, subagentId) {
     try {
@@ -158,31 +157,24 @@ class ClaudeCodeSubagentClient {
         contextFile,
         JSON.stringify(request.context, null, 2)
       );
-      const resultFile = path.join(this.tempDir, `${subagentId}-result.json`);
-      const taskCommand = this.buildTaskCommand(
-        request,
-        prompt,
-        contextFile,
-        resultFile
-      );
-      const result = await this.executeTaskTool(taskCommand, request.timeout);
-      let subagentResult = {};
-      if (fs.existsSync(resultFile)) {
-        const resultContent = await fs.promises.readFile(resultFile, "utf-8");
-        try {
-          subagentResult = JSON.parse(resultContent);
-        } catch {
-          subagentResult = { rawOutput: resultContent };
-        }
-      }
+      const fullPrompt = `${prompt}
+
+Context (JSON): ${JSON.stringify(request.context)}`;
+      const result = await this.spawnClaude(fullPrompt, request.timeout);
       this.cleanup(subagentId);
+      let parsed;
+      try {
+        parsed = JSON.parse(result.text);
+      } catch {
+        parsed = { rawOutput: result.text };
+      }
       return {
         success: true,
-        result: subagentResult,
-        output: result.stdout,
+        result: parsed,
+        output: result.text,
         duration: Date.now() - startTime,
         subagentType: request.type,
-        tokens: this.estimateTokens(prompt + JSON.stringify(subagentResult))
+        tokens: this.estimateTokens(fullPrompt + result.text)
       };
     } catch (error) {
       logger.error(`Subagent CLI execution failed: ${request.type}`, {
@@ -347,66 +339,94 @@ class ClaudeCodeSubagentClient {
     return (request.systemPrompt || prompts[request.type] || prompts.planning) + STRUCTURED_RESPONSE_SUFFIX;
   }
   /**
-   * Build Task tool command
-   * This creates a command that Claude Code's Task tool can execute
+   * Spawn `claude -p --output-format stream-json` and collect the result.
+   * Parses stream-json events to extract the final assistant text.
    */
-  buildTaskCommand(request, prompt, contextFile, resultFile) {
-    const scriptContent = `
-#!/bin/bash
-# Subagent execution script for ${request.type}
-
-# Read context
-CONTEXT=$(cat "${contextFile}")
-
-# Execute task based on type
-case "${request.type}" in
-  "testing")
-    # For testing subagent, actually run tests
-    echo "Generating and running tests..."
-    # The subagent will generate test files and run them
-    ;;
-  "linting")
-    # For linting subagent, run actual linters
-    echo "Running linters..."
-    npm run lint || true
-    ;;
-  "code")
-    # For code generation, create implementation files
-    echo "Generating implementation..."
-    ;;
-  *)
-    # Default behavior
-    echo "Executing ${request.type} task..."
-    ;;
-esac
-
-# Write result
-echo '{"status": "completed", "type": "${request.type}"}' > "${resultFile}"
-`;
-    const scriptFile = path.join(this.tempDir, `${request.type}-script.sh`);
-    fs.writeFileSync(scriptFile, scriptContent);
-    fs.chmodSync(scriptFile, "755");
-    return scriptFile;
-  }
-  /**
-   * Execute via Task tool (simulated for now)
-   * In production, this would use Claude Code's actual Task tool API
-   */
-  async executeTaskTool(command, timeout) {
-    try {
-      const result = await execAsync(command, {
-        timeout: timeout || 3e5,
-        // 5 minutes default
-        maxBuffer: 10 * 1024 * 1024
-        // 10MB buffer
+  spawnClaude(prompt, timeout) {
+    return new Promise((resolve, reject) => {
+      const args = [
+        "-p",
+        "--output-format",
+        "stream-json",
+        "--dangerously-skip-permissions",
+        prompt
+      ];
+      const claude = spawn("claude", args, {
+        cwd: process.cwd(),
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"]
       });
-      return result;
-    } catch (error) {
-      if (error.killed || error.signal === "SIGTERM") {
-        throw new Error(`Subagent timeout after ${timeout}ms`);
-      }
-      throw error;
-    }
+      const timeoutMs = timeout || 3e5;
+      const timer = setTimeout(() => {
+        claude.kill("SIGTERM");
+        reject(new Error(`Subagent timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+      let lastAssistantText = "";
+      let toolUseCount = 0;
+      let lineBuffer = "";
+      let stderr = "";
+      claude.stdout.on("data", (chunk) => {
+        lineBuffer += chunk.toString();
+        const lines = lineBuffer.split("\n");
+        lineBuffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "assistant" && event.message) {
+              const textBlocks = (event.message.content || []).filter((b) => b.type === "text").map((b) => b.text);
+              if (textBlocks.length > 0) {
+                lastAssistantText = textBlocks.join("\n");
+              }
+              const toolBlocks = (event.message.content || []).filter(
+                (b) => b.type === "tool_use"
+              );
+              toolUseCount += toolBlocks.length;
+            }
+            if (event.type === "result" && event.result) {
+              lastAssistantText = event.result;
+            }
+          } catch {
+          }
+        }
+      });
+      claude.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      claude.on("close", (code) => {
+        clearTimeout(timer);
+        if (lineBuffer.trim()) {
+          try {
+            const event = JSON.parse(lineBuffer);
+            if (event.type === "result" && event.result) {
+              lastAssistantText = event.result;
+            }
+          } catch {
+          }
+        }
+        logger.info("Claude subagent completed", {
+          code,
+          toolUseCount,
+          outputLength: lastAssistantText.length
+        });
+        if (code === 0 && lastAssistantText) {
+          resolve({ text: lastAssistantText, toolUseCount });
+        } else if (code === 0) {
+          resolve({
+            text: "(Claude completed but produced no text output)",
+            toolUseCount
+          });
+        } else {
+          reject(
+            new Error(`Claude exited code ${code}: ${stderr.slice(0, 500)}`)
+          );
+        }
+      });
+      claude.on("error", (err) => {
+        clearTimeout(timer);
+        reject(new Error(`Failed to spawn claude: ${err.message}`));
+      });
+    });
   }
   /**
    * Get mock response for testing

package/dist/src/integrations/claude-code/task-coordinator.js

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { v4 as uuidv4 } from "uuid";
+import { spawn } from "child_process";
 import { logger } from "../../core/monitoring/logger.js";
 class ClaudeCodeTaskCoordinator {
   activeTasks = /* @__PURE__ */ new Map();
@@ -205,26 +206,68 @@ class ClaudeCodeTaskCoordinator {
       agentType: agentConfig.type,
       promptTokens: this.estimateTokenUsage(prompt, "")
     });
-    return this.simulateClaudeCodeExecution(agentName, prompt, agentConfig);
+    return this.spawnClaudeCode(agentName, prompt, agentConfig);
   }
   /**
-   * Simulate Claude Code execution (temporary until real integration)
+   * Spawn Claude Code CLI as a subprocess.
+   * Uses `claude --print` for non-interactive execution with stdout capture.
+   * Workspace cwd is inherited from the coordinator's process.
    */
-  simulateClaudeCodeExecution(agentName, prompt, agentConfig) {
-    return new Promise((resolve) => {
-      const executionTime = agentConfig.type === "oracle" ? 2e3 + Math.random() * 3e3 : 1e3 + Math.random() * 2e3;
-      setTimeout(() => {
-        const result = `Claude Code agent '${agentName}' completed task successfully.
-        
-Agent Capabilities Used: ${agentConfig.capabilities.slice(0, 3).join(", ")}
-Task Type: ${agentConfig.type}
-Specializations: ${agentConfig.specializations.join(", ")}
-
-Simulated output based on prompt context: ${prompt.substring(0, 100)}...
-
-This simulation will be replaced with actual Claude Code Task tool integration.`;
-        resolve(result);
-      }, executionTime);
+  spawnClaudeCode(agentName, prompt, agentConfig) {
+    return new Promise((resolve, reject) => {
+      const args = ["--print"];
+      if (agentConfig.type === "oracle") {
+        args.push("--model", "opus");
+      }
+      if (agentConfig.capabilities.includes("code_implementation")) {
+        args.push("--allowedTools", "Edit,Write,Bash,Read,Glob,Grep");
+      } else {
+        args.push("--allowedTools", "Read,Glob,Grep,Bash");
+      }
+      args.push(prompt);
+      logger.info("Spawning claude CLI", {
+        agentName,
+        agentType: agentConfig.type,
+        cwd: process.cwd(),
+        promptLength: prompt.length
+      });
+      const proc = spawn("claude", args, {
+        cwd: process.cwd(),
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("error", (err) => {
+        logger.error("Failed to spawn claude CLI", {
+          agentName,
+          error: err.message
+        });
+        reject(new Error(`Failed to spawn claude: ${err.message}`));
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          logger.debug("Claude CLI completed", {
+            agentName,
+            outputLength: stdout.length
+          });
+          resolve(stdout.trim());
+        } else {
+          const errMsg = stderr.slice(0, 500) || `exit code ${code}`;
+          logger.warn("Claude CLI failed", {
+            agentName,
+            exitCode: code,
+            stderr: errMsg
+          });
+          reject(new Error(`Claude CLI exited with code ${code}: ${errMsg}`));
+        }
+      });
     });
   }
   /**

package/dist/src/integrations/mcp/handlers/linear-handlers.js

@@ -2,11 +2,19 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
+import { LinearClient } from "../../linear/client.js";
 import { logger } from "../../../core/monitoring/logger.js";
 class LinearHandlers {
   constructor(deps) {
     this.deps = deps;
   }
+  /**
+   * Create an authenticated LinearClient from the auth manager token
+   */
+  async getClient() {
+    const token = await this.deps.linearAuthManager.getValidToken();
+    return new LinearClient({ apiKey: token, useBearer: true });
+  }
   /**
    * Sync tasks with Linear
    */
@@ -67,7 +75,7 @@ class LinearHandlers {
     }
   }
   /**
-   * Update Linear task status
+   * Update Linear issue directly via GraphQL API
    */
   async handleLinearUpdateTask(args) {
     try {
@@ -75,27 +83,30 @@ class LinearHandlers {
       if (!linear_id) {
         throw new Error("Linear ID is required");
       }
-      try {
-        await this.deps.linearAuthManager.getValidToken();
-      } catch {
-        throw new Error("Linear authentication required");
-      }
+      const client = await this.getClient();
       const updateData = {};
-      if (status) {
-        updateData.status = status;
-      }
-      if (assignee_id) {
-        updateData.assigneeId = assignee_id;
-      }
-      if (priority) {
-        updateData.priority = priority;
-      }
+      if (status) updateData.stateId = status;
+      if (assignee_id) updateData.assigneeId = assignee_id;
+      if (priority !== void 0) updateData.priority = priority;
       if (labels) {
-        updateData.labels = Array.isArray(labels) ? labels : [labels];
+        updateData.labelIds = Array.isArray(labels) ? labels : [labels];
       }
-      throw new Error(
-        "Linear issue updates via MCP are not yet implemented. Use `stackmemory linear sync` instead."
-      );
+      const issue = await client.updateIssue(linear_id, updateData);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Updated ${issue.identifier}: ${issue.title}
+Status: ${issue.state.name} | Priority: ${issue.priority}`
+          }
+        ],
+        metadata: {
+          id: issue.id,
+          identifier: issue.identifier,
+          state: issue.state.name,
+          url: issue.url
+        }
+      };
     } catch (error) {
       logger.error(
         "Error updating Linear task",
@@ -105,40 +116,43 @@ class LinearHandlers {
     }
   }
   /**
-   * Get tasks from Linear
+   * Get issues from Linear via GraphQL API
    */
   async handleLinearGetTasks(args) {
     try {
-      const {
-        team_id,
-        assignee_id,
-        state = "active",
-        limit = 20,
-        search
-      } = args;
-      try {
-        await this.deps.linearAuthManager.getValidToken();
-      } catch {
-        throw new Error("Linear authentication required");
-      }
-      const filters = {
-        limit
+      const { team_id, assignee_id, state = "active", limit = 20 } = args;
+      const client = await this.getClient();
+      const stateTypeMap = {
+        active: "started",
+        closed: "completed",
+        all: void 0
       };
-      if (team_id) {
-        filters.teamId = team_id;
-      }
-      if (assignee_id) {
-        filters.assigneeId = assignee_id;
-      }
-      if (state) {
-        filters.state = state;
-      }
-      if (search) {
-        filters.search = search;
-      }
-      throw new Error(
-        "Linear issue listing via MCP is not yet implemented. Use `stackmemory linear sync` instead."
+      const issues = await client.getIssues({
+        teamId: team_id,
+        assigneeId: assignee_id,
+        stateType: stateTypeMap[state],
+        limit
+      });
+      const issueLines = issues.map(
+        (i) => `${i.identifier} [${i.state.name}] ${i.title}${i.assignee ? ` (@${i.assignee.name})` : ""}`
       );
+      const text = issues.length > 0 ? `Found ${issues.length} issues:
+${issueLines.join("\n")}` : "No issues found matching filters.";
+      return {
+        content: [{ type: "text", text }],
+        metadata: {
+          count: issues.length,
+          issues: issues.map((i) => ({
+            id: i.id,
+            identifier: i.identifier,
+            title: i.title,
+            state: i.state.name,
+            priority: i.priority,
+            assignee: i.assignee?.name,
+            url: i.url
+          }))
+        }
+      };
     } catch (error) {
       logger.error(
         "Error getting Linear tasks",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, Claude/Codex/OpenCode wrappers, Linear sync, automatic hooks, and log analysis.",
   "engines": {
     "node": ">=20.0.0",