@proteinjs/conversation 2.1.3 → 2.1.5

package/src/fs/conversation_fs/FsFunctions.ts

@@ -1,6 +1,50 @@
 import { File, Fs } from '@proteinjs/util-node';
 import { Function } from '../../Function';
 import { ConversationFsModule } from './ConversationFsModule';
+import path from 'path';
+
+const toRepoAbs = (mod: ConversationFsModule, p: string) => (path.isAbsolute(p) ? p : path.join(mod.getRepoPath(), p));
+
+// If path doesn’t exist, try to resolve "<repo>/<basename>" to the actual file under repo
+async function canonicalizePaths(mod: ConversationFsModule, paths: string[]): Promise<string[]> {
+  const repo = mod.getRepoPath();
+  const ignore = ['**/node_modules/**', '**/dist/**', '**/.git/**'];
+
+  const out: string[] = [];
+  for (const p of paths) {
+    const abs = toRepoAbs(mod, p);
+    if (await Fs.exists(abs)) {
+      out.push(abs);
+      continue;
+    }
+    const base = path.basename(p);
+    if (!base) {
+      out.push(abs);
+      continue;
+    }
+    const parsed = path.parse(base); // { name, ext }
+    const pattern = parsed.ext ? `**/${parsed.name}${parsed.ext}` : `**/${parsed.name}.*`;
+
+    let matches: string[] = [];
+    try {
+      matches = await (Fs as any).getFilePathsMatchingGlob(repo, pattern, ignore);
+    } catch {
+      // fall through
+    }
+
+    if (matches.length === 1) {
+      out.push(matches[0]);
+    } else if (matches.length > 1) {
+      // Prefer the shortest match (usually “src/...” beats deeper/duplicate locations)
+      matches.sort((a, b) => a.length - b.length);
+      out.push(matches[0]);
+    } else {
+      // No luck; keep the original absolute (will throw with a clear error)
+      out.push(abs);
+    }
+  }
+  return out;
+}
 
 export const readFilesFunctionName = 'readFiles';
 export function readFilesFunction(fsModule: ConversationFsModule) {
@@ -14,9 +58,7 @@ export function readFilesFunction(fsModule: ConversationFsModule) {
           filePaths: {
             type: 'array',
             description: 'Paths to the files',
-            items: {
-              type: 'string',
-            },
+            items: { type: 'string' },
           },
         },
         required: ['filePaths'],
@@ -24,7 +66,8 @@ export function readFilesFunction(fsModule: ConversationFsModule) {
     },
     call: async (params: { filePaths: string[] }) => {
       fsModule.pushRecentlyAccessedFilePath(params.filePaths);
-      return await Fs.readFiles(params.filePaths);
+      const absPaths = await canonicalizePaths(fsModule, params.filePaths);
+      return await Fs.readFiles(absPaths);
     },
     instructions: [`To read files from the local file system, use the ${readFilesFunctionName} function`],
   };
@@ -41,19 +84,10 @@ export function writeFilesFunction(fsModule: ConversationFsModule) {
         properties: {
           files: {
             type: 'array',
-            description: 'Files to write',
             items: {
               type: 'object',
-              properties: {
-                path: {
-                  type: 'string',
-                  description: 'the file path',
-                },
-                content: {
-                  type: 'string',
-                  description: 'the content to write to the file',
-                },
-              },
+              properties: { path: { type: 'string' }, content: { type: 'string' } },
+              required: ['path', 'content'],
             },
           },
         },
@@ -61,8 +95,13 @@ export function writeFilesFunction(fsModule: ConversationFsModule) {
       },
     },
     call: async (params: { files: File[] }) => {
-      fsModule.pushRecentlyAccessedFilePath(params.files.map((file) => file.path));
-      return await Fs.writeFiles(params.files);
+      fsModule.pushRecentlyAccessedFilePath(params.files.map((f) => f.path));
+      const canon = await canonicalizePaths(
+        fsModule,
+        params.files.map((f) => f.path)
+      );
+      const absFiles = params.files.map((f, i) => ({ ...f, path: canon[i] }));
+      return await Fs.writeFiles(absFiles);
     },
     instructions: [`To write files to the local file system, use the ${writeFilesFunctionName} function`],
   };
@@ -232,6 +271,47 @@ const moveFunction: Function = {
   instructions: [`To move a file or directory, use the ${moveFunctionName} function`],
 };
 
+export const grepFunctionName = 'grep';
+export function grepFunction(fsModule: ConversationFsModule) {
+  return {
+    definition: {
+      name: grepFunctionName,
+      description:
+        "Run system grep recursively (-F literal) within the repository and return raw stdout/stderr/code. Excludes node_modules, dist, and .git. Use 'maxResults' to cap output.",
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: {
+            type: 'string',
+            description:
+              'Literal text to search for (grep -F). For parentheses or special characters, pass them as-is; no regex needed.',
+          },
+          dir: {
+            type: 'string',
+            description:
+              'Directory to search under. If relative, it is resolved against the repo root. Defaults to the repo root.',
+          },
+          maxResults: {
+            type: 'number',
+            description: 'Maximum number of matching lines to return (uses grep -m N).',
+          },
+        },
+        required: ['pattern'],
+      },
+    },
+    call: async (params: { pattern: string; dir?: string; maxResults?: number }) => {
+      const repo = fsModule.getRepoPath();
+      const cwd = params.dir ? toRepoAbs(fsModule, params.dir) : repo;
+      return await Fs.grep({ pattern: params.pattern, dir: cwd, maxResults: params.maxResults });
+    },
+    instructions: [
+      `Use ${grepFunctionName} to search for literal text across the repo.`,
+      `Prefer small 'maxResults' (e.g., 5-20) to avoid flooding the context.`,
+      `Parse the returned stdout yourself (format: "<path>:<line>:<text>") to pick files to read.`,
+    ],
+  };
+}
+
 export const fsFunctions: Function[] = [
   createFolderFunction,
   fileOrDirectoryExistsFunction,

package/src/fs/keyword_to_files_index/KeywordToFilesIndexModule.ts

@@ -7,7 +7,8 @@ import { searchFilesFunction, searchFilesFunctionName } from './KeywordToFilesIn
 
 export type KeywordToFilesIndexModuleParams = {
   dir: string;
-  keywordFilesIndex: { [keyword: string]: string[] /** file paths */ };
+  // Map from lowercase filename *stem* (no extension) → file paths
+  keywordFilesIndex: { [keyword: string]: string[] };
 };
 
 export class KeywordToFilesIndexModule implements ConversationModule {
@@ -22,15 +23,19 @@ export class KeywordToFilesIndexModule implements ConversationModule {
     return 'Keyword to files index';
   }
 
+  /**
+   * Case-insensitive file name search that ignores extension.
+   */
   searchFiles(params: { keyword: string }) {
-    this.logger.info({ message: `Searching for file, keyword: ${params.keyword}` });
-    const filePaths = this.params.keywordFilesIndex[params.keyword];
+    this.logger.debug({ message: `Searching for file, keyword: ${params.keyword}` });
+    const keywordLowerNoExtension = path.parse(params.keyword).name.toLowerCase();
+    const filePaths = this.params.keywordFilesIndex[keywordLowerNoExtension];
     return filePaths || [];
   }
 
   getSystemMessages(): string[] {
     return [
-      `If you're searching for something, use the ${searchFilesFunctionName} function to find a file matching the search string`,
+      `If you're searching for something, use the ${searchFilesFunctionName} function to find a file (by name) matching the search string`,
     ];
   }
 
@@ -76,14 +81,14 @@ export class KeywordToFilesIndexModuleFactory implements ConversationModuleFacto
 
     // Process each file path
     for (const filePath of filePaths) {
-      const fileName = path.parse(filePath).name; // Get file name without extension
+      const fileNameLower = path.parse(filePath).name.toLowerCase(); // Get file name without extension
 
-      if (!keywordFilesIndex[fileName]) {
-        keywordFilesIndex[fileName] = [];
+      if (!keywordFilesIndex[fileNameLower]) {
+        keywordFilesIndex[fileNameLower] = [];
       }
 
-      this.logger.debug({ message: `fileName: ${fileName}, filePath: ${filePath}` });
-      keywordFilesIndex[fileName].push(filePath);
+      this.logger.debug({ message: `fileName: ${fileNameLower}, filePath: ${filePath}` });
+      keywordFilesIndex[fileNameLower].push(filePath);
     }
 
     return keywordFilesIndex;