@gagik.co/snippet-agent 0.1.0 → 0.1.1

package/src/tools/mongosh-eval.ts

@@ -1,115 +0,0 @@
-import type { ShellContext } from '../shell-context';
-import type { Tool } from './types';
-
-export type CreateMongoshEvalToolOptions = {
-  shellContext: ShellContext;
-  debugLogging: boolean;
-};
-
-export async function createMongoshEvalTool(
-  options: CreateMongoshEvalToolOptions,
-): Promise<Tool> {
-  const { shellContext, debugLogging } = options;
-  const { defineTool } = await import('@earendil-works/pi-coding-agent');
-  const { Type } = await import('@sinclair/typebox');
-
-  const {
-    shellEvaluator,
-    originalEval,
-    formatResultValue,
-    instanceState,
-    capturedPrintOutput,
-  } = shellContext;
-
-  return defineTool({
-    name: 'mongosh_eval',
-    label: 'mongosh eval',
-    description:
-      'Execute a mongosh shell expression against the connected MongoDB instance. ' +
-      'Supports the full mongosh API: queries, aggregations, admin commands ' +
-      'The expression runs in the same context as the interactive mongosh REPL.' +
-      'Note: make sure to double-check with the user before running destructive or risky operations.',
-    parameters: Type.Object({
-      expression: Type.String({
-        description:
-          'The mongosh expression to evaluate. Never run `use` to switch databases and instead refer to the database name explicitly. Examples: "db.getMongo()", "db.users.find().limit(5)", "db.serverStatus()", "db.getSiblingDB(\'movies\')". The last line of the output will be the result of the tool call.',
-      }),
-    }),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    execute: async (_toolCallId: string, params: any) => {
-      const expr: string = params.expression;
-
-      // Clear captured output before execution
-      capturedPrintOutput.length = 0;
-
-      try {
-        let rawValue = await shellEvaluator.customEval(
-          originalEval,
-          expr,
-          instanceState.context,
-          'mongosh_eval',
-        );
-
-        // Auto-call functions that take no arguments (e.g., `history` -> `history()`)
-        // This provides shell-like behavior for zero-argument functions
-        if (typeof rawValue === 'function') {
-          try {
-            rawValue = await rawValue();
-          } catch {
-            // If calling fails, keep the original function reference
-          }
-        }
-
-        const formatted = await formatResultValue(rawValue);
-
-        // Build output: captured print output takes priority, then add formatted result if present
-        let output: string;
-        if (capturedPrintOutput.length > 0) {
-          // Has captured print output - use it as primary output
-          output = capturedPrintOutput.join('\n');
-          // Also append formatted result if it's meaningful (not empty/undefined)
-          if (formatted) {
-            output += '\n' + formatted;
-          }
-        } else if (formatted) {
-          // No captured output, but has formatted result
-          output = formatted;
-        } else {
-          // Nothing to show
-          output = '(no output)';
-        }
-
-        if (debugLogging) {
-          process.stderr.write(
-            `[mongosh_eval] Output: ${output.substring(0, 200)}\n`,
-          );
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: output }],
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          details: { expression: expr } as any,
-        };
-      } catch (err) {
-        const errorMsg =
-          err instanceof Error ? `${err.name}: ${err.message}` : String(err);
-
-        if (debugLogging) {
-          process.stderr.write(`[mongosh_eval] Error: ${errorMsg}\n`);
-        }
-
-        const parts: string[] = [];
-        if (capturedPrintOutput.length > 0) {
-          parts.push(capturedPrintOutput.join('\n'));
-        }
-        parts.push(`Error: ${errorMsg}`);
-
-        return {
-          content: [{ type: 'text' as const, text: parts.join('\n') }],
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          details: { error: errorMsg, expression: expr } as any,
-        };
-      }
-    },
-  });
-}

package/src/tools/search-docs.ts

@@ -1,115 +0,0 @@
-import type { Tool, SearchDocsResult } from './types';
-
-export async function createSearchDocsTool(): Promise<Tool> {
-  const { defineTool } = await import('@earendil-works/pi-coding-agent');
-  const { Type } = await import('@sinclair/typebox');
-
-  return defineTool({
-    name: 'search_docs',
-    label: 'search docs',
-    description:
-      'Search for information in the MongoDB documentation and knowledge base. ' +
-      'This includes official documentation, curated expert guidance, and other resources provided by MongoDB.',
-    parameters: Type.Object({
-      query: Type.String({
-        description:
-          'A natural language query to search for in the MongoDB knowledge base. ' +
-          'This should be a single question or a topic that is relevant to the MongoDB use case.',
-      }),
-      limit: Type.Optional(
-        Type.Number({
-          description: 'The maximum number of results to return (1-100)',
-          default: 5,
-          minimum: 1,
-          maximum: 100,
-        }),
-      ),
-    }),
-    execute: async (_toolCallId: string, params: { query: string; limit?: number }) => {
-      const { query, limit = 5 } = params;
-
-      try {
-        const response = await fetch('https://knowledge.mongodb.com/api/v1/content/search', {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'X-Request-Origin': 'mongodb-mongosh',
-            'User-Agent': 'mongodb-mongosh',
-          },
-          body: JSON.stringify({
-            query,
-            limit,
-          }),
-        });
-
-        if (!response.ok) {
-          const errorText = await response.text();
-          return {
-            content: [
-              {
-                type: 'text' as const,
-                text: `Failed to search docs: ${response.status} ${response.statusText}${errorText ? `\n${errorText}` : ''}`,
-              },
-            ],
-            isError: true,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            details: { query, limit, error: errorText } as any,
-          };
-        }
-
-        const data = (await response.json()) as SearchDocsResult;
-
-        if (!data.results || data.results.length === 0) {
-          return {
-            content: [
-              {
-                type: 'text' as const,
-                text: 'No results found for this query.',
-              },
-            ],
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            details: { query, limit, resultCount: 0 } as any,
-          };
-        }
-
-        const formattedResults = data.results
-          .map((result, index) => {
-            const lines: string[] = [];
-            lines.push(`${index + 1}. ${result.title}`);
-            lines.push(`   URL: ${result.url}`);
-            if (result.metadata?.tags?.length) {
-              lines.push(`   Tags: ${result.metadata.tags.join(', ')}`);
-            }
-            lines.push('');
-            lines.push(result.text.split('\n').map((line) => `   ${line}`).join('\n'));
-            return lines.join('\n');
-          })
-          .join('\n\n');
-
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Found ${data.results.length} result${data.results.length === 1 ? '' : 's'} in MongoDB documentation:\n\n${formattedResults}`,
-            },
-          ],
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          details: { query, limit, resultCount: data.results.length } as any,
-        };
-      } catch (err) {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Error searching docs: ${errorMsg}`,
-            },
-          ],
-          isError: true,
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          details: { query, limit, error: errorMsg } as any,
-        };
-      }
-    },
-  });
-}

package/src/tools/types.ts

@@ -1,15 +0,0 @@
-export type Tool = ReturnType<
-  typeof import('@earendil-works/pi-coding-agent').defineTool
->;
-
-export type SearchDocsResult = {
-  results: Array<{
-    url: string;
-    title: string;
-    text: string;
-    metadata: {
-      tags: string[];
-      [key: string]: unknown;
-    };
-  }>;
-};

package/src/types.ts

@@ -1,23 +0,0 @@
-export type ShellInstanceState = {
-  evaluationListener: {
-    setConfig: (key: string, value: unknown) => void;
-    getConfig: <T>(key: string) => Promise<T>;
-  };
-  shellApi: Record<string, unknown>;
-  context: Record<string, unknown>;
-};
-
-export type CliContext = {
-  db: {
-    _mongo: {
-      _instanceState: ShellInstanceState;
-    };
-  };
-};
-
-export type Skill = {
-  name: string;
-  description: string;
-  content: string;
-  source: string;
-};

package/tsconfig-lint.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["src/**/*.ts", "src/**/*.test.ts", "src/index.js"]
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "declaration": true,
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "types": ["node"],
-    "allowJs": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["src/**/*.test.ts"]
-}