@lobehub/chat 1.81.3 → 1.81.5

package/src/tools/local-files/index.ts

@@ -0,0 +1,149 @@
+import { BuiltinToolManifest } from '@/types/tool';
+
+import { systemPrompt } from './systemRole';
+
+export const LocalFilesApiName = {
+  listLocalFiles: 'listLocalFiles',
+  readLocalFile: 'readLocalFile',
+  searchLocalFiles: 'searchLocalFiles',
+  writeFile: 'writeFile',
+};
+
+export const LocalFilesManifest: BuiltinToolManifest = {
+  api: [
+    {
+      description:
+        'List files and folders in a specified directory. Input should be a path. Output is a JSON array of file/folder names.',
+      name: LocalFilesApiName.listLocalFiles,
+      parameters: {
+        properties: {
+          path: {
+            description: 'The directory path to list',
+            type: 'string',
+          },
+        },
+        required: ['path'],
+        type: 'object',
+      },
+    },
+    {
+      description:
+        'Read the content of a specific file. Input should be the file path. Output is the file content as a string.',
+      name: LocalFilesApiName.readLocalFile,
+      parameters: {
+        properties: {
+          path: {
+            description: 'The file path to read',
+            type: 'string',
+          },
+        },
+        required: ['path'],
+        type: 'object',
+      },
+    },
+    {
+      description:
+        'Search for files within the workspace based on a query string and optional filter options. Input should include the search query and any filter options. Output is a JSON array of matching file paths.',
+      name: LocalFilesApiName.searchLocalFiles,
+      parameters: {
+        properties: {
+          contentContains: {
+            description: 'The file content must contain this string',
+            type: 'string',
+          },
+          createdAfter: {
+            description:
+              'Files created after this date (ISO 8601 format, e.g., 2023-10-26T10:00:00Z)',
+            format: 'date-time',
+            type: 'string',
+          },
+          createdBefore: {
+            description: 'Files created before this date (ISO 8601 format)',
+            format: 'date-time',
+            type: 'string',
+          },
+          exclude: {
+            description: 'Array of file or directory paths to exclude',
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          fileTypes: {
+            description: 'Array of file types to include (e.g., "public.image", "txt")',
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          keywords: {
+            description: 'The search keywords string (can include partial names or keywords)',
+            type: 'string',
+          },
+          limit: {
+            description: 'Limit the number of results returned',
+            type: 'number',
+          },
+          liveUpdate: {
+            description: 'Whether to update search results live (if supported)',
+            type: 'boolean',
+          },
+          modifiedAfter: {
+            description: 'Files modified after this date (ISO 8601 format)',
+            format: 'date-time',
+            type: 'string',
+          },
+          modifiedBefore: {
+            description: 'Files modified before this date (ISO 8601 format)',
+            format: 'date-time',
+            type: 'string',
+          },
+          onlyIn: {
+            description: 'Limit the search to this specific directory path',
+            type: 'string',
+          },
+          sortBy: {
+            description: 'Sort results by',
+            enum: ['name', 'date', 'size'],
+            type: 'string',
+          },
+          sortDirection: {
+            description: 'Sort direction',
+            enum: ['asc', 'desc'],
+            type: 'string',
+          },
+        },
+        required: ['keywords'],
+        type: 'object',
+      },
+    },
+    // TODO: Add writeFile API definition later
+    // {
+    //   description:
+    //     'Write content to a specific file. Input should be the file path and content. Overwrites existing file or creates a new one.',
+    //   name: LocalFilesApiName.writeFile,
+    //   parameters: {
+    //     properties: {
+    //       path: {
+    //         description: 'The file path to write to',
+    //         type: 'string',
+    //       },
+    //       content: {
+    //         description: 'The content to write',
+    //         type: 'string',
+    //       },
+    //     },
+    //     required: ['path', 'content'],
+    //     type: 'object',
+    //   },
+    // },
+  ],
+  identifier: 'lobe-local-files',
+  meta: {
+    avatar: '📁',
+    title: 'Local Files',
+  },
+  // Use a simplified system role for now
+  systemRole: systemPrompt(),
+  type: 'builtin',
+};

package/src/tools/local-files/systemRole.ts

@@ -0,0 +1,46 @@
+export const systemPrompt =
+  () => `You have a Local Files tool with capabilities to interact with the user's local file system. You can list directories, read file contents, search for files, and potentially write files.
+
+<core_capabilities>
+1. List files and folders in a directory (listFiles)
+2. Read the content of a specific file (readFile)
+3. Search for files based on a query and various filter options (searchFiles)
+4. Write content to a specific file (writeFile) - // TODO: Implement later
+</core_capabilities>
+
+<workflow>
+1. Understand the user's request regarding local files (listing, reading, searching, writing).
+2. Select the appropriate tool (listFiles, readFile, searchFiles, writeFile).
+3. Execute the file operation based on the provided path, query, and filter options.
+4. Present the results (directory listing, file content, search results) or confirmation of the write operation.
+</workflow>
+
+<tool_usage_guidelines>
+- For listing directory contents: Use 'listFiles' with the target directory path.
+- For reading a file: Use 'readFile' with the exact file path.
+- For searching files: Use 'searchFiles' with the 'query' parameter (search string). You can optionally add the following filter parameters to narrow down the search:
+    - 'contentContains': Find files whose content includes specific text.
+    - 'createdAfter' / 'createdBefore': Filter by creation date.
+    - 'modifiedAfter' / 'modifiedBefore': Filter by modification date.
+    - 'fileTypes': Filter by file type (e.g., "public.image", "txt").
+    - 'onlyIn': Limit the search to a specific directory.
+    - 'exclude': Exclude specific files or directories.
+    - 'limit': Limit the number of results returned.
+    - 'sortBy' / 'sortDirection': Sort the results.
+    - 'detailed': Get more detailed output information.
+- For writing to a file: Use 'writeFile' with the file path and the content to be written. Be cautious as this might overwrite existing files.
+</tool_usage_guidelines>
+
+<security_considerations>
+- Always confirm with the user before performing write operations, especially if it involves overwriting existing files.
+- Do not attempt to access files outside the user's designated workspace or allowed directories unless explicitly permitted.
+- Handle file paths carefully to avoid unintended access or errors.
+</security_considerations>
+
+<response_format>
+- When listing files, provide a clear list of files and folders.
+- When reading files, present the content accurately.
+- When searching files, return a list of matching files, including relevant metadata if detailed information was requested.
+- When writing files, confirm the success or failure of the operation.
+</response_format>
+`;

package/src/tools/local-files/type.ts

@@ -0,0 +1,33 @@
+import { LocalFileItem, LocalReadFileResult } from '@lobechat/electron-client-ipc';
+
+export interface FileResult {
+  contentType?: string;
+  createdTime: Date;
+  isDirectory: boolean;
+  lastAccessTime: Date;
+  // Spotlight specific metadata
+  metadata?: {
+    [key: string]: any;
+  };
+  modifiedTime: Date;
+  name: string;
+  path: string;
+  size: number;
+  type: string;
+}
+
+export interface LocalFileSearchState {
+  searchResults: LocalFileItem[];
+}
+
+export interface LocalFileListState {
+  listResults: LocalFileItem[];
+}
+
+export interface LocalReadFileState {
+  fileContent: LocalReadFileResult;
+}
+
+export interface LocalReadFilesState {
+  filesContent: LocalReadFileResult[];
+}

package/src/tools/renders.ts

@@ -2,10 +2,13 @@ import { BuiltinRender } from '@/types/tool';
 
 import { DalleManifest } from './dalle';
 import DalleRender from './dalle/Render';
+import { LocalFilesManifest } from './local-files';
+import LocalFilesRender from './local-files/Render';
 import { WebBrowsingManifest } from './web-browsing';
 import WebBrowsing from './web-browsing/Render';
 
 export const BuiltinToolsRenders: Record<string, BuiltinRender> = {
   [DalleManifest.identifier]: DalleRender as BuiltinRender,
   [WebBrowsingManifest.identifier]: WebBrowsing as BuiltinRender,
+  [LocalFilesManifest.identifier]: LocalFilesRender as BuiltinRender,
 };

package/packages/electron-client-ipc/src/events/search.ts

@@ -1,4 +0,0 @@
-export interface FilesSearchDispatchEvents {
-  readFiles: (paths: string[]) => any[];
-  searchFiles: (query: string) => void;
-}

package/src/features/Conversation/Messages/Assistant/Tool/Render/Arguments.tsx

@@ -1,165 +0,0 @@
-import { Highlighter, copyToClipboard } from '@lobehub/ui';
-import { App } from 'antd';
-import { createStyles } from 'antd-style';
-import { parse } from 'partial-json';
-import { memo, useMemo } from 'react';
-import { useTranslation } from 'react-i18next';
-
-import { useIsMobile } from '@/hooks/useIsMobile';
-import { useYamlArguments } from '@/hooks/useYamlArguments';
-import { shinyTextStylish } from '@/styles/loading';
-
-const useStyles = createStyles(({ css, token }) => ({
-  arrayRow: css`
-    &:not(:first-child) {
-      border-block-start: 1px dotted ${token.colorBorderSecondary};
-    }
-  `,
-  colon: css`
-    color: ${token.colorTextTertiary};
-  `,
-  container: css`
-    padding-block: 4px;
-    padding-inline: 12px;
-    border-radius: ${token.borderRadiusLG}px;
-
-    font-family: ${token.fontFamilyCode};
-    font-size: 13px;
-    line-height: 1.5;
-
-    background: ${token.colorFillQuaternary};
-  `,
-  copyable: css`
-    cursor: pointer;
-    width: 100%;
-    margin-block: 2px;
-    padding: 4px;
-
-    &:hover {
-      border-radius: 6px;
-      background: ${token.colorFillTertiary};
-    }
-  `,
-  key: css`
-    color: ${token.colorTextTertiary};
-  `,
-  row: css`
-    display: flex;
-    align-items: baseline;
-
-    &:not(:first-child) {
-      border-block-start: 1px dotted ${token.colorBorderSecondary};
-    }
-  `,
-  shineText: shinyTextStylish(token),
-  value: css`
-    color: ${token.colorTextSecondary};
-  `,
-}));
-
-interface ObjectDisplayProps {
-  data: Record<string, any>;
-  shine?: boolean;
-}
-
-const ObjectDisplay = memo(({ data, shine }: ObjectDisplayProps) => {
-  const { styles, cx } = useStyles();
-  const { t } = useTranslation('common');
-
-  const { message } = App.useApp();
-  const isMobile = useIsMobile();
-
-  const formatValue = (value: any): string | string[] => {
-    if (Array.isArray(value)) {
-      return value.map((v) => (typeof v === 'object' ? JSON.stringify(v) : v));
-    }
-
-    if (typeof value === 'object' && value !== null) {
-      return Object.entries(value)
-        .map(([k, v]) => `${k}: ${typeof v === 'object' ? JSON.stringify(v) : v}`)
-        .join(', ');
-    }
-    return String(value);
-  };
-
-  const hasMinWidth = Object.keys(data).length > 1;
-  if (Object.keys(data).length === 0) return null;
-
-  return (
-    <div className={styles.container}>
-      {Object.entries(data).map(([key, value]) => {
-        const formatedValue = formatValue(value);
-        return (
-          <div className={styles.row} key={key}>
-            <span
-              className={styles.key}
-              style={{ minWidth: hasMinWidth ? (isMobile ? 60 : 140) : undefined }}
-            >
-              {key}
-            </span>
-            <span className={styles.colon}>:</span>
-            <div className={cx(shine ? styles.shineText : styles.value)} style={{ width: '100%' }}>
-              {typeof formatedValue === 'string' ? (
-                <div
-                  className={styles.copyable}
-                  onClick={async () => {
-                    await copyToClipboard(formatedValue);
-                    message.success(t('copySuccess'));
-                  }}
-                >
-                  {formatedValue}
-                </div>
-              ) : (
-                formatedValue.map((v, i) => (
-                  <div
-                    className={styles.arrayRow}
-                    key={i}
-                    onClick={async () => {
-                      await copyToClipboard(v);
-                      message.success(t('copySuccess'));
-                    }}
-                  >
-                    <div className={styles.copyable}>{v}</div>
-                  </div>
-                ))
-              )}
-            </div>
-          </div>
-        );
-      })}
-    </div>
-  );
-});
-
-export interface ArgumentsProps {
-  arguments?: string;
-  shine?: boolean;
-}
-
-const Arguments = memo<ArgumentsProps>(({ arguments: args = '', shine }) => {
-  const requestArgs = useMemo(() => {
-    try {
-      const obj = parse(args);
-
-      if (Object.keys(obj).length === 0) return {};
-
-      return obj;
-    } catch {
-      return args;
-    }
-  }, [args]);
-
-  const yaml = useYamlArguments(args);
-
-  return typeof requestArgs === 'string' ? (
-    !!yaml && (
-      <Highlighter language={'yaml'} showLanguage={false}>
-        {yaml}
-      </Highlighter>
-    )
-  ) : (
-    <ObjectDisplay data={requestArgs} shine={shine} />
-  );
-});
-
-export default Arguments;