centient 2.20.0

package/dist/tools/session/checkCodeFeasibility.js

@@ -0,0 +1,766 @@
+import { estimateTokensFromJSON } from "../../utils/tokenEstimator.js";
+export const checkCodeFeasibilityTool = {
+    name: "check_code_feasibility",
+    description: "Check code for feasibility issues: syntax errors, non-existent imports, invalid API calls, deprecated patterns, and security concerns. Part of hallucination detection for code suggestions.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            code: {
+                type: "string",
+                description: "The code to check for feasibility",
+            },
+            language: {
+                type: "string",
+                enum: [
+                    "typescript",
+                    "javascript",
+                    "python",
+                    "go",
+                    "rust",
+                    "sql",
+                    "bash",
+                ],
+                description: "Programming language of the code",
+            },
+            context: {
+                type: "string",
+                description: "Optional context about what the code is supposed to do",
+            },
+            strictMode: {
+                type: "boolean",
+                description: "Enable strict checking (more warnings, lower confidence threshold)",
+            },
+        },
+        required: ["code", "language"],
+    },
+};
+export async function checkCodeFeasibilityHandler(args) {
+    const startTime = Date.now();
+    try {
+        const input = args;
+        if (!input.code) {
+            throw new Error("code is required");
+        }
+        if (!input.language) {
+            throw new Error("language is required");
+        }
+        const result = await checkFeasibility(input);
+        const duration = Date.now() - startTime;
+        const tokensUsed = estimateTokensFromJSON({ input, result });
+        const output = {
+            success: true,
+            data: result,
+            metadata: {
+                tokensUsed,
+                duration,
+                language: input.language,
+                linesOfCode: input.code.split("\n").length,
+            },
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(output, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const input = args;
+        const errorResult = {
+            success: false,
+            error: {
+                code: "CODE_FEASIBILITY_ERROR",
+                message: errorMessage,
+            },
+            metadata: {
+                tokensUsed: 0,
+                duration,
+                language: input?.language || "unknown",
+                linesOfCode: input?.code?.split("\n").length || 0,
+            },
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(errorResult, null, 2),
+                },
+            ],
+        };
+    }
+}
+async function checkFeasibility(input) {
+    const { code, language, strictMode = false } = input;
+    const issues = [];
+    const checksPerformed = [];
+    const syntaxResult = checkSyntax(code, language);
+    issues.push(...syntaxResult.issues);
+    checksPerformed.push("syntax");
+    const importResult = checkImports(code, language);
+    issues.push(...importResult.issues);
+    checksPerformed.push("imports");
+    const apiResult = checkApiPatterns(code, language);
+    issues.push(...apiResult.issues);
+    checksPerformed.push("api_patterns");
+    const logicResult = checkLogicPatterns(code, language);
+    issues.push(...logicResult.issues);
+    checksPerformed.push("logic_patterns");
+    const securityResult = checkSecurityPatterns(code, language);
+    issues.push(...securityResult.issues);
+    checksPerformed.push("security_patterns");
+    const errorCount = issues.filter((i) => i.severity === "error").length;
+    const warningCount = issues.filter((i) => i.severity === "warning").length;
+    const syntaxValid = syntaxResult.issues.filter((i) => i.severity === "error").length === 0;
+    const importsValid = importResult.issues.filter((i) => i.severity === "error").length === 0;
+    const apisValid = apiResult.issues.filter((i) => i.severity === "error").length === 0;
+    let confidence = 1.0;
+    confidence -= errorCount * 0.2;
+    confidence -= warningCount * 0.05;
+    if (strictMode) {
+        confidence -= warningCount * 0.05;
+    }
+    confidence = Math.max(0, Math.min(1, confidence));
+    const feasible = errorCount === 0 && (strictMode ? warningCount < 3 : true);
+    const badge = determineBadge(confidence, errorCount, warningCount);
+    return {
+        feasible,
+        syntaxValid,
+        importsValid,
+        apisValid,
+        issues,
+        confidence,
+        checksPerformed,
+        badge,
+    };
+}
+function determineBadge(confidence, errors, warnings) {
+    if (errors > 0) {
+        return "🚫 ERRORS FOUND";
+    }
+    if (confidence >= 0.9) {
+        return "✅ FEASIBLE";
+    }
+    if (confidence >= 0.7) {
+        return "✓ LIKELY FEASIBLE";
+    }
+    if (warnings > 0) {
+        return "⚠️ WARNINGS";
+    }
+    return "🔍 NEEDS REVIEW";
+}
+function checkSyntax(code, language) {
+    const issues = [];
+    const lines = code.split("\n");
+    switch (language) {
+        case "typescript":
+        case "javascript":
+            issues.push(...checkJsSyntax(code, lines));
+            break;
+        case "python":
+            issues.push(...checkPythonSyntax(code, lines));
+            break;
+        case "go":
+            issues.push(...checkGoSyntax(code, lines));
+            break;
+        case "rust":
+            issues.push(...checkRustSyntax(code, lines));
+            break;
+        case "sql":
+            issues.push(...checkSqlSyntax(code, lines));
+            break;
+        case "bash":
+            issues.push(...checkBashSyntax(code, lines));
+            break;
+    }
+    return { issues };
+}
+function checkJsSyntax(code, lines) {
+    const issues = [];
+    const openBraces = (code.match(/\{/g) || []).length;
+    const closeBraces = (code.match(/\}/g) || []).length;
+    if (openBraces !== closeBraces) {
+        issues.push({
+            type: "syntax",
+            description: `Unbalanced braces: ${openBraces} opening, ${closeBraces} closing`,
+            severity: "error",
+            suggestion: "Check for missing or extra braces",
+        });
+    }
+    const openParens = (code.match(/\(/g) || []).length;
+    const closeParens = (code.match(/\)/g) || []).length;
+    if (openParens !== closeParens) {
+        issues.push({
+            type: "syntax",
+            description: `Unbalanced parentheses: ${openParens} opening, ${closeParens} closing`,
+            severity: "error",
+            suggestion: "Check for missing or extra parentheses",
+        });
+    }
+    lines.forEach((line, idx) => {
+        if (/\bfunciton\b/i.test(line)) {
+            issues.push({
+                type: "syntax",
+                description: 'Typo: "funciton" should be "function"',
+                severity: "error",
+                line: idx + 1,
+                suggestion: 'Replace with "function"',
+            });
+        }
+        if (/^\s*(const|let)\s+\w+\s*;/.test(line) && /const/.test(line)) {
+            issues.push({
+                type: "syntax",
+                description: "const declaration without initialization",
+                severity: "error",
+                line: idx + 1,
+                suggestion: "const requires an initial value",
+            });
+        }
+        if (/=>\s*\{[^}]*$/.test(line) &&
+            !lines.slice(idx + 1).some((l) => /\}/.test(l))) {
+            issues.push({
+                type: "syntax",
+                description: "Arrow function body may not be closed",
+                severity: "warning",
+                line: idx + 1,
+            });
+        }
+    });
+    return issues;
+}
+function checkPythonSyntax(_code, lines) {
+    const issues = [];
+    lines.forEach((line, idx) => {
+        const leadingSpaces = line.match(/^(\s*)/)?.[1] || "";
+        if (leadingSpaces.includes("\t") && leadingSpaces.includes(" ")) {
+            issues.push({
+                type: "syntax",
+                description: "Mixed tabs and spaces in indentation",
+                severity: "error",
+                line: idx + 1,
+                suggestion: "Use consistent indentation (spaces recommended)",
+            });
+        }
+        if (/\bpritn\b/.test(line)) {
+            issues.push({
+                type: "syntax",
+                description: 'Typo: "pritn" should be "print"',
+                severity: "error",
+                line: idx + 1,
+            });
+        }
+        if (/^\s*(def|if|elif|else|for|while|class|try|except|finally|with)\s+[^:]+$/.test(line) &&
+            !/:\s*$/.test(line) &&
+            !/^\s*(else|try|finally)\s*$/.test(line)) {
+            issues.push({
+                type: "syntax",
+                description: "Missing colon after statement",
+                severity: "error",
+                line: idx + 1,
+                suggestion: "Add colon at end of line",
+            });
+        }
+    });
+    return issues;
+}
+function checkGoSyntax(code, lines) {
+    const issues = [];
+    const openBraces = (code.match(/\{/g) || []).length;
+    const closeBraces = (code.match(/\}/g) || []).length;
+    if (openBraces !== closeBraces) {
+        issues.push({
+            type: "syntax",
+            description: `Unbalanced braces: ${openBraces} opening, ${closeBraces} closing`,
+            severity: "error",
+        });
+    }
+    lines.forEach((line, idx) => {
+        if (/^\s*(func|if|for|switch|select)\s+[^{]*$/.test(line) &&
+            lines[idx + 1]?.trim().startsWith("{")) {
+            issues.push({
+                type: "syntax",
+                description: "Go requires opening brace on same line as statement",
+                severity: "error",
+                line: idx + 1,
+                suggestion: "Move opening brace to end of this line",
+            });
+        }
+    });
+    return issues;
+}
+function checkRustSyntax(code, lines) {
+    const issues = [];
+    const openBraces = (code.match(/\{/g) || []).length;
+    const closeBraces = (code.match(/\}/g) || []).length;
+    if (openBraces !== closeBraces) {
+        issues.push({
+            type: "syntax",
+            description: `Unbalanced braces: ${openBraces} opening, ${closeBraces} closing`,
+            severity: "error",
+        });
+    }
+    lines.forEach((line, idx) => {
+        if (/^\s*(let|const|return|println!|print!|eprintln!)\s+[^;{]+[^;{}\s]$/.test(line)) {
+            issues.push({
+                type: "syntax",
+                description: "Possible missing semicolon",
+                severity: "warning",
+                line: idx + 1,
+            });
+        }
+    });
+    return issues;
+}
+function checkSqlSyntax(code, _lines) {
+    void _lines;
+    const issues = [];
+    const upperCode = code.toUpperCase();
+    if (/\bSELECT\b/.test(upperCode) &&
+        !/\bFROM\b/.test(upperCode) &&
+        !/\bSELECT\s+\d+/.test(upperCode)) {
+        issues.push({
+            type: "syntax",
+            description: "SELECT statement without FROM clause",
+            severity: "warning",
+            suggestion: "Add FROM clause or use SELECT literal",
+        });
+    }
+    if (/\bUPDATE\b/.test(upperCode) && !/\bWHERE\b/.test(upperCode)) {
+        issues.push({
+            type: "security",
+            description: "UPDATE statement without WHERE clause - will affect all rows",
+            severity: "error",
+            suggestion: "Add WHERE clause to limit affected rows",
+        });
+    }
+    if (/\bDELETE\b/.test(upperCode) && !/\bWHERE\b/.test(upperCode)) {
+        issues.push({
+            type: "security",
+            description: "DELETE statement without WHERE clause - will delete all rows",
+            severity: "error",
+            suggestion: "Add WHERE clause to limit affected rows",
+        });
+    }
+    return issues;
+}
+function checkBashSyntax(code, lines) {
+    const issues = [];
+    lines.forEach((line, idx) => {
+        if (/\brm\s+-rf?\s+\$\w+[^"]/.test(line) ||
+            /\brm\s+-rf?\s+\$\{[^}]+\}[^"]/.test(line)) {
+            issues.push({
+                type: "security",
+                description: "Unquoted variable in rm command - dangerous if empty or contains spaces",
+                severity: "error",
+                line: idx + 1,
+                suggestion: 'Quote the variable: rm -rf "$variable"',
+            });
+        }
+        if (/\[\s+[^]]*\s+\]/.test(line) && !/\[\[/.test(line)) {
+            issues.push({
+                type: "logic",
+                description: "Using [ ] instead of [[ ]] - consider using [[ ]] for better string handling",
+                severity: "info",
+                line: idx + 1,
+            });
+        }
+    });
+    const ifCount = (code.match(/\bif\b/g) || []).length;
+    const fiCount = (code.match(/\bfi\b/g) || []).length;
+    if (ifCount !== fiCount) {
+        issues.push({
+            type: "syntax",
+            description: `Unbalanced if/fi: ${ifCount} if statements, ${fiCount} fi`,
+            severity: "error",
+        });
+    }
+    return issues;
+}
+const KNOWN_PACKAGES = {
+    npm: new Set([
+        "react",
+        "vue",
+        "angular",
+        "express",
+        "next",
+        "axios",
+        "lodash",
+        "moment",
+        "dayjs",
+        "date-fns",
+        "uuid",
+        "zod",
+        "joi",
+        "yup",
+        "typescript",
+        "webpack",
+        "vite",
+        "esbuild",
+        "rollup",
+        "jest",
+        "vitest",
+        "mocha",
+        "chai",
+        "prisma",
+        "drizzle-orm",
+        "typeorm",
+        "sequelize",
+        "mongoose",
+        "graphql",
+        "apollo",
+        "@tanstack/react-query",
+        "swr",
+        "redux",
+        "zustand",
+        "jotai",
+        "recoil",
+        "@modelcontextprotocol/sdk",
+        "@qdrant/js-client-rest",
+        "openai",
+        "@google/genai",
+    ]),
+    python: new Set([
+        "numpy",
+        "pandas",
+        "scipy",
+        "matplotlib",
+        "seaborn",
+        "sklearn",
+        "tensorflow",
+        "torch",
+        "keras",
+        "flask",
+        "django",
+        "fastapi",
+        "requests",
+        "httpx",
+        "aiohttp",
+        "sqlalchemy",
+        "alembic",
+        "pydantic",
+        "pytest",
+        "unittest",
+        "asyncio",
+        "typing",
+        "json",
+        "os",
+        "sys",
+        "pathlib",
+        "re",
+        "datetime",
+        "collections",
+        "itertools",
+    ]),
+    go: new Set([
+        "fmt",
+        "os",
+        "io",
+        "net",
+        "http",
+        "encoding/json",
+        "encoding/xml",
+        "database/sql",
+        "context",
+        "sync",
+        "time",
+        "strings",
+        "strconv",
+        "regexp",
+        "errors",
+        "log",
+    ]),
+};
+function checkImports(code, language) {
+    const issues = [];
+    switch (language) {
+        case "typescript":
+        case "javascript": {
+            const importMatches = code.matchAll(/import\s+(?:(?:\{[^}]+\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g);
+            for (const match of importMatches) {
+                const pkg = match[1];
+                if (!pkg)
+                    continue;
+                if (pkg.startsWith(".") || pkg.startsWith("/"))
+                    continue;
+                const basePkg = pkg.split("/")[0];
+                if (!KNOWN_PACKAGES.npm.has(basePkg) &&
+                    !basePkg.startsWith("@types/")) {
+                    issues.push({
+                        type: "import",
+                        description: `Unknown package: "${basePkg}" - verify it exists in npm`,
+                        severity: "warning",
+                        suggestion: `Check npm for package existence: npm view ${basePkg}`,
+                    });
+                }
+            }
+            if (/from\s+['"]raect['"]/.test(code)) {
+                issues.push({
+                    type: "import",
+                    description: 'Typo: "raect" should be "react"',
+                    severity: "error",
+                });
+            }
+            break;
+        }
+        case "python": {
+            const importMatches = code.matchAll(/(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
+            for (const match of importMatches) {
+                const pkg = (match[1] || match[2])?.split(".")[0];
+                if (!pkg)
+                    continue;
+                if (!KNOWN_PACKAGES.python.has(pkg) && !pkg.startsWith("_")) {
+                    issues.push({
+                        type: "import",
+                        description: `Unknown package: "${pkg}" - verify it exists in PyPI`,
+                        severity: "warning",
+                        suggestion: `Check PyPI for package existence: pip show ${pkg}`,
+                    });
+                }
+            }
+            break;
+        }
+        case "go": {
+            const importMatches = code.matchAll(/import\s+(?:\(\s*([\s\S]*?)\s*\)|"([^"]+)")/g);
+            for (const match of importMatches) {
+                const imports = match[1] || match[2];
+                if (!imports)
+                    continue;
+                const pkgs = imports
+                    .split("\n")
+                    .map((l) => l.trim().replace(/"/g, ""))
+                    .filter(Boolean);
+                for (const pkg of pkgs) {
+                    if (!pkg || pkg.startsWith("//"))
+                        continue;
+                    const basePkg = pkg.split("/")[0];
+                    if (!KNOWN_PACKAGES.go.has(basePkg) && !pkg.includes(".")) {
+                        issues.push({
+                            type: "import",
+                            description: `Unknown standard library package: "${basePkg}"`,
+                            severity: "warning",
+                        });
+                    }
+                }
+            }
+            break;
+        }
+    }
+    return { issues };
+}
+const API_PATTERNS = {
+    typescript: [
+        {
+            pattern: /fetch\([^)]+\)\s*(?!\.then|await)/,
+            issue: "fetch() returns a Promise - should be awaited or .then() chained",
+            severity: "warning",
+            suggestion: "Add await or .then() to handle the Promise",
+        },
+        {
+            pattern: /JSON\.parse\([^)]*\)\s*(?!\.catch|try)/,
+            issue: "JSON.parse() can throw - consider wrapping in try/catch",
+            severity: "info",
+        },
+        {
+            pattern: /\.(map|filter|reduce)\([^)]*\)\s*\.length/,
+            issue: "Using .length after map/filter - consider using appropriate method",
+            severity: "info",
+        },
+        {
+            pattern: /new\s+Promise\([^)]*resolve[^)]*reject[^)]*\)\s*{\s*return/,
+            issue: "Returning inside Promise executor - use resolve() instead",
+            severity: "warning",
+        },
+    ],
+    javascript: [],
+    python: [
+        {
+            pattern: /open\([^)]+\)(?!\s*as\s)/,
+            issue: 'File open without context manager - use "with open() as f:"',
+            severity: "warning",
+            suggestion: "Use context manager for automatic file closing",
+        },
+        {
+            pattern: /except:\s*$/m,
+            issue: "Bare except clause - catches all exceptions including KeyboardInterrupt",
+            severity: "warning",
+            suggestion: 'Use "except Exception:" or specific exception types',
+        },
+        {
+            pattern: /==\s*None/,
+            issue: 'Use "is None" instead of "== None"',
+            severity: "info",
+        },
+    ],
+    sql: [
+        {
+            pattern: /SELECT\s+\*/i,
+            issue: "SELECT * is inefficient - specify needed columns",
+            severity: "info",
+        },
+        {
+            pattern: /'\s*\+\s*\w+\s*\+\s*'/,
+            issue: "String concatenation in SQL - possible SQL injection",
+            severity: "error",
+            suggestion: "Use parameterized queries instead",
+        },
+    ],
+};
+function checkApiPatterns(code, language) {
+    const issues = [];
+    let patterns = API_PATTERNS[language] || [];
+    if (language === "javascript") {
+        patterns = [...(API_PATTERNS.typescript || []), ...patterns];
+    }
+    for (const { pattern, issue, severity, suggestion } of patterns) {
+        if (pattern.test(code)) {
+            issues.push({
+                type: "api",
+                description: issue,
+                severity,
+                suggestion,
+            });
+        }
+    }
+    return { issues };
+}
+function checkLogicPatterns(code, language) {
+    const issues = [];
+    const lines = code.split("\n");
+    lines.forEach((line, idx) => {
+        if (/catch\s*\([^)]*\)\s*\{\s*\}/.test(line)) {
+            issues.push({
+                type: "logic",
+                description: "Empty catch block - exceptions are silently ignored",
+                severity: "warning",
+                line: idx + 1,
+                suggestion: "Log the error or handle it appropriately",
+            });
+        }
+        if (/console\.(log|debug|info)\(/.test(line) &&
+            !line.includes("// debug")) {
+            issues.push({
+                type: "logic",
+                description: "console.log statement - remove before production",
+                severity: "info",
+                line: idx + 1,
+            });
+        }
+        if (/\/\/\s*(TODO|FIXME|XXX|HACK)/i.test(line)) {
+            issues.push({
+                type: "logic",
+                description: "TODO/FIXME comment found - incomplete implementation",
+                severity: "info",
+                line: idx + 1,
+            });
+        }
+    });
+    switch (language) {
+        case "typescript":
+        case "javascript":
+            if (/[^!=]==[^=]/.test(code) && !/===/.test(code.replace(/==/g, ""))) {
+                issues.push({
+                    type: "logic",
+                    description: "Using == instead of === - may cause type coercion issues",
+                    severity: "warning",
+                    suggestion: "Use === for strict equality comparison",
+                });
+            }
+            if (/async\s+(?:function|\([^)]*\)\s*=>)/.test(code) &&
+                !/await\s/.test(code)) {
+                issues.push({
+                    type: "logic",
+                    description: "async function without await - may be unnecessary",
+                    severity: "info",
+                });
+            }
+            break;
+        case "python":
+            if (/def\s+\w+\([^)]*(?:\[\]|\{\}|set\(\))[^)]*\):/.test(code)) {
+                issues.push({
+                    type: "logic",
+                    description: "Mutable default argument - shared between calls",
+                    severity: "error",
+                    suggestion: "Use None as default and create inside function",
+                });
+            }
+            break;
+    }
+    return { issues };
+}
+function checkSecurityPatterns(code, language) {
+    const issues = [];
+    const lines = code.split("\n");
+    lines.forEach((line, idx) => {
+        if (/(?:password|secret|api_key|apikey|token|auth)\s*[:=]\s*['"][^'"]{8,}['"]/i.test(line)) {
+            issues.push({
+                type: "security",
+                description: "Possible hardcoded secret detected",
+                severity: "error",
+                line: idx + 1,
+                suggestion: "Use environment variables for secrets",
+            });
+        }
+        if (/\beval\s*\(/.test(line)) {
+            issues.push({
+                type: "security",
+                description: "eval() usage - potential code injection vulnerability",
+                severity: "error",
+                line: idx + 1,
+                suggestion: "Avoid eval() - use safer alternatives",
+            });
+        }
+    });
+    switch (language) {
+        case "typescript":
+        case "javascript":
+            if (/\.innerHTML\s*=/.test(code)) {
+                issues.push({
+                    type: "security",
+                    description: "innerHTML assignment - potential XSS vulnerability",
+                    severity: "warning",
+                    suggestion: "Use textContent or sanitize input",
+                });
+            }
+            if (/document\.write\s*\(/.test(code)) {
+                issues.push({
+                    type: "security",
+                    description: "document.write() usage - potential XSS and performance issues",
+                    severity: "warning",
+                });
+            }
+            break;
+        case "python":
+            if (/pickle\.loads?\s*\(/.test(code)) {
+                issues.push({
+                    type: "security",
+                    description: "pickle usage - can execute arbitrary code with untrusted data",
+                    severity: "warning",
+                    suggestion: "Use JSON for untrusted data serialization",
+                });
+            }
+            if (/os\.system\s*\(/.test(code) ||
+                /subprocess\.(?:call|run)\s*\([^)]*shell\s*=\s*True/.test(code)) {
+                issues.push({
+                    type: "security",
+                    description: "Shell command execution - potential command injection",
+                    severity: "warning",
+                    suggestion: "Use subprocess with shell=False and pass args as list",
+                });
+            }
+            break;
+        case "bash":
+            if (/\$\([^)]*\$[A-Za-z_]/.test(code)) {
+                issues.push({
+                    type: "security",
+                    description: "Variable in command substitution - potential injection",
+                    severity: "warning",
+                });
+            }
+            break;
+    }
+    return { issues };
+}
+//# sourceMappingURL=checkCodeFeasibility.js.map