@lobehub/lobehub 2.0.0-next.257 → 2.0.0-next.259

package/packages/builtin-tool-memory/src/executor/index.ts

@@ -6,6 +6,7 @@ import type {
   RemoveIdentityActionSchema,
   UpdateIdentityActionSchema,
 } from '@lobechat/memory-user-memory/schemas';
+import { formatMemorySearchResults } from '@lobechat/prompts';
 import { BaseExecutor, type BuiltinToolResult, SearchMemoryParams } from '@lobechat/types';
 import type { z } from 'zod';
 
@@ -14,35 +15,6 @@ import { userMemoryService } from '@/services/userMemory';
 import { MemoryIdentifier } from '../manifest';
 import { MemoryApiName } from '../types';
 
-/**
- * Format search results into human-readable summary
- */
-const formatSearchResultsSummary = (result: {
-  contexts: unknown[];
-  experiences: unknown[];
-  preferences: unknown[];
-}): string => {
-  const total = result.contexts.length + result.experiences.length + result.preferences.length;
-
-  if (total === 0) {
-    return '🔍 No memories found matching the query.';
-  }
-
-  const parts: string[] = [`🔍 Found ${total} memories:`];
-
-  if (result.contexts.length > 0) {
-    parts.push(`- ${result.contexts.length} context memories`);
-  }
-  if (result.experiences.length > 0) {
-    parts.push(`- ${result.experiences.length} experience memories`);
-  }
-  if (result.preferences.length > 0) {
-    parts.push(`- ${result.preferences.length} preference memories`);
-  }
-
-  return parts.join('\n');
-};
-
 /**
  * Memory Tool Executor
  *
@@ -62,7 +34,7 @@ class MemoryExecutor extends BaseExecutor<typeof MemoryApiName> {
       const result = await userMemoryService.searchMemory(params);
 
       return {
-        content: formatSearchResultsSummary(result),
+        content: formatMemorySearchResults({ query: params.query, results: result }),
         state: result,
         success: true,
       };

package/packages/database/src/schemas/agentCronJob.ts

@@ -43,7 +43,7 @@ export const agentCronJobs = pgTable(
 
     // Core configuration
     enabled: boolean('enabled').default(true),
-    cronPattern: text('cron_pattern').notNull(), // e.g., "0 */30 * * *"
+    cronPattern: text('cron_pattern').notNull(), // e.g., "*/30 * * * *" (every 30 minutes)
     timezone: text('timezone').default('UTC'),
 
     // Content fields
@@ -82,27 +82,61 @@ export const cronPatternSchema = z
     'Invalid cron pattern',
   );
 
-// Minimum 30 minutes validation
+// Minimum 30 minutes validation (using standard cron format)
 export const minimumIntervalSchema = z.string().refine((pattern) => {
-  // For simplicity, we'll validate common patterns
-  // More complex validation can be added later
-  const thirtyMinPatterns = [
-    '0 */30 * * *', // Every 30 minutes
-    '0 0 * * *', // Every hour
-    '0 0 */2 * *', // Every 2 hours
-    '0 0 */6 * *', // Every 6 hours
-    '0 0 0 * *', // Daily
-    '0 0 0 * * 1', // Weekly
-    '0 0 0 1 *', // Monthly
+  // Standard cron format: minute hour day month weekday
+  const allowedPatterns = [
+    '*/30 * * * *', // Every 30 minutes
+    '0 * * * *', // Every hour
+    '0 */2 * * *', // Every 2 hours
+    '0 */3 * * *', // Every 3 hours
+    '0 */4 * * *', // Every 4 hours
+    '0 */6 * * *', // Every 6 hours
+    '0 */8 * * *', // Every 8 hours
+    '0 */12 * * *', // Every 12 hours
+    '0 0 * * *', // Daily at midnight
+    '0 0 * * 0', // Weekly on Sunday
+    '0 0 1 * *', // Monthly on 1st
   ];
 
-  // Check if it matches allowed patterns or follows 30+ minute intervals
-  return (
-    thirtyMinPatterns.includes(pattern) ||
-    pattern.includes('*/30') ||
-    pattern.includes('*/60') ||
-    /0 \d+ \* \* \*/.test(pattern)
-  ); // Hours pattern
+  // Check if it matches allowed patterns
+  if (allowedPatterns.includes(pattern)) {
+    return true;
+  }
+
+  // Parse pattern to validate minimum 30-minute interval
+  const parts = pattern.split(' ');
+  if (parts.length !== 5) {
+    return false;
+  }
+
+  const [minute, hour] = parts;
+
+  // Allow minute intervals >= 30 (e.g., */30, */45, */60)
+  if (minute.startsWith('*/')) {
+    const interval = parseInt(minute.slice(2));
+    if (!isNaN(interval) && interval >= 30) {
+      return true;
+    }
+  }
+
+  // Allow hourly patterns: 0 */N * * * where N >= 1
+  if (minute === '0' && hour.startsWith('*/')) {
+    const interval = parseInt(hour.slice(2));
+    if (!isNaN(interval) && interval >= 1) {
+      return true;
+    }
+  }
+
+  // Allow specific hour patterns: 0 N * * * (runs once per day)
+  if (minute === '0' && /^\d+$/.test(hour)) {
+    const h = parseInt(hour);
+    if (!isNaN(h) && h >= 0 && h <= 23) {
+      return true;
+    }
+  }
+
+  return false;
 }, 'Minimum execution interval is 30 minutes');
 
 export const executionConditionsSchema = z

package/packages/file-loaders/package.json

@@ -25,7 +25,6 @@
     "test:coverage": "vitest --coverage --silent='passed-only'"
   },
   "dependencies": {
-    "@napi-rs/canvas": "^0.1.70",
     "@xmldom/xmldom": "^0.9.8",
     "concat-stream": "^2.0.0",
     "debug": "^4.4.3",
@@ -37,6 +36,7 @@
     "yauzl": "^3.2.0"
   },
   "devDependencies": {
+    "@napi-rs/canvas": "^0.1.70",
     "@types/concat-stream": "^2.0.3",
     "@types/yauzl": "^2.10.3",
     "typescript": "^5.9.3"

package/packages/prompts/src/prompts/userMemory/__snapshots__/formatSearchResults.test.ts.snap

@@ -0,0 +1,65 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`formatMemorySearchResults > should format context memories with full content 1`] = `
+"<memories query="project" total="1">
+<contexts count="1">
+  <context id="ctx-1" title="Web App Project" urgency=7 impact=8 type="project" status="in-progress">
+    Building a new web application
+    <subjects>John (person)</subjects>
+    <objects>React (application)</objects>
+  </context>
+</contexts>
+</memories>"
+`;
+
+exports[`formatMemorySearchResults > should format experience memories with full content 1`] = `
+"<memories query="debugging" total="1">
+<experiences count="1">
+  <experience id="exp-1" type="lesson" confidence=9>
+    <situation>Debugging complex state issues</situation>
+    <keyLearning>Breakpoints save time in complex debugging</keyLearning>
+  </experience>
+</experiences>
+</memories>"
+`;
+
+exports[`formatMemorySearchResults > should format mixed results with all memory types 1`] = `
+"<memories query="work" total="3">
+<contexts count="1">
+  <context id="ctx-1" title="Context Title">
+    Context description
+  </context>
+</contexts>
+<experiences count="1">
+  <experience id="exp-1">
+    <situation>Situation</situation>
+    <keyLearning>Key learning</keyLearning>
+  </experience>
+</experiences>
+<preferences count="1">
+  <preference id="pref-1">Directive</preference>
+</preferences>
+</memories>"
+`;
+
+exports[`formatMemorySearchResults > should format preference memories with full content 1`] = `
+"<memories query="code style" total="1">
+<preferences count="1">
+  <preference id="pref-1" type="coding-standard" priority=10>Always use TypeScript strict mode</preference>
+</preferences>
+</memories>"
+`;
+
+exports[`formatMemorySearchResults > should handle null and undefined values gracefully 1`] = `
+"<memories query="test" total="1">
+<contexts count="1">
+  <context id="ctx-1"></context>
+</contexts>
+</memories>"
+`;
+
+exports[`formatMemorySearchResults > should return empty results message when no memories found 1`] = `
+"<memories query="test query">
+  <status>No memories found matching the query.</status>
+</memories>"
+`;

package/packages/prompts/src/prompts/userMemory/formatSearchResults.test.ts

@@ -0,0 +1,200 @@
+import { UserMemoryContextObjectType, UserMemoryContextSubjectType } from '@lobechat/types';
+import { describe, expect, it } from 'vitest';
+
+import { formatMemorySearchResults } from './formatSearchResults';
+
+describe('formatMemorySearchResults', () => {
+  it('should return empty results message when no memories found', () => {
+    const result = formatMemorySearchResults({
+      query: 'test query',
+      results: {
+        contexts: [],
+        experiences: [],
+        preferences: [],
+      },
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should format context memories with full content', () => {
+    const result = formatMemorySearchResults({
+      query: 'project',
+      results: {
+        contexts: [
+          {
+            accessedAt: new Date('2024-01-01'),
+            associatedObjects: [{ name: 'React', type: UserMemoryContextObjectType.Application }],
+            associatedSubjects: [{ name: 'John', type: UserMemoryContextSubjectType.Person }],
+            createdAt: new Date('2024-01-01'),
+            currentStatus: 'in-progress',
+            description: 'Building a new web application',
+            id: 'ctx-1',
+            metadata: null,
+            scoreImpact: 8,
+            scoreUrgency: 7,
+            tags: ['frontend', 'react'],
+            title: 'Web App Project',
+            type: 'project',
+            updatedAt: new Date('2024-01-01'),
+            userMemoryIds: null,
+          },
+        ],
+        experiences: [],
+        preferences: [],
+      },
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should format experience memories with full content', () => {
+    const result = formatMemorySearchResults({
+      query: 'debugging',
+      results: {
+        contexts: [],
+        experiences: [
+          {
+            accessedAt: new Date('2024-01-01'),
+            action: 'Used breakpoints instead of console.log',
+            createdAt: new Date('2024-01-01'),
+            id: 'exp-1',
+            keyLearning: 'Breakpoints save time in complex debugging',
+            metadata: null,
+            possibleOutcome: 'Faster debugging sessions',
+            reasoning: 'Console logs clutter the code',
+            scoreConfidence: 9,
+            situation: 'Debugging complex state issues',
+            tags: ['debugging', 'best-practice'],
+            type: 'lesson',
+            updatedAt: new Date('2024-01-01'),
+            userMemoryId: null,
+          },
+        ],
+        preferences: [],
+      },
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should format preference memories with full content', () => {
+    const result = formatMemorySearchResults({
+      query: 'code style',
+      results: {
+        contexts: [],
+        experiences: [],
+        preferences: [
+          {
+            accessedAt: new Date('2024-01-01'),
+            conclusionDirectives: 'Always use TypeScript strict mode',
+            createdAt: new Date('2024-01-01'),
+            id: 'pref-1',
+            metadata: null,
+            scorePriority: 10,
+            suggestions: 'Consider adding eslint rules',
+            tags: ['typescript', 'code-quality'],
+            type: 'coding-standard',
+            updatedAt: new Date('2024-01-01'),
+            userMemoryId: null,
+          },
+        ],
+      },
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should format mixed results with all memory types', () => {
+    const result = formatMemorySearchResults({
+      query: 'work',
+      results: {
+        contexts: [
+          {
+            accessedAt: new Date('2024-01-01'),
+            associatedObjects: null,
+            associatedSubjects: null,
+            createdAt: new Date('2024-01-01'),
+            currentStatus: null,
+            description: 'Context description',
+            id: 'ctx-1',
+            metadata: null,
+            scoreImpact: null,
+            scoreUrgency: null,
+            tags: null,
+            title: 'Context Title',
+            type: null,
+            updatedAt: new Date('2024-01-01'),
+            userMemoryIds: null,
+          },
+        ],
+        experiences: [
+          {
+            accessedAt: new Date('2024-01-01'),
+            action: null,
+            createdAt: new Date('2024-01-01'),
+            id: 'exp-1',
+            keyLearning: 'Key learning',
+            metadata: null,
+            possibleOutcome: null,
+            reasoning: null,
+            scoreConfidence: null,
+            situation: 'Situation',
+            tags: null,
+            type: null,
+            updatedAt: new Date('2024-01-01'),
+            userMemoryId: null,
+          },
+        ],
+        preferences: [
+          {
+            accessedAt: new Date('2024-01-01'),
+            conclusionDirectives: 'Directive',
+            createdAt: new Date('2024-01-01'),
+            id: 'pref-1',
+            metadata: null,
+            scorePriority: null,
+            suggestions: null,
+            tags: null,
+            type: null,
+            updatedAt: new Date('2024-01-01'),
+            userMemoryId: null,
+          },
+        ],
+      },
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should handle null and undefined values gracefully', () => {
+    const result = formatMemorySearchResults({
+      query: 'test',
+      results: {
+        contexts: [
+          {
+            accessedAt: new Date('2024-01-01'),
+            associatedObjects: null,
+            associatedSubjects: null,
+            createdAt: new Date('2024-01-01'),
+            currentStatus: null,
+            description: null,
+            id: 'ctx-1',
+            metadata: null,
+            scoreImpact: null,
+            scoreUrgency: null,
+            tags: null,
+            title: null,
+            type: null,
+            updatedAt: new Date('2024-01-01'),
+            userMemoryIds: null,
+          },
+        ],
+        experiences: [],
+        preferences: [],
+      },
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+});

package/packages/prompts/src/prompts/userMemory/formatSearchResults.ts

@@ -0,0 +1,164 @@
+import type { SearchMemoryResult } from '@lobechat/types';
+
+/**
+ * Search result item interfaces matching the SearchMemoryResult type
+ */
+type ContextResult = SearchMemoryResult['contexts'][number];
+type ExperienceResult = SearchMemoryResult['experiences'][number];
+type PreferenceResult = SearchMemoryResult['preferences'][number];
+
+/**
+ * Format a single context memory item for search results
+ * Format: attributes for metadata, description as text content
+ */
+const formatContextResult = (item: ContextResult): string => {
+  const attrs: string[] = [`id="${item.id}"`];
+
+  if (item.title) {
+    attrs.push(`title="${item.title}"`);
+  }
+  if (item.scoreUrgency !== null && item.scoreUrgency !== undefined) {
+    attrs.push(`urgency=${item.scoreUrgency}`);
+  }
+  if (item.scoreImpact !== null && item.scoreImpact !== undefined) {
+    attrs.push(`impact=${item.scoreImpact}`);
+  }
+  if (item.type) {
+    attrs.push(`type="${item.type}"`);
+  }
+  if (item.currentStatus) {
+    attrs.push(`status="${item.currentStatus}"`);
+  }
+
+  const children: string[] = [];
+
+  // Description as main text content
+  if (item.description) {
+    children.push(`    ${item.description}`);
+  }
+
+  // Associated subjects (actors)
+  if (item.associatedSubjects && item.associatedSubjects.length > 0) {
+    const subjects = item.associatedSubjects
+      .filter((s) => s?.name)
+      .map((s) => `${s.name}${s.type ? ` (${s.type})` : ''}`)
+      .join(', ');
+    if (subjects) {
+      children.push(`    <subjects>${subjects}</subjects>`);
+    }
+  }
+
+  // Associated objects (resources)
+  if (item.associatedObjects && item.associatedObjects.length > 0) {
+    const objects = item.associatedObjects
+      .filter((o) => o?.name)
+      .map((o) => `${o.name}${o.type ? ` (${o.type})` : ''}`)
+      .join(', ');
+    if (objects) {
+      children.push(`    <objects>${objects}</objects>`);
+    }
+  }
+
+  const content = children.length > 0 ? `\n${children.join('\n')}\n  ` : '';
+
+  return `  <context ${attrs.join(' ')}>${content}</context>`;
+};
+
+/**
+ * Format a single experience memory item for search results
+ * Format: attributes for metadata, situation and keyLearning as child elements
+ */
+const formatExperienceResult = (item: ExperienceResult): string => {
+  const attrs: string[] = [`id="${item.id}"`];
+
+  if (item.type) {
+    attrs.push(`type="${item.type}"`);
+  }
+  if (item.scoreConfidence !== null && item.scoreConfidence !== undefined) {
+    attrs.push(`confidence=${item.scoreConfidence}`);
+  }
+
+  const children: string[] = [];
+
+  if (item.situation) {
+    children.push(`    <situation>${item.situation}</situation>`);
+  }
+  if (item.keyLearning) {
+    children.push(`    <keyLearning>${item.keyLearning}</keyLearning>`);
+  }
+
+  const content = children.length > 0 ? `\n${children.join('\n')}\n  ` : '';
+
+  return `  <experience ${attrs.join(' ')}>${content}</experience>`;
+};
+
+/**
+ * Format a single preference memory item for search results
+ * Format: attributes for metadata, directives as text content
+ */
+const formatPreferenceResult = (item: PreferenceResult): string => {
+  const attrs: string[] = [`id="${item.id}"`];
+
+  if (item.type) {
+    attrs.push(`type="${item.type}"`);
+  }
+  if (item.scorePriority !== null && item.scorePriority !== undefined) {
+    attrs.push(`priority=${item.scorePriority}`);
+  }
+
+  const content = item.conclusionDirectives || '';
+
+  return `  <preference ${attrs.join(' ')}>${content}</preference>`;
+};
+
+export interface FormatSearchResultsOptions {
+  /** The search query that was used */
+  query: string;
+  /** The search results to format */
+  results: SearchMemoryResult;
+}
+
+/**
+ * Format memory search results as XML for LLM consumption.
+ *
+ * This function formats the complete search results with all content details,
+ * making the retrieved memories directly usable by the LLM for reasoning
+ * and response generation.
+ */
+export const formatMemorySearchResults = ({
+  query,
+  results,
+}: FormatSearchResultsOptions): string => {
+  const { contexts, experiences, preferences } = results;
+  const total = contexts.length + experiences.length + preferences.length;
+
+  if (total === 0) {
+    return `<memories query="${query}">
+  <status>No memories found matching the query.</status>
+</memories>`;
+  }
+
+  const sections: string[] = [];
+
+  // Add contexts section
+  if (contexts.length > 0) {
+    const contextsXml = contexts.map(formatContextResult).join('\n');
+    sections.push(`<contexts count="${contexts.length}">\n${contextsXml}\n</contexts>`);
+  }
+
+  // Add experiences section
+  if (experiences.length > 0) {
+    const experiencesXml = experiences.map(formatExperienceResult).join('\n');
+    sections.push(`<experiences count="${experiences.length}">\n${experiencesXml}\n</experiences>`);
+  }
+
+  // Add preferences section
+  if (preferences.length > 0) {
+    const preferencesXml = preferences.map(formatPreferenceResult).join('\n');
+    sections.push(`<preferences count="${preferences.length}">\n${preferencesXml}\n</preferences>`);
+  }
+
+  return `<memories query="${query}" total="${total}">
+${sections.join('\n')}
+</memories>`;
+};

package/packages/prompts/src/prompts/userMemory/index.ts

@@ -1,3 +1,5 @@
+export * from './formatSearchResults';
+
 /**
  * User memory item interfaces
  */

package/scripts/electronWorkflow/buildNextApp.mts

@@ -20,6 +20,31 @@ const foldersToSymlink = [
 
 const foldersToCopy = ['src', 'scripts'];
 
+// Assets to remove from desktop build output (not needed for Electron app)
+const assetsToRemove = [
+  // Icons & favicons
+  'apple-touch-icon.png',
+  'favicon.ico',
+  'favicon-32x32.ico',
+  'favicon-16x16.png',
+  'favicon-32x32.png',
+
+  // SEO & sitemap
+  'sitemap.xml',
+  'sitemap-index.xml',
+  'sitemap',
+  'robots.txt',
+
+  // Incompatible pages
+  'not-compatible.html',
+  'not-compatible',
+
+  // Large media assets
+  'videos',
+  'screenshots',
+  'og',
+];
+
 const filesToCopy = [
   'package.json',
   'tsconfig.json',
@@ -85,10 +110,13 @@ const build = async () => {
 
   console.log('🏗  Running next build in shadow workspace...');
   try {
-    execSync('next build --webpack', {
+    execSync('next build', {
       cwd: TEMP_DIR,
       env: {
         ...process.env,
+        // Pass PROJECT_ROOT to next.config.ts for outputFileTracingRoot
+        // This fixes Turbopack symlink resolution when building in shadow workspace
+        ELECTRON_BUILD_PROJECT_ROOT: PROJECT_ROOT,
         NODE_OPTIONS: process.env.NODE_OPTIONS || '--max-old-space-size=8192',
       },
       stdio: 'inherit',
@@ -106,6 +134,16 @@ const build = async () => {
     if (fs.existsSync(sourceOutDir)) {
       console.log('📦 Moving "out" directory...');
       await fs.move(sourceOutDir, targetOutDir);
+
+      // Remove unnecessary assets from desktop build
+      console.log('🗑️  Removing unnecessary assets...');
+      for (const asset of assetsToRemove) {
+        const assetPath = path.join(targetOutDir, asset);
+        if (fs.existsSync(assetPath)) {
+          await fs.remove(assetPath);
+          console.log(`   Removed: ${asset}`);
+        }
+      }
     } else {
       console.warn("⚠️ 'out' directory not found. Using '.next' instead (fallback)?");
       const sourceNextDir = path.join(TEMP_DIR, '.next');

package/scripts/electronWorkflow/modifiers/nextConfig.mts

@@ -144,6 +144,32 @@ export const modifyNextConfig = async (TEMP_DIR: string) => {
         }
       }
 
+      // 6. Inject outputFileTracingRoot to fix symlink resolution for Turbopack
+      // When building in shadow workspace (TEMP_DIR), symlinks (e.g., node_modules) point to PROJECT_ROOT
+      // Turbopack's root defaults to TEMP_DIR, causing strip_prefix to fail for paths outside TEMP_DIR
+      // Setting outputFileTracingRoot to PROJECT_ROOT allows Turbopack to correctly resolve these symlinks
+      // We use ELECTRON_BUILD_PROJECT_ROOT env var which is set by buildNextApp.mts
+      const outputFileTracingRootPair = nextConfigDecl.find({
+        rule: {
+          pattern: 'outputFileTracingRoot: $A',
+        },
+      });
+      if (!outputFileTracingRootPair) {
+        const objectNode = nextConfigDecl.find({
+          rule: { kind: 'object' },
+        });
+        if (objectNode) {
+          const range = objectNode.range();
+          // Insert outputFileTracingRoot that reads from env var at build time
+          // Falls back to current directory if not in electron build context
+          edits.push({
+            end: range.start.index + 1,
+            start: range.start.index + 1,
+            text: "\n  outputFileTracingRoot: process.env.ELECTRON_BUILD_PROJECT_ROOT || process.cwd(),",
+          });
+        }
+      }
+
       // Remove withPWA wrapper
       const withPWA = root.find({
         rule: {