@gotza02/sequential-thinking 10000.1.7 → 10000.1.8

package/dist/parsers/GoParser.d.ts

@@ -0,0 +1,6 @@
+import { ParseResult } from './TypeScriptParser.js';
+export declare class GoParser {
+    parse(filePath: string): Promise<ParseResult>;
+}
+export declare const goParser: GoParser;
+export default goParser;

package/dist/parsers/GoParser.js

@@ -0,0 +1,36 @@
+import * as fs from 'fs/promises';
+export class GoParser {
+    async parse(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            // Single line: import "fmt"
+            const singleImportMatches = content.matchAll(/import\s+"([^"]+)"/g);
+            for (const match of singleImportMatches)
+                imports.push(match[1]);
+            // Block: import ( "fmt"; "os" )
+            const blockImportMatches = content.matchAll(/import\s+\(([\s\S]*?)\)/g);
+            for (const match of blockImportMatches) {
+                const block = match[1];
+                const innerMatches = block.matchAll(/"([^"]+)"/g);
+                for (const im of innerMatches)
+                    imports.push(im[1]);
+            }
+            // Go symbols
+            const funcMatches = content.matchAll(/^func\s+(?:\([^\)]*\)\s+)?([a-zA-Z_][a-zA-Z0-9_]*)/gm);
+            for (const match of funcMatches)
+                symbols.push(`func:${match[1]}`);
+            const typeMatches = content.matchAll(/^type\s+([A-Z][a-zA-Z0-9_]*)\s+(?:struct|interface)/gm);
+            for (const match of typeMatches)
+                symbols.push(`type:${match[1]}`);
+            return { imports, symbols };
+        }
+        catch (error) {
+            console.error(`Error parsing Go file ${filePath}:`, error);
+            return { imports: [], symbols: [] };
+        }
+    }
+}
+export const goParser = new GoParser();
+export default goParser;

package/dist/parsers/JavaParser.d.ts

@@ -0,0 +1,6 @@
+import { ParseResult } from './TypeScriptParser.js';
+export declare class JavaParser {
+    parse(filePath: string): Promise<ParseResult>;
+}
+export declare const javaParser: JavaParser;
+export default javaParser;

package/dist/parsers/JavaParser.js

@@ -0,0 +1,32 @@
+import * as fs from 'fs/promises';
+export class JavaParser {
+    async parse(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            // import package.Class;
+            const importMatches = content.matchAll(/^import\s+([^;]+);/gm);
+            for (const match of importMatches)
+                imports.push(match[1].trim());
+            // package declaration
+            const pkgMatch = content.match(/^package\s+([^;]+);/m);
+            if (pkgMatch)
+                symbols.push(`package:${pkgMatch[1]}`);
+            // public class/interface/enum
+            const classMatches = content.matchAll(/^public\s+(?:static\s+)?(?:final\s+)?(?:abstract\s+)?(class|interface|enum|record)\s+([A-Z][A-Za-z0-9_]*)/gm);
+            for (const match of classMatches)
+                symbols.push(`${match[1]}:${match[2]}`);
+            // public methods
+            const methodMatches = content.matchAll(/^public\s+(?:static\s+)?(?:synchronized\s+)?(?:final\s+)?(?:\w+(?:<[^>]+>)?)\s+([a-z][a-zA-Z0-9_]*)\s*\(/gm);
+            for (const match of methodMatches)
+                symbols.push(`method:${match[1]}`);
+            return { imports, symbols };
+        }
+        catch (error) {
+            return { imports: [], symbols: [] };
+        }
+    }
+}
+export const javaParser = new JavaParser();
+export default javaParser;

package/dist/parsers/PythonParser.d.ts

@@ -0,0 +1,6 @@
+import { ParseResult } from './TypeScriptParser.js';
+export declare class PythonParser {
+    parse(filePath: string): Promise<ParseResult>;
+}
+export declare const pythonParser: PythonParser;
+export default pythonParser;

package/dist/parsers/PythonParser.js

@@ -0,0 +1,50 @@
+import * as fs from 'fs/promises';
+export class PythonParser {
+    async parse(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            // Python imports with better regex
+            const simpleImportMatches = content.matchAll(/^\s*import\s+([^#\n]+)/gm);
+            for (const match of simpleImportMatches) {
+                match[1].split(',').forEach(s => {
+                    const clean = s.trim().split(/\s+/)[0];
+                    if (clean && !clean.startsWith('.'))
+                        imports.push(clean);
+                });
+            }
+            // from . import x, from ..package import y
+            const fromImportMatches = content.matchAll(/^\s*from\s+([.\w]+)\s+import/gm);
+            for (const match of fromImportMatches) {
+                let imp = match[1];
+                if (imp.startsWith('.')) {
+                    const matchDots = imp.match(/^(\.+)(.*)/);
+                    if (matchDots) {
+                        const dots = matchDots[1].length;
+                        const name = matchDots[2];
+                        if (dots === 1)
+                            imp = `./${name}`;
+                        else
+                            imp = `${'../'.repeat(dots - 1)}${name}`;
+                    }
+                }
+                imports.push(imp);
+            }
+            // Python symbols (skip underscored/private)
+            const funcMatches = content.matchAll(/^def\s+([a-zA-Z_][a-zA-Z0-9_]*)/gm);
+            for (const match of funcMatches)
+                symbols.push(`def:${match[1]}`);
+            const classMatches = content.matchAll(/^class\s+([a-zA-Z_][a-zA-Z0-9_]*)/gm);
+            for (const match of classMatches)
+                symbols.push(`class:${match[1]}`);
+            return { imports, symbols };
+        }
+        catch (error) {
+            console.error(`Error parsing Python file ${filePath}:`, error);
+            return { imports: [], symbols: [] };
+        }
+    }
+}
+export const pythonParser = new PythonParser();
+export default pythonParser;

package/dist/parsers/RustParser.d.ts

@@ -0,0 +1,6 @@
+import { ParseResult } from './TypeScriptParser.js';
+export declare class RustParser {
+    parse(filePath: string): Promise<ParseResult>;
+}
+export declare const rustParser: RustParser;
+export default rustParser;

package/dist/parsers/RustParser.js

@@ -0,0 +1,33 @@
+import * as fs from 'fs/promises';
+export class RustParser {
+    async parse(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            // use crate::module::item;
+            const useMatches = content.matchAll(/^use\s+([^;]+);/gm);
+            for (const match of useMatches) {
+                imports.push(match[1].trim());
+            }
+            // mod statement
+            const modMatches = content.matchAll(/^mod\s+([a-z][a-z0-9_]*)/gm);
+            for (const match of modMatches)
+                symbols.push(`mod:${match[1]}`);
+            // pub fn / pub struct / pub enum / pub trait
+            const pubMatches = content.matchAll(/^pub\s+(fn|struct|enum|trait)\s+([A-Za-z][A-Za-z0-9_]*)/gm);
+            for (const match of pubMatches)
+                symbols.push(`${match[1]}:${match[2]}`);
+            // impl blocks
+            const implMatches = content.matchAll(/^impl\s+([A-Z][A-Za-z0-9_]*)/gm);
+            for (const match of implMatches)
+                symbols.push(`impl:${match[1]}`);
+            return { imports, symbols };
+        }
+        catch (error) {
+            return { imports: [], symbols: [] };
+        }
+    }
+}
+export const rustParser = new RustParser();
+export default rustParser;

package/dist/parsers/TypeScriptParser.d.ts

@@ -0,0 +1,9 @@
+export interface ParseResult {
+    imports: string[];
+    symbols: string[];
+}
+export declare class TypeScriptParser {
+    parse(filePath: string): Promise<ParseResult>;
+}
+export declare const typeScriptParser: TypeScriptParser;
+export default typeScriptParser;

package/dist/parsers/TypeScriptParser.js

@@ -0,0 +1,85 @@
+import * as fs from 'fs/promises';
+import ts from 'typescript';
+export class TypeScriptParser {
+    async parse(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+            const imports = [];
+            const symbols = [];
+            const visit = (node) => {
+                // --- Symbols (Exports) ---
+                if (ts.isFunctionDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`function:${node.name.text}`);
+                }
+                else if (ts.isClassDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`class:${node.name.text}`);
+                }
+                else if (ts.isInterfaceDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`interface:${node.name.text}`);
+                }
+                else if (ts.isTypeAliasDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`type:${node.name.text}`);
+                }
+                else if (ts.isEnumDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`enum:${node.name.text}`);
+                }
+                else if (ts.isVariableStatement(node)) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported) {
+                        node.declarationList.declarations.forEach(d => {
+                            if (ts.isIdentifier(d.name))
+                                symbols.push(`var:${d.name.text}`);
+                        });
+                    }
+                }
+                // --- Imports ---
+                if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+                    if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+                        imports.push(node.moduleSpecifier.text);
+                    }
+                }
+                else if (ts.isCallExpression(node)) {
+                    if (node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments.length > 0) {
+                        const arg = node.arguments[0];
+                        if (ts.isStringLiteral(arg)) {
+                            imports.push(arg.text);
+                        }
+                    }
+                    else if (ts.isIdentifier(node.expression) && node.expression.text === 'require' && node.arguments.length > 0) {
+                        const arg = node.arguments[0];
+                        if (ts.isStringLiteral(arg)) {
+                            imports.push(arg.text);
+                        }
+                    }
+                }
+                else if (ts.isImportEqualsDeclaration(node)) {
+                    if (ts.isExternalModuleReference(node.moduleReference)) {
+                        if (ts.isStringLiteral(node.moduleReference.expression)) {
+                            imports.push(node.moduleReference.expression.text);
+                        }
+                    }
+                }
+                ts.forEachChild(node, visit);
+            };
+            visit(sourceFile);
+            return { imports, symbols };
+        }
+        catch (error) {
+            console.error(`Error parsing TypeScript file ${filePath}:`, error);
+            return { imports: [], symbols: [] };
+        }
+    }
+}
+export const typeScriptParser = new TypeScriptParser();
+export default typeScriptParser;

package/dist/parsers/index.d.ts

@@ -0,0 +1,7 @@
+export { TypeScriptParser, typeScriptParser } from './TypeScriptParser.js';
+export { PythonParser, pythonParser } from './PythonParser.js';
+export { GoParser, goParser } from './GoParser.js';
+export { RustParser, rustParser } from './RustParser.js';
+export { JavaParser, javaParser } from './JavaParser.js';
+export { GenericParser, genericParser } from './GenericParser.js';
+export type { ParseResult } from './TypeScriptParser.js';

package/dist/parsers/index.js

@@ -0,0 +1,6 @@
+export { TypeScriptParser, typeScriptParser } from './TypeScriptParser.js';
+export { PythonParser, pythonParser } from './PythonParser.js';
+export { GoParser, goParser } from './GoParser.js';
+export { RustParser, rustParser } from './RustParser.js';
+export { JavaParser, javaParser } from './JavaParser.js';
+export { GenericParser, genericParser } from './GenericParser.js';

package/dist/tools/sports/tools/match.js

@@ -337,12 +337,12 @@ async function scrapeContentWithErrorHandling(url, type) {
             return scrapedContent.data || '';
         }
         else {
-            return `(${type} scrape failed: ${scrapedContent.error})`;
+            return `${type.charAt(0).toUpperCase() + type.slice(1)} scrape failed: ${scrapedContent.error}`;
         }
     }
     catch (scrapeError) {
         const errorMsg = scrapeError instanceof Error ? scrapeError.message : String(scrapeError);
-        return `(${type} scrape failed: ${errorMsg})`;
+        return `${type.charAt(0).toUpperCase() + type.slice(1)} scrape failed: ${errorMsg}`;
     }
 }
 /**

package/dist/tools/web.js

@@ -96,13 +96,16 @@ export function registerWebTools(server) {
     }, async ({ query, provider }) => {
         const errors = [];
         // 1. Identify available providers
-        const availableProviders = ['duckduckgo']; // Always available (HTML scraping)
+        // Priority: API providers first, then HTML scraping fallback
+        const availableProviders = [];
         if (process.env.BRAVE_API_KEY)
             availableProviders.push('brave');
         if (process.env.EXA_API_KEY)
             availableProviders.push('exa');
         if (process.env.GOOGLE_SEARCH_API_KEY && process.env.GOOGLE_SEARCH_CX)
             availableProviders.push('google');
+        // Always add duckduckgo as last resort (HTML scraping)
+        availableProviders.push('duckduckgo');
         if (availableProviders.length === 0) {
             return {
                 content: [{ type: "text", text: "Error: No search provider configured. Please set BRAVE_API_KEY, EXA_API_KEY, or GOOGLE_SEARCH_API_KEY." }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "10000.1.7",
+  "version": "10000.1.8",
   "publishConfig": {
     "access": "public"
   },