@lobehub/lobehub 2.0.0-next.306 → 2.0.0-next.308

package/packages/prompts/src/prompts/fileSystem/formatCommandResult.ts

@@ -0,0 +1,35 @@
+export interface FormatCommandResultParams {
+  error?: string;
+  exitCode?: number;
+  shellId?: string;
+  stderr?: string;
+  stdout?: string;
+  success: boolean;
+}
+
+export const formatCommandResult = ({
+  success,
+  shellId,
+  error,
+  stdout,
+  stderr,
+  exitCode,
+}: FormatCommandResultParams): string => {
+  const parts: string[] = [];
+
+  if (success) {
+    if (shellId) {
+      parts.push(`Command started in background with shell_id: ${shellId}`);
+    } else {
+      parts.push('Command completed successfully.');
+    }
+  } else {
+    parts.push(`Command failed: ${error}`);
+  }
+
+  if (stdout) parts.push(`Output:\n${stdout}`);
+  if (stderr) parts.push(`Stderr:\n${stderr}`);
+  if (exitCode !== undefined) parts.push(`Exit code: ${exitCode}`);
+
+  return parts.join('\n\n');
+};

package/packages/prompts/src/prompts/fileSystem/formatEditResult.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatEditResult } from './formatEditResult';
+
+describe('formatEditResult', () => {
+  it('should format edit result without line stats', () => {
+    const result = formatEditResult({
+      filePath: '/src/index.ts',
+      replacements: 3,
+    });
+    expect(result).toMatchInlineSnapshot(
+      `"Successfully replaced 3 occurrence(s) in /src/index.ts"`,
+    );
+  });
+
+  it('should format edit result with lines added', () => {
+    const result = formatEditResult({
+      filePath: '/src/index.ts',
+      linesAdded: 5,
+      replacements: 1,
+    });
+    expect(result).toMatchInlineSnapshot(
+      `"Successfully replaced 1 occurrence(s) in /src/index.ts (+5 -0)"`,
+    );
+  });
+
+  it('should format edit result with lines deleted', () => {
+    const result = formatEditResult({
+      filePath: '/src/index.ts',
+      linesDeleted: 3,
+      replacements: 2,
+    });
+    expect(result).toMatchInlineSnapshot(
+      `"Successfully replaced 2 occurrence(s) in /src/index.ts (+0 -3)"`,
+    );
+  });
+
+  it('should format edit result with both lines added and deleted', () => {
+    const result = formatEditResult({
+      filePath: '/src/utils.ts',
+      linesAdded: 10,
+      linesDeleted: 5,
+      replacements: 4,
+    });
+    expect(result).toMatchInlineSnapshot(
+      `"Successfully replaced 4 occurrence(s) in /src/utils.ts (+10 -5)"`,
+    );
+  });
+
+  it('should handle zero replacements', () => {
+    const result = formatEditResult({
+      filePath: '/test.txt',
+      replacements: 0,
+    });
+    expect(result).toMatchInlineSnapshot(`"Successfully replaced 0 occurrence(s) in /test.txt"`);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatEditResult.ts

@@ -0,0 +1,17 @@
+export interface FormatEditResultParams {
+  filePath: string;
+  linesAdded?: number;
+  linesDeleted?: number;
+  replacements: number;
+}
+
+export const formatEditResult = ({
+  replacements,
+  filePath,
+  linesAdded,
+  linesDeleted,
+}: FormatEditResultParams): string => {
+  const statsText =
+    linesAdded || linesDeleted ? ` (+${linesAdded || 0} -${linesDeleted || 0})` : '';
+  return `Successfully replaced ${replacements} occurrence(s) in ${filePath}${statsText}`;
+};

package/packages/prompts/src/prompts/fileSystem/formatFileContent.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatFileContent } from './formatFileContent';
+
+describe('formatFileContent', () => {
+  it('should format file content without line range', () => {
+    const result = formatFileContent({
+      content: 'console.log("hello");',
+      path: '/src/index.ts',
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "File: /src/index.ts
+
+      console.log("hello");"
+    `);
+  });
+
+  it('should format file content with line range', () => {
+    const result = formatFileContent({
+      content: 'function test() {\n  return true;\n}',
+      lineRange: [10, 12],
+      path: '/src/utils.ts',
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "File: /src/utils.ts (lines 10-12)
+
+      function test() {
+        return true;
+      }"
+    `);
+  });
+
+  it('should handle empty content', () => {
+    const result = formatFileContent({
+      content: '',
+      path: '/empty.txt',
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "File: /empty.txt
+
+      "
+    `);
+  });
+
+  it('should handle multiline content', () => {
+    const content = 'line 1\nline 2\nline 3';
+    const result = formatFileContent({
+      content,
+      path: '/test.txt',
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "File: /test.txt
+
+      line 1
+      line 2
+      line 3"
+    `);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatFileContent.ts

@@ -0,0 +1,14 @@
+export interface FormatFileContentParams {
+  content: string;
+  lineRange?: [number, number];
+  path: string;
+}
+
+export const formatFileContent = ({
+  path,
+  content,
+  lineRange,
+}: FormatFileContentParams): string => {
+  const lineInfo = lineRange ? ` (lines ${lineRange[0]}-${lineRange[1]})` : '';
+  return `File: ${path}${lineInfo}\n\n${content}`;
+};

package/packages/prompts/src/prompts/fileSystem/formatFileList.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatFileList } from './formatFileList';
+
+describe('formatFileList', () => {
+  it('should format empty directory', () => {
+    const result = formatFileList([], '/home/user');
+    expect(result).toMatchInlineSnapshot(`"Directory /home/user is empty"`);
+  });
+
+  it('should format directory with files only', () => {
+    const files = [
+      { isDirectory: false, name: 'file1.txt' },
+      { isDirectory: false, name: 'file2.js' },
+    ];
+    const result = formatFileList(files, '/home/user');
+    expect(result).toMatchInlineSnapshot(`
+      "Found 2 item(s) in /home/user:
+        [F] file1.txt
+        [F] file2.js"
+    `);
+  });
+
+  it('should format directory with directories only', () => {
+    const files = [
+      { isDirectory: true, name: 'src' },
+      { isDirectory: true, name: 'dist' },
+    ];
+    const result = formatFileList(files, '/project');
+    expect(result).toMatchInlineSnapshot(`
+      "Found 2 item(s) in /project:
+        [D] src
+        [D] dist"
+    `);
+  });
+
+  it('should format directory with mixed content', () => {
+    const files = [
+      { isDirectory: true, name: 'src' },
+      { isDirectory: false, name: 'package.json' },
+      { isDirectory: true, name: 'node_modules' },
+      { isDirectory: false, name: 'README.md' },
+    ];
+    const result = formatFileList(files, '/project');
+    expect(result).toMatchInlineSnapshot(`
+      "Found 4 item(s) in /project:
+        [D] src
+        [F] package.json
+        [D] node_modules
+        [F] README.md"
+    `);
+  });
+
+  it('should format single item', () => {
+    const files = [{ isDirectory: false, name: 'index.ts' }];
+    const result = formatFileList(files, '/src');
+    expect(result).toMatchInlineSnapshot(`
+      "Found 1 item(s) in /src:
+        [F] index.ts"
+    `);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatFileList.ts

@@ -0,0 +1,13 @@
+export interface FileListItem {
+  isDirectory: boolean;
+  name: string;
+}
+
+export const formatFileList = (files: FileListItem[], directory: string): string => {
+  if (files.length === 0) {
+    return `Directory ${directory} is empty`;
+  }
+
+  const fileList = files.map((f) => `  ${f.isDirectory ? '[D]' : '[F]'} ${f.name}`).join('\n');
+  return `Found ${files.length} item(s) in ${directory}:\n${fileList}`;
+};

package/packages/prompts/src/prompts/fileSystem/formatFileSearchResults.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatFileSearchResults } from './formatFileSearchResults';
+
+describe('formatFileSearchResults', () => {
+  it('should format empty results', () => {
+    const result = formatFileSearchResults([]);
+    expect(result).toMatchInlineSnapshot(`"No files found"`);
+  });
+
+  it('should format single result', () => {
+    const results = [{ path: '/src/index.ts' }];
+    const result = formatFileSearchResults(results);
+    expect(result).toMatchInlineSnapshot(`
+      "Found 1 file(s):
+        /src/index.ts"
+    `);
+  });
+
+  it('should format multiple results', () => {
+    const results = [
+      { path: '/src/index.ts' },
+      { path: '/src/utils.ts' },
+      { path: '/src/types.ts' },
+    ];
+    const result = formatFileSearchResults(results);
+    expect(result).toMatchInlineSnapshot(`
+      "Found 3 file(s):
+        /src/index.ts
+        /src/utils.ts
+        /src/types.ts"
+    `);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatFileSearchResults.ts

@@ -0,0 +1,12 @@
+export interface FileSearchResultItem {
+  path: string;
+}
+
+export const formatFileSearchResults = (results: FileSearchResultItem[]): string => {
+  if (results.length === 0) {
+    return 'No files found';
+  }
+
+  const fileList = results.map((f) => `  ${f.path}`).join('\n');
+  return `Found ${results.length} file(s):\n${fileList}`;
+};

package/packages/prompts/src/prompts/fileSystem/formatGlobResults.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatGlobResults } from './formatGlobResults';
+
+describe('formatGlobResults', () => {
+  it('should format empty results', () => {
+    const result = formatGlobResults({
+      files: [],
+      totalFiles: 0,
+    });
+    expect(result).toMatchInlineSnapshot(`"Found 0 files"`);
+  });
+
+  it('should format single file', () => {
+    const result = formatGlobResults({
+      files: ['/src/index.ts'],
+      totalFiles: 1,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Found 1 files:
+        /src/index.ts"
+    `);
+  });
+
+  it('should format multiple files', () => {
+    const result = formatGlobResults({
+      files: ['/src/index.ts', '/src/utils.ts', '/src/types.ts'],
+      totalFiles: 3,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Found 3 files:
+        /src/index.ts
+        /src/utils.ts
+        /src/types.ts"
+    `);
+  });
+
+  it('should truncate files exceeding maxDisplay (default 50)', () => {
+    const files = Array.from({ length: 55 }, (_, i) => `/file${i + 1}.ts`);
+    const result = formatGlobResults({
+      files,
+      totalFiles: 55,
+    });
+    expect(result).toContain('Found 55 files:');
+    expect(result).toContain('... and 5 more');
+    expect(result).not.toContain('file51');
+  });
+
+  it('should respect custom maxDisplay', () => {
+    const files = ['/a.ts', '/b.ts', '/c.ts', '/d.ts', '/e.ts'];
+    const result = formatGlobResults({
+      files,
+      maxDisplay: 3,
+      totalFiles: 5,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Found 5 files:
+        /a.ts
+        /b.ts
+        /c.ts
+        ... and 2 more"
+    `);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatGlobResults.ts

@@ -0,0 +1,23 @@
+export interface FormatGlobResultsParams {
+  files: string[];
+  maxDisplay?: number;
+  totalFiles: number;
+}
+
+export const formatGlobResults = ({
+  totalFiles,
+  files,
+  maxDisplay = 50,
+}: FormatGlobResultsParams): string => {
+  const message = `Found ${totalFiles} files`;
+
+  if (files.length === 0) {
+    return message;
+  }
+
+  const displayFiles = files.slice(0, maxDisplay);
+  const fileList = displayFiles.map((f) => `  ${f}`).join('\n');
+  const moreInfo = files.length > maxDisplay ? `\n  ... and ${files.length - maxDisplay} more` : '';
+
+  return `${message}:\n${fileList}${moreInfo}`;
+};

package/packages/prompts/src/prompts/fileSystem/formatGrepResults.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatGrepResults } from './formatGrepResults';
+
+describe('formatGrepResults', () => {
+  it('should format empty results', () => {
+    const result = formatGrepResults({
+      matches: [],
+      totalMatches: 0,
+    });
+    expect(result).toMatchInlineSnapshot(`"Found 0 matches in 0 locations"`);
+  });
+
+  it('should format single match', () => {
+    const result = formatGrepResults({
+      matches: ['/src/index.ts:10: const foo = "bar"'],
+      totalMatches: 1,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Found 1 matches in 1 locations:
+        /src/index.ts:10: const foo = "bar""
+    `);
+  });
+
+  it('should format multiple matches', () => {
+    const result = formatGrepResults({
+      matches: ['/src/index.ts:10: match1', '/src/utils.ts:20: match2', '/src/types.ts:30: match3'],
+      totalMatches: 5,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Found 5 matches in 3 locations:
+        /src/index.ts:10: match1
+        /src/utils.ts:20: match2
+        /src/types.ts:30: match3"
+    `);
+  });
+
+  it('should truncate matches exceeding maxDisplay', () => {
+    const matches = Array.from({ length: 25 }, (_, i) => `match${i + 1}`);
+    const result = formatGrepResults({
+      matches,
+      totalMatches: 100,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Found 100 matches in 25 locations:
+        match1
+        match2
+        match3
+        match4
+        match5
+        match6
+        match7
+        match8
+        match9
+        match10
+        match11
+        match12
+        match13
+        match14
+        match15
+        match16
+        match17
+        match18
+        match19
+        match20
+        ... and 5 more"
+    `);
+  });
+
+  it('should respect custom maxDisplay', () => {
+    const matches = ['match1', 'match2', 'match3', 'match4', 'match5'];
+    const result = formatGrepResults({
+      matches,
+      maxDisplay: 3,
+      totalMatches: 10,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Found 10 matches in 5 locations:
+        match1
+        match2
+        match3
+        ... and 2 more"
+    `);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatGrepResults.ts

@@ -0,0 +1,24 @@
+export interface FormatGrepResultsParams {
+  matches: string[];
+  maxDisplay?: number;
+  totalMatches: number;
+}
+
+export const formatGrepResults = ({
+  totalMatches,
+  matches,
+  maxDisplay = 20,
+}: FormatGrepResultsParams): string => {
+  const message = `Found ${totalMatches} matches in ${matches.length} locations`;
+
+  if (matches.length === 0) {
+    return message;
+  }
+
+  const displayMatches = matches.slice(0, maxDisplay);
+  const matchList = displayMatches.map((m) => `  ${m}`).join('\n');
+  const moreInfo =
+    matches.length > maxDisplay ? `\n  ... and ${matches.length - maxDisplay} more` : '';
+
+  return `${message}:\n${matchList}${moreInfo}`;
+};

package/packages/prompts/src/prompts/fileSystem/formatKillResult.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatKillResult } from './formatKillResult';
+
+describe('formatKillResult', () => {
+  it('should format successful kill', () => {
+    const result = formatKillResult({
+      shellId: 'shell-123',
+      success: true,
+    });
+    expect(result).toMatchInlineSnapshot(`"Successfully killed shell: shell-123"`);
+  });
+
+  it('should format failed kill', () => {
+    const result = formatKillResult({
+      error: 'Process not found',
+      shellId: 'shell-456',
+      success: false,
+    });
+    expect(result).toMatchInlineSnapshot(`"Failed to kill shell: Process not found"`);
+  });
+
+  it('should format failed kill without error message', () => {
+    const result = formatKillResult({
+      shellId: 'shell-789',
+      success: false,
+    });
+    expect(result).toMatchInlineSnapshot(`"Failed to kill shell: undefined"`);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatKillResult.ts

@@ -0,0 +1,9 @@
+export interface FormatKillResultParams {
+  error?: string;
+  shellId: string;
+  success: boolean;
+}
+
+export const formatKillResult = ({ success, shellId, error }: FormatKillResultParams): string => {
+  return success ? `Successfully killed shell: ${shellId}` : `Failed to kill shell: ${error}`;
+};

package/packages/prompts/src/prompts/fileSystem/formatMoveResults.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatMoveResults } from './formatMoveResults';
+
+describe('formatMoveResults', () => {
+  it('should format all successful moves', () => {
+    const results = [{ success: true }, { success: true }, { success: true }];
+    const result = formatMoveResults(results);
+    expect(result).toMatchInlineSnapshot(`"Successfully moved 3 item(s)."`);
+  });
+
+  it('should format all failed moves', () => {
+    const results = [{ success: false }, { success: false }];
+    const result = formatMoveResults(results);
+    expect(result).toMatchInlineSnapshot(`"Failed to move all 2 item(s)."`);
+  });
+
+  it('should format partial success', () => {
+    const results = [{ success: true }, { success: false }, { success: true }];
+    const result = formatMoveResults(results);
+    expect(result).toMatchInlineSnapshot(
+      `"Moved 2 item(s) successfully. Failed to move 1 item(s)."`,
+    );
+  });
+
+  it('should handle single item success', () => {
+    const results = [{ success: true }];
+    const result = formatMoveResults(results);
+    expect(result).toMatchInlineSnapshot(`"Successfully moved 1 item(s)."`);
+  });
+
+  it('should handle single item failure', () => {
+    const results = [{ success: false }];
+    const result = formatMoveResults(results);
+    expect(result).toMatchInlineSnapshot(`"Failed to move all 1 item(s)."`);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatMoveResults.ts

@@ -0,0 +1,20 @@
+export interface MoveResultItem {
+  success: boolean;
+}
+
+export const formatMoveResults = (results: MoveResultItem[]): string => {
+  const successCount = results.filter((r) => r.success).length;
+  const failedCount = results.length - successCount;
+  const allSucceeded = failedCount === 0;
+  const allFailed = successCount === 0;
+
+  if (allSucceeded) {
+    return `Successfully moved ${results.length} item(s).`;
+  }
+
+  if (allFailed) {
+    return `Failed to move all ${results.length} item(s).`;
+  }
+
+  return `Moved ${successCount} item(s) successfully. Failed to move ${failedCount} item(s).`;
+};

package/packages/prompts/src/prompts/fileSystem/formatMultipleFiles.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatMultipleFiles } from './formatMultipleFiles';
+
+describe('formatMultipleFiles', () => {
+  it('should format single file', () => {
+    const files = [{ content: 'hello world', filename: 'test.txt' }];
+    const result = formatMultipleFiles(files);
+    expect(result).toMatchInlineSnapshot(`
+      "Read 1 file(s):
+
+      === test.txt ===
+      hello world"
+    `);
+  });
+
+  it('should format multiple files', () => {
+    const files = [
+      { content: 'content 1', filename: 'file1.txt' },
+      { content: 'content 2', filename: 'file2.txt' },
+    ];
+    const result = formatMultipleFiles(files);
+    expect(result).toMatchInlineSnapshot(`
+      "Read 2 file(s):
+
+      === file1.txt ===
+      content 1
+
+      === file2.txt ===
+      content 2"
+    `);
+  });
+
+  it('should handle empty files array', () => {
+    const result = formatMultipleFiles([]);
+    expect(result).toMatchInlineSnapshot(`
+      "Read 0 file(s):
+
+      "
+    `);
+  });
+
+  it('should handle files with multiline content', () => {
+    const files = [{ content: 'line 1\nline 2', filename: 'multi.txt' }];
+    const result = formatMultipleFiles(files);
+    expect(result).toMatchInlineSnapshot(`
+      "Read 1 file(s):
+
+      === multi.txt ===
+      line 1
+      line 2"
+    `);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatMultipleFiles.ts

@@ -0,0 +1,9 @@
+export interface FileContentItem {
+  content: string;
+  filename: string;
+}
+
+export const formatMultipleFiles = (files: FileContentItem[]): string => {
+  const fileContents = files.map((f) => `=== ${f.filename} ===\n${f.content}`).join('\n\n');
+  return `Read ${files.length} file(s):\n\n${fileContents}`;
+};