boxsafe 1.0.0

package/util/extractCode.ts

@@ -0,0 +1,217 @@
+import { remark } from 'remark';
+import { visit } from 'unist-util-visit';
+import { Logger } from '@util/logger';
+
+const logger = Logger.createModuleLogger('ExtractCode');
+
+/* -------------------------------------------------------------------------- */
+/*                                   Types                                    */
+/* -------------------------------------------------------------------------- */
+
+interface ExtractCodeOptions {
+  /**
+   * If true, throws error when code is not found.
+   * If false, returns guidance prompt.
+   * @default false
+   */
+  throwOnNotFound?: boolean;
+
+  /**
+   * Custom message when code is not found
+   */
+  customNotFoundMessage?: string;
+}
+
+/* -------------------------------------------------------------------------- */
+/*                               Configuration                                */
+/* -------------------------------------------------------------------------- */
+
+const LANG_ALIASES: Record<string, string[]> = {
+  javascript: ['javascript', 'js'],
+  typescript: ['typescript', 'ts'],
+  python: ['python', 'py'],
+  bash: ['bash', 'sh', 'shell'],
+  rust: ['rust', 'rs'],
+};
+
+/* -------------------------------------------------------------------------- */
+/*                                  Helpers                                   */
+/* -------------------------------------------------------------------------- */
+
+function normalizeLang(lang?: string): string | undefined {
+  return lang?.toLowerCase().trim();
+}
+
+function matchesLanguage(target: string, nodeLang?: string): boolean {
+  if (!nodeLang) return false;
+
+  const normalizedNodeLang = normalizeLang(nodeLang);
+
+  if (normalizedNodeLang === target) return true;
+
+  return Object.values(LANG_ALIASES).some(
+    (aliases) =>
+      aliases.includes(target) && aliases.includes(normalizedNodeLang!)
+  );
+}
+
+/**
+ * Heuristic detection of language from a code snippet when no fence language is provided.
+ * Returns true when the snippet contains tokens commonly associated with `target`.
+ */
+function detectByContent(target: string, code: string): boolean {
+  const c = code || '';
+  switch (target) {
+    case 'typescript':
+    case 'ts':
+    case 'javascript':
+    case 'js':
+      return /\b(import|export|const|let|interface|type|from|require\(|console\.log)\b/.test(c);
+    case 'python':
+    case 'py':
+      return /\b(def |import |from |print\()/.test(c);
+    case 'bash':
+    case 'sh':
+    case 'shell':
+      return /(^#!\/bin\/bash)|(^#!\/usr\/bin\/env bash)|\becho\b|\bcd\b|\bmkdir\b/.test(c);
+    case 'rust':
+    case 'rs':
+      return /\b(fn |let |use |extern crate)\b/.test(c);
+    default:
+      return false;
+  }
+}
+
+/**
+ * Generates guidance prompt when code is not found
+ */
+function generateNotFoundPrompt(lang: string): string {
+  return `ERROR: ${lang} code was not found in the response.
+
+MANDATORY INSTRUCTIONS:
+1. Generate ONLY the requested ${lang} code
+2. Use the correct code block format: \`\`\`${lang}
+3. DO NOT include explanations, descriptions, or additional text
+4. DO NOT generate multiple code blocks
+5. The code will be executed directly - it will not be read by humans
+6. Do not use markdown for anything other than the code block
+7. Return ONLY a single functional code block
+
+Correct format example:
+\`\`\`${lang}
+// your code here
+\`\`\`
+
+Generate the ${lang} code now following these instructions.`;
+}
+
+/* -------------------------------------------------------------------------- */
+/*                                   Public                                   */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Extracts code blocks of a specific language from Markdown.
+ *
+ * @param md - Markdown string (usually LLM response)
+ * @param lang - Code language (javascript, python, etc)
+ * @param options - Configuration options
+ * @returns Array of found code blocks or error prompt
+ */
+export const extractCode = async (
+  md: string,
+  lang: string,
+  options: ExtractCodeOptions = {}
+): Promise<string[]> => {
+  const { throwOnNotFound = false, customNotFoundMessage } = options;
+
+  if (!md || typeof md !== 'string') {
+    const errorMsg = 'Invalid markdown input: expected non-empty string';
+    logger.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  if (!lang || typeof lang !== 'string') {
+    const errorMsg = 'Invalid language: expected non-empty string';
+    logger.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  const codeBlocks: string[] = [];
+  const normalizedLang = normalizeLang(lang)!;
+
+  const onVisitCode = (node: any) => {
+    if (!node?.value) return;
+
+    // Exact match by explicit fence language
+    if (matchesLanguage(normalizedLang, node.lang)) {
+      codeBlocks.push(node.value.trim());
+      return;
+    }
+
+    // Fallback: if the fence had no language, try to heuristically detect
+    // the requested language from the code content itself.
+    if (!node.lang && detectByContent(normalizedLang, node.value)) {
+      codeBlocks.push(node.value.trim());
+      return;
+    }
+  };
+
+  try {
+    await remark()
+      .use(() => (tree) => {
+        visit(tree, 'code', onVisitCode);
+      })
+      .process(md);
+
+    if (codeBlocks.length === 0) {
+      if (throwOnNotFound) {
+        const errorMsg = `No ${lang} code block found in markdown`;
+        logger.error(errorMsg);
+        throw new Error(errorMsg);
+      }
+
+      // Fallback: try to extract unlabeled fenced blocks or raw code from the
+      // entire markdown string when no explicit code nodes were found.
+      // 1) unlabeled/any fenced blocks via regex
+      const fenceRegex = /```(?:\w+)?\n([\s\S]*?)\n```/g;
+      let m: RegExpExecArray | null;
+      while ((m = fenceRegex.exec(md)) !== null) {
+        if (!m || !m[1]) continue;
+        const candidate = m[1].trim();
+        if (candidate && (detectByContent(normalizedLang, candidate) || normalizedLang === 'ts' || normalizedLang === 'js')) {
+          codeBlocks.push(candidate);
+        }
+      }
+
+      // 2) If still nothing, heuristically treat the whole markdown as code
+      // when it clearly contains tokens for the requested language.
+      if (codeBlocks.length === 0 && detectByContent(normalizedLang, md)) {
+        // require at least two lines to avoid grabbing short messages
+        if ((md.match(/\n/g) || []).length >= 1) {
+          codeBlocks.push(md.trim());
+        }
+      }
+
+      if (codeBlocks.length === 0) {
+        if (throwOnNotFound) {
+          const errorMsg = `No ${lang} code block found in markdown`;
+          logger.error(errorMsg);
+          throw new Error(errorMsg);
+        }
+
+        return [customNotFoundMessage ?? generateNotFoundPrompt(lang)];
+      }
+    }
+
+    return codeBlocks;
+  } catch (error) {
+    const errorMsg = `Failed to parse markdown: ${error}`;
+    logger.error(errorMsg);
+
+    throw new Error(
+      `Failed to extract code: ${
+        error instanceof Error ? error.message : 'unknown error'
+      }`
+    );
+  }
+};

package/util/extractToolCalls.ts

@@ -0,0 +1,80 @@
+import { remark } from 'remark';
+import { visit } from 'unist-util-visit';
+import { Logger } from '@core/util/logger';
+import type { ToolCallParseResult, ToolCallParseError } from '@core/loop/toolCalls';
+import { parseOneToolCall, isParseError } from '@core/loop/toolCalls';
+
+const logger = Logger.createModuleLogger('ExtractToolCalls');
+
+/**
+ * Extracts json-tool blocks from Markdown using remark (same approach as extractCode)
+ * 
+ * @param md - Markdown string (usually LLM response)
+ * @returns ToolCallParseResult with parsed calls and errors
+ */
+export const extractToolCalls = async (md: string): Promise<ToolCallParseResult> => {
+  const calls: any[] = [];
+  const errors: ToolCallParseError[] = [];
+
+  if (!md || typeof md !== 'string') {
+    const errorMsg = 'Invalid markdown input: expected non-empty string';
+    logger.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  logger.debug(`Processing markdown of length ${md.length}`);
+
+  const onVisitCode = (node: any) => {
+    if (!node?.value) return;
+    
+    // Only process json-tool blocks
+    if (node.lang === 'json-tool') {
+      logger.debug(`Found json-tool block: ${node.value.substring(0, 100)}...`);
+      
+      try {
+        const jsonContent = node.value.trim();
+        const parsed = JSON.parse(jsonContent);
+        const toolCall = parseOneToolCall(parsed);
+        
+        if (isParseError(toolCall)) {
+          logger.warn(`Invalid tool call: ${toolCall.error}`);
+          errors.push({ ...toolCall, fence: jsonContent });
+        } else {
+          logger.info(`Valid tool call detected: ${toolCall.tool}`);
+          calls.push(toolCall);
+        }
+      } catch (e: any) {
+        logger.error(`JSON parse error: ${e?.message ?? String(e)}`);
+        errors.push({ 
+          ok: false, 
+          error: `invalid JSON: ${e?.message ?? String(e)}`, 
+          fence: node.value 
+        });
+      }
+    }
+  };
+
+  try {
+    await remark()
+      .use(() => (tree) => {
+        visit(tree, 'code', onVisitCode);
+      })
+      .process(md);
+
+    logger.info(`Extracted ${calls.length} tool calls, ${errors.length} errors`);
+    
+    return { 
+      ok: true, 
+      calls, 
+      errors 
+    };
+  } catch (error) {
+    const errorMsg = `Failed to parse markdown for tool calls: ${error}`;
+    logger.error(errorMsg);
+    throw new Error(
+      `Failed to extract tool calls: ${
+        error instanceof Error ? error.message : 'unknown error'
+      }`
+    );
+  }
+};

package/util/logger.ts

@@ -0,0 +1,125 @@
+export enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+}
+
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    module: string;
+    timestamp: Date;
+}
+
+export class Logger {
+    private static instance: Logger;
+    private currentLevel: LogLevel;
+    private moduleName: string;
+
+    // ANSI color codes - simplified for better readability
+    private static readonly COLORS = {
+        RESET: '\x1b[0m',
+        DEBUG: '\x1b[36m', // Cyan
+        INFO: '\x1b[32m',  // Green  
+        WARN: '\x1b[33m',  // Yellow
+        ERROR: '\x1b[31m', // Red
+    };
+
+    private static readonly LEVEL_NAMES = {
+        [LogLevel.DEBUG]: 'DEBUG',
+        [LogLevel.INFO]: 'INFO',
+        [LogLevel.WARN]: 'WARN',
+        [LogLevel.ERROR]: 'ERROR',
+    };
+
+    constructor(moduleName: string = 'root', level: LogLevel = LogLevel.INFO) {
+        this.moduleName = moduleName;
+        this.currentLevel = level;
+    }
+
+    static getInstance(moduleName?: string, level?: LogLevel): Logger {
+        if (!Logger.instance) {
+            Logger.instance = new Logger(moduleName || 'root', level);
+        }
+        return Logger.instance;
+    }
+
+    setLevel(level: LogLevel): void {
+        this.currentLevel = level;
+    }
+
+    getLevel(): LogLevel {
+        return this.currentLevel;
+    }
+
+    private formatMessage(level: LogLevel, message: string): string {
+        const levelName = Logger.LEVEL_NAMES[level];
+        const color = Logger.COLORS[levelName as keyof typeof Logger.COLORS];
+        const reset = Logger.COLORS.RESET;
+
+        return `${color}[${levelName}(${this.moduleName})]${reset} ${message}\n\n`;
+    }
+
+    private log(level: LogLevel, message: string): void {
+        if (level < this.currentLevel) {
+            return;
+        }
+
+        const formattedMessage = this.formatMessage(level, message);
+        process.stdout.write(formattedMessage);
+    }
+
+    debug(message: string): void {
+        this.log(LogLevel.DEBUG, message);
+    }
+
+    info(message: string): void {
+        this.log(LogLevel.INFO, message);
+    }
+
+    warn(message: string): void {
+        this.log(LogLevel.WARN, message);
+    }
+
+    error(message: string): void {
+        this.log(LogLevel.ERROR, message);
+    }
+
+    // Static methods for quick access
+    static debug(message: string, moduleName?: string): void {
+        const logger = new Logger(moduleName || 'root');
+        logger.debug(message);
+    }
+
+    static info(message: string, moduleName?: string): void {
+        const logger = new Logger(moduleName || 'root');
+        logger.info(message);
+    }
+
+    static warn(message: string, moduleName?: string): void {
+        const logger = new Logger(moduleName || 'root');
+        logger.warn(message);
+    }
+
+    static error(message: string, moduleName?: string): void {
+        const logger = new Logger(moduleName || 'root');
+        logger.error(message);
+    }
+
+    // Method to create a logger instance for a specific module
+    static createModuleLogger(moduleName: string, level?: LogLevel): Logger {
+        return new Logger(moduleName, level);
+    }
+}
+
+// Export a default logger instance
+export const logger = Logger.getInstance();
+
+// Export convenience functions
+export const log = {
+    debug: (message: string, moduleName?: string) => Logger.debug(message, moduleName),
+    info: (message: string, moduleName?: string) => Logger.info(message, moduleName),
+    warn: (message: string, moduleName?: string) => Logger.warn(message, moduleName),
+    error: (message: string, moduleName?: string) => Logger.error(message, moduleName),
+};