@ai-setting/roy-agent-core 1.4.12 → 1.4.14

package/dist/shared/@ai-setting/roy-agent-core-gv1hrn3x.js

@@ -0,0 +1,378 @@
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-04qgbjbe.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/agent/summary-agent.ts
+init_logger();
+init_decorator();
+var logger = createLogger("agent:summary");
+
+class SummaryAgent {
+  promptComponent;
+  llmComponent;
+  config;
+  constructor(promptComponent, llmComponent, config) {
+    this.promptComponent = promptComponent;
+    this.llmComponent = llmComponent;
+    this.config = {
+      type: "summary",
+      promptName: "session/compact",
+      maxIterations: 1,
+      model: undefined,
+      ...config
+    };
+  }
+  async generateCompactHint(options) {
+    const { messages, sessionContext } = options;
+    logger.info("[SummaryAgent] Generating compact hint for session");
+    const formattedMessages = this.formatMessages(messages);
+    const systemPrompt = this.getHintGenerationSystemPrompt();
+    const userPrompt = this.buildHintGenerationUserPrompt(formattedMessages, sessionContext);
+    let response;
+    try {
+      response = await this.llmComponent.invoke({
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userPrompt }
+        ],
+        skipThresholdCheck: true
+      });
+    } catch (error) {
+      logger.error(`[SummaryAgent] Hint generation LLM invoke failed: ${error}`);
+      throw new Error(`LLM invoke failed: ${error}`);
+    }
+    const responseContent = response.output?.content || response.content || "";
+    const hint = this.parseHintResponse(responseContent);
+    logger.info("[SummaryAgent] Compact hint generated", { hint: hint.substring(0, 100) });
+    return {
+      hint,
+      rawResponse: responseContent
+    };
+  }
+  async run(options) {
+    const { messages, userContext, outputFormat, scenarioHint } = options;
+    logger.info("[SummaryAgent] Starting checkpoint generation", {
+      hasScenarioHint: !!scenarioHint
+    });
+    const formattedMessages = this.formatMessages(messages);
+    const systemPrompt = this.getSystemPrompt(scenarioHint);
+    const userPrompt = this.buildUserPrompt(formattedMessages, userContext);
+    let response;
+    try {
+      response = await this.llmComponent.invoke({
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userPrompt }
+        ],
+        model: this.config.model,
+        skipThresholdCheck: true
+      });
+    } catch (error) {
+      logger.error(`[SummaryAgent] LLM invoke failed: ${error}`);
+      throw new Error(`LLM invoke failed: ${error}`);
+    }
+    const responseContent = response.output?.content || response.content || "";
+    if (outputFormat === "json") {
+      const result = this.parseJsonResponse(responseContent);
+      logger.info(`[SummaryAgent] Checkpoint generated: "${result.title}"`);
+      return {
+        title: result.title || "Untitled Checkpoint",
+        processKeyPoints: result.processKeyPoints || [],
+        currentState: result.currentState || "",
+        nextSteps: result.nextSteps || [],
+        userIntents: result.userIntents || [],
+        rawResponse: responseContent
+      };
+    }
+    throw new Error(`Unsupported output format: ${outputFormat}`);
+  }
+  getSystemPrompt(scenarioHint) {
+    let prompt = `You are a professional session analyst assistant. Your task is to extract key information from a conversation and generate a structured checkpoint.
+
+A checkpoint captures the progress and state of a session at a point in time. It should contain:
+
+1. **Process Key Points**: The key steps, discoveries, or decisions made during this part of the conversation
+2. **Current State**: The current progress and status at the end of the conversation
+3. **Next Steps**: Follow-up items and what needs to be done next
+4. **User Intents**: The underlying goals and intentions of the user (what they want to accomplish)
+
+Be concise and accurate. Avoid redundancy. Each section should be appropriately sized - not too long.`;
+    if (scenarioHint && scenarioHint.trim()) {
+      prompt += `
+
+## Scenario Context
+
+${scenarioHint.trim()}`;
+    }
+    return prompt;
+  }
+  getHintGenerationSystemPrompt() {
+    return `You are a compact guidance prompt engineer. Your task is to analyze a conversation and generate a "compact guidance prompt" that will instruct the checkpoint generator on what information to extract and preserve during session compression.
+
+**Purpose**: The guidance prompt will be used by the checkpoint generator to understand:
+1. What work is currently in progress
+2. What progress has been made
+3. What information MUST be preserved during compression (this is critical for task continuation)
+4. What information should be the focus of extraction
+
+**Key Principle**: The preserved information should enable seamless task continuation. If critical details are lost during compression, the user will have to re-explain context when continuing this work later.
+
+**Output Format**: A structured guidance prompt (3-4 sentences) covering:
+1. Current work type and what the user is trying to accomplish
+2. Current progress and key achievements
+3. CRITICAL information that MUST be preserved (decisions, findings, remaining issues)
+4. What the checkpoint generator should focus on when extracting information
+
+**Example good outputs**:
+1. "Bug investigation: User is debugging LSP diagnostics not updating after file edits. Progress: identified root cause (getDiagnostics needs to read latest file content and trigger didChange notification), implemented fix, CI verified. CRITICAL to preserve: the fix implementation details (file path, code changes), that 2 agent-node-integration tests still fail due to test assertion timing issue (expects 'running' but completes in ~78ms) - this is unrelated to LSP work. Focus extraction on: root cause analysis, fix implementation, known remaining test issues."
+2. "Feature development: User is implementing JWT authentication for auth-service. Progress: designed auth flow, implemented token refresh logic, middleware partially done. CRITICAL to preserve: auth flow decisions (token storage, refresh strategy), completed middleware components, modules pending implementation. Focus extraction on: architectural decisions, completed components, pending work."
+3. "Refactoring: User is migrating data layer to repository pattern. Progress: migrated UserRepository and OrderRepository, 3 more pending. CRITICAL to preserve: pattern decisions (interface definitions, dependency injection approach), completed repositories, modules pending migration. Focus extraction on: pattern implementation details, completed vs pending modules."`;
+  }
+  buildHintGenerationUserPrompt(messages, sessionContext) {
+    let prompt = `Analyze the following conversation and generate a compact guidance prompt for checkpoint generation.
+
+## Your Task
+Generate a structured guidance prompt (3-4 sentences) that will help the checkpoint generator understand:
+1. What work is currently in progress
+2. What progress has been made
+3. What information MUST be preserved during compression (critical for task continuation)
+4. What the checkpoint generator should focus on when extracting information
+
+`;
+    if (sessionContext) {
+      const ctxLines = ["## Session Context"];
+      if (sessionContext.activeTaskTitle) {
+        ctxLines.push(`- Active Task: ${sessionContext.activeTaskTitle}`);
+      }
+      if (sessionContext.workingDirectory) {
+        ctxLines.push(`- Working Directory: ${sessionContext.workingDirectory}`);
+      }
+      if (sessionContext.recentActions && sessionContext.recentActions.length > 0) {
+        ctxLines.push(`- Recent Actions: ${sessionContext.recentActions.slice(-3).join(" → ")}`);
+      }
+      if (ctxLines.length > 1) {
+        prompt += ctxLines.join(`
+`) + `
+
+`;
+      }
+    }
+    prompt += `## Conversation to Analyze
+
+${messages}
+
+`;
+    prompt += `---
+
+`;
+    prompt += `## Output Format
+
+`;
+    prompt += `Generate a structured guidance prompt covering:
+`;
+    prompt += `1. Current work type and what the user is trying to accomplish
+`;
+    prompt += `2. Current progress and key achievements
+`;
+    prompt += `3. CRITICAL information that MUST be preserved (decisions, findings, remaining issues)
+`;
+    prompt += `4. What to focus on during extraction
+
+`;
+    prompt += `Wrap the output in a JSON object with a \`guidance_prompt\` key:
+
+`;
+    prompt += `\`\`\`json
+`;
+    prompt += `{
+`;
+    prompt += `  "guidance_prompt": "Work type: ... Progress: ... CRITICAL to preserve: ... Focus extraction on: ..."
+`;
+    prompt += `}
+`;
+    prompt += `\`\`\`
+
+`;
+    prompt += `IMPORTANT: The preserved information should enable seamless task continuation. If critical details are lost, the user will need to re-explain context when continuing this work.`;
+    return prompt;
+  }
+  buildUserPrompt(messages, userContext) {
+    let prompt = `Please analyze the following conversation and generate a checkpoint:
+
+`;
+    if (userContext && userContext !== "无额外上下文") {
+      prompt += `## Context
+${userContext}
+
+`;
+    }
+    prompt += `## Conversation Content
+
+${messages}
+
+`;
+    prompt += `---
+
+`;
+    prompt += `## Output Format
+
+Please output in the following JSON format:
+
+\`\`\`json
+{
+  "title": "Brief checkpoint title (max 30 characters)",
+  "processKeyPoints": [
+    "Point 1: Description of key discovery or decision",
+    "Point 2: Description of important step or conclusion",
+    "Point 3: ..."
+  ],
+  "currentState": "Current state description explaining progress and status (50-100 characters)",
+  "nextSteps": [
+    "Next follow-up item 1",
+    "Next follow-up item 2"
+  ],
+  "userIntents": [
+    "User intent 1: what the user wants to accomplish",
+    "User intent 2: another goal or request",
+    "User intent 3: ..."
+  ]
+}
+\`\`\`
+
+`;
+    prompt += `## Intent Extraction Guidelines
+
+`;
+    prompt += `- Extract user intents from the ENTIRE conversation flow (both user and assistant messages)
+`;
+    prompt += `- Focus on what the user WANTS to accomplish, not just what was discussed
+`;
+    prompt += `- Include both explicit requests and inferred goals
+`;
+    prompt += `- Aim for 2-5 intents, prioritize the most important ones
+`;
+    prompt += `- Be concise and specific in intent descriptions
+`;
+    prompt += `- Examples: "Fix authentication bug", "Optimize database performance", "Add unit tests for auth module"
+
+`;
+    prompt += `Make sure the JSON output is valid and can be parsed.`;
+    return prompt;
+  }
+  formatMessages(messages) {
+    return messages.map((m, i) => `[${i}] ${m.role}: ${m.content}`).join(`
+
+`);
+  }
+  parseJsonResponse(content) {
+    const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) || content.match(/```\s*([\s\S]*?)\s*```/) || [null, content];
+    const jsonStr = jsonMatch[1] || content;
+    try {
+      return JSON.parse(jsonStr.trim());
+    } catch {
+      const fixed = jsonStr.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").replace(/'/g, '"').trim();
+      try {
+        return JSON.parse(fixed);
+      } catch (e) {
+        logger.error(`[SummaryAgent] Failed to parse JSON: ${content}`);
+        throw new Error(`Failed to parse checkpoint JSON: ${e}`);
+      }
+    }
+  }
+  parseHintResponse(content) {
+    return parseCompactHintResponse(content);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.generateCompactHint")
+], SummaryAgent.prototype, "generateCompactHint", null);
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.run", { recordParams: true, recordResult: true })
+], SummaryAgent.prototype, "run", null);
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.getHintGenerationSystemPrompt")
+], SummaryAgent.prototype, "getHintGenerationSystemPrompt", null);
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.buildHintGenerationUserPrompt")
+], SummaryAgent.prototype, "buildHintGenerationUserPrompt", null);
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.parseHintResponse")
+], SummaryAgent.prototype, "parseHintResponse", null);
+function parseCompactHintResponse(content) {
+  const jsonResult = extractGuidanceFromJson(content);
+  if (jsonResult !== null) {
+    const trimmed = jsonResult.trim();
+    if (!trimmed) {
+      return "[Hint extraction failed]";
+    }
+    if (trimmed.length > 500) {
+      return trimmed.substring(0, 500) + "...";
+    }
+    return trimmed;
+  }
+  let text = content.replace(/```json\s*([\s\S]*?)\s*```/g, "$1").replace(/```markdown\s*([\s\S]*?)\s*```/g, "$1").replace(/```\s*([\s\S]*?)\s*```/g, "$1").trim();
+  if (!text) {
+    return "[Hint extraction failed]";
+  }
+  if (text.length > 500) {
+    return text.substring(0, 500) + "...";
+  }
+  return text;
+}
+function extractGuidanceFromJson(content) {
+  const jsonBlockMatch = content.match(/```json\s*([\s\S]*?)\s*```/);
+  if (jsonBlockMatch) {
+    const parsed2 = tryParseJson(jsonBlockMatch[1]);
+    const guidancePrompt2 = parsed2?.guidance_prompt;
+    if (typeof guidancePrompt2 === "string") {
+      return guidancePrompt2;
+    }
+  }
+  const plainBlockMatch = content.match(/```\s*([\s\S]*?)\s*```/);
+  if (plainBlockMatch) {
+    const parsed2 = tryParseJson(plainBlockMatch[1]);
+    const guidancePrompt2 = parsed2?.guidance_prompt;
+    if (typeof guidancePrompt2 === "string") {
+      return guidancePrompt2;
+    }
+  }
+  const jsonMatch = content.match(/\{[\s\S]*"guidance_prompt"[\s\S]*\}/);
+  if (jsonMatch) {
+    const parsed2 = tryParseJson(jsonMatch[0]);
+    const guidancePrompt2 = parsed2?.guidance_prompt;
+    if (typeof guidancePrompt2 === "string") {
+      return guidancePrompt2;
+    }
+  }
+  const parsed = tryParseJson(content.trim());
+  const guidancePrompt = parsed?.guidance_prompt;
+  if (typeof guidancePrompt === "string") {
+    return guidancePrompt;
+  }
+  return null;
+}
+function tryParseJson(str) {
+  if (!str || !str.trim()) {
+    return null;
+  }
+  try {
+    return JSON.parse(str.trim());
+  } catch {
+    try {
+      const fixed = str.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").trim();
+      return JSON.parse(fixed);
+    } catch {
+      return null;
+    }
+  }
+}
+
+export { SummaryAgent };

package/dist/{env/task/tools/operation/index.js → shared/@ai-setting/roy-agent-core-gy0wp5h7.js}

@@ -1,54 +1,3 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
 // packages/core/src/env/task/tools/operation/operation-types.ts
 import { z } from "zod";
 var ActionTypeEnum = z.enum([
@@ -261,10 +210,4 @@ function deleteOperationTool(taskComponent) {
     }
   };
 }
-export {
-  updateOperationTool,
-  listOperationsTool,
-  getOperationTool,
-  deleteOperationTool,
-  createOperationTool
-};
+export { createOperationTool, getOperationTool, listOperationsTool, updateOperationTool, deleteOperationTool };

package/dist/shared/@ai-setting/roy-agent-core-hyza1gm7.js

@@ -0,0 +1,15 @@
+import {
+  getDecoratorNodes,
+  hasDecoratorNodes,
+  init_node_registry_helper,
+  registerDecoratorNodeType
+} from "./roy-agent-core-1z1zv5g8.js";
+import"./roy-agent-core-3tnb2005.js";
+import"./roy-agent-core-fs0mn2jk.js";
+init_node_registry_helper();
+
+export {
+  registerDecoratorNodeType,
+  hasDecoratorNodes,
+  getDecoratorNodes
+};

package/dist/shared/@ai-setting/roy-agent-core-j8zx62zr.js

@@ -0,0 +1,154 @@
+import {
+  __esm,
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/log-trace/span-storage.ts
+class SQLiteSpanStorage {
+  db = null;
+  dbPath;
+  initialized = false;
+  constructor(dbPath) {
+    if (!dbPath) {
+      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
+    }
+    if (dbPath === ":memory:") {
+      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
+    }
+    this.dbPath = dbPath;
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    const { Database } = __require("bun:sqlite");
+    const fs = __require("fs");
+    const path = __require("path");
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    this.db.run("PRAGMA journal_mode=WAL");
+    this.db.run("PRAGMA busy_timeout=5000");
+    this.db.run("PRAGMA synchronous=NORMAL");
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS span (
+        span_id TEXT PRIMARY KEY,
+        trace_id TEXT NOT NULL,
+        parent_span_id TEXT,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        status TEXT NOT NULL,
+        start_time INTEGER NOT NULL,
+        end_time INTEGER,
+        attributes TEXT,
+        result TEXT,
+        error TEXT,
+        time_created INTEGER NOT NULL
+      )
+    `);
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
+    this.initialized = true;
+  }
+  save(span) {
+    if (!this.db)
+      return;
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO span 
+      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
+    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
+  }
+  saveBatch(spans) {
+    for (const span of spans) {
+      this.save(span);
+    }
+  }
+  findByTraceId(traceId) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
+    return this.buildTree(rows.map(this.rowToSpan));
+  }
+  findBySpanId(spanId) {
+    if (!this.db)
+      return;
+    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
+    return row ? this.rowToSpan(row) : undefined;
+  }
+  listTraces(limit = 10) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare(`
+      SELECT trace_id, 
+             MIN(start_time) as start_time,
+             MAX(end_time) as end_time,
+             COUNT(*) as span_count
+      FROM span 
+      GROUP BY trace_id 
+      ORDER BY start_time DESC 
+      LIMIT ?
+    `).all(limit);
+    return rows.map((row) => ({
+      traceId: row.trace_id,
+      rootSpanName: "unknown",
+      startTime: row.start_time,
+      endTime: row.end_time,
+      duration: row.end_time - row.start_time,
+      spanCount: row.span_count,
+      status: "ok"
+    }));
+  }
+  deleteByTraceId(traceId) {
+    if (this.db) {
+      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
+    }
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  rowToSpan(row) {
+    return {
+      traceId: row.trace_id,
+      spanId: row.span_id,
+      parentSpanId: row.parent_span_id,
+      name: row.name,
+      kind: row.kind,
+      status: row.status,
+      startTime: row.start_time,
+      endTime: row.end_time,
+      attributes: row.attributes ? JSON.parse(row.attributes) : {},
+      result: row.result || undefined,
+      error: row.error || undefined
+    };
+  }
+  buildTree(spans) {
+    const spanMap = new Map;
+    const roots = [];
+    for (const span of spans) {
+      spanMap.set(span.spanId, { ...span, children: [] });
+    }
+    for (const span of spanMap.values()) {
+      if (span.parentSpanId) {
+        const parent = spanMap.get(span.parentSpanId);
+        if (parent) {
+          parent.children.push(span);
+        } else {
+          roots.push(span);
+        }
+      } else {
+        roots.push(span);
+      }
+    }
+    return roots;
+  }
+}
+var init_span_storage = () => {};
+
+export { SQLiteSpanStorage, init_span_storage };