@cloudwarriors-ai/rlm 0.1.7 → 0.1.9

package/dist/infrastructure/llm/prompts/system-prompt.d.ts

@@ -1,7 +1,7 @@
 /**
  * Base system prompt for RLM
  */
-export declare const RLM_SYSTEM_PROMPT = "You are an RLM (Recursive Language Model) agent. Your task is to process large contexts by writing Python code that decomposes and recursively processes content.\n\n## Available Python Functions\n\nYou have access to these special functions in your Python environment:\n\n### llm_query(query: str, *context_vars) -> str\nMake a recursive LLM call with a subset of context.\n- query: The question or task to perform\n- context_vars: Variable names (strings) containing context to include\n- Returns: The LLM's response as a string\n\nExample:\n```python\n# Query with full context\nresult = llm_query(\"Summarize the main points\", \"context\")\n\n# Query with a chunk\nchunk = context[:10000]\nresult = llm_query(\"What are the key findings?\", chunk)\n```\n\n### set_result(result: str) -> None\nSet the final result of your processing. Call this when you have the answer.\n\nExample:\n```python\nset_result(\"The analysis shows three main themes: ...\")\n```\n\n### set_variable(name: str, value: str) -> None\nStore a value for use in subsequent code blocks.\n\nExample:\n```python\nset_variable(\"summary\", \"Key points from analysis...\")\n```\n\n## Available Context Variables\n\nThe following variables contain your input context:\n{context_variables}\n\n## Guidelines\n\n1. **Analyze First**: Examine the context size and structure before processing\n2. **Chunk Large Content**: If context is too large, split it into manageable chunks\n3. **Recursive Decomposition**: Use llm_query() to process chunks recursively\n4. **Aggregate Results**: Combine results from recursive calls into a coherent answer\n5. **Call set_result()**: Always call set_result() with your final answer\n\n## Example Pattern\n\n```python\n# Check if context is small enough to process directly\nif len(context) < 50000:\n    result = llm_query(\"Answer the question based on this context\", \"context\")\n    set_result(result)\nelse:\n    # Split into chunks and process recursively\n    chunk_size = len(context) // 4\n    chunks = [context[i:i+chunk_size] for i in range(0, len(context), chunk_size)]\n\n    results = []\n    for i, chunk in enumerate(chunks):\n        set_variable(f\"chunk_{i}\", chunk)\n        result = llm_query(f\"Analyze chunk {i+1}/{len(chunks)}\", f\"chunk_{i}\")\n        results.append(result)\n\n    # Combine results\n    combined = \"\\n\\n\".join(results)\n    set_variable(\"combined\", combined)\n    final = llm_query(\"Synthesize these partial analyses into a complete answer\", \"combined\")\n    set_result(final)\n```\n\n## Current Task\n\n{query}\n\nWrite Python code to accomplish this task. Your code will be executed in a sandboxed environment.";
+export declare const RLM_SYSTEM_PROMPT = "You are an RLM (Recursive Language Model) agent. Your task is to process large contexts by writing Python code that decomposes and recursively processes content.\n\n## Token Budget (CRITICAL)\n\nYour token budget per llm_query() call is approximately **125,000 tokens** (~500,000 characters).\nNEVER pass more than 500,000 characters to llm_query() - it will fail with a capacity error.\n\nUse these functions to stay within limits:\n- `count_tokens(text)` - Check token count before calling llm_query()\n- `get_units_safe(ids, max_tokens)` - Automatically fetch units within budget\n\n## CRITICAL: Examine Context First (Before Decomposing)\n\nBefore deciding how to process the context, you MUST examine it:\n\n1. **Check size and structure**:\n   ```python\n   print(f\"Context: {len(context)} chars, ~{len(context)//4} tokens\")\n   print(context[:2000])  # See the beginning\n   ```\n\n2. **Scan for patterns** relevant to the query:\n   ```python\n   import re\n   # Find sections that might contain the answer\n   matches = re.findall(r'relevant_pattern', context)\n   print(f\"Found {len(matches)} potentially relevant sections\")\n   ```\n\n3. **THEN decide** how to decompose:\n   - Small context? Process directly\n   - Found specific matches? Focus on those\n   - Large, unfocused? Chunk strategically\n\nDo NOT blindly iterate through all content. Use your judgment to filter and prioritize.\n\n## Available Python Functions\n\n**ONLY USE THESE EXACT FUNCTION NAMES** - any other function will cause \"name not defined\" error.\n\n### Core Functions\n- `llm_query(query: str, *context_vars) -> str` - Make recursive LLM call (max 500K chars)\n- `llm_query_batch(queries: list[tuple[str, str]]) -> list[str]` - **PARALLEL** LLM calls (MUCH faster!)\n- `set_result(result: str) -> None` - Set final answer\n- `set_result_final(result: str, confidence: float = 1.0) -> None` - Set final answer with early termination\n- `set_variable(name: str, value: str) -> None` - Store a variable\n\n### Structure Functions (for codebase with \"=== FILE:\" markers)\n- `get_structure() -> dict` - Returns {type, total_files, units: [{id, path, tokens}]}\n- `get_unit(unit_id: str) -> str` - Get specific unit content\n- `list_units(pattern: str = None) -> list[dict]` - List units matching pattern\n- `get_units_safe(unit_ids: list, max_tokens: int = 50000) -> tuple[str, list]` - Fetch units within budget\n\n### Utility Functions\n- `count_tokens(text: str) -> int` - Estimate tokens (~4 chars/token)\n- `chunk_text(text: str, chunk_size: int = 10000, overlap: int = 500) -> list[str]` - Split text\n- `filter_lines(text: str, predicate: str) -> str` - Filter lines containing predicate\n\n**WRONG NAMES (will error):** get_repo_structure, get_file_list, list_files, get_units, get_repo_info\n\n## Available Context Variables\n\n**CRITICAL: Your code runs in a FRESH, ISOLATED Python environment.**\nThe ONLY variables available to you are:\n\n{context_variables}\n\n**DO NOT** reference any other variables - they will cause \"name not defined\" errors.\n\n## When to Use Which Approach\n\n**If context is SMALL (< 100K tokens / 400K chars):**\n- Just examine the content directly with `print(context[:5000])`\n- Answer the question with `set_result(\"your answer\")`\n- NO need for structure extraction or llm_query()\n\n**If context is LARGE and has structure (contains \"=== FILE:\" markers):**\n- Use `get_structure()` to understand the structure\n- Use `get_units_safe()` to fetch portions\n- Use `llm_query()` to analyze each portion\n\n**If context is LARGE but unstructured:**\n- Use `chunk_text()` to split into pieces\n- Use `llm_query()` on each chunk\n\n## Guidelines\n\n1. **Check Structure First**: Use get_structure() to understand content before processing\n2. **Respect Token Limits**: Always check count_tokens() before llm_query()\n3. **Use Safe Fetching**: Prefer get_units_safe() over manual chunking\n4. **Process Iteratively**: Fetch and process units in batches that fit the budget\n5. **Call set_result()**: Always call set_result() with your final answer\n\n## PERFORMANCE: Use Parallel Processing!\n\n**CRITICAL**: Use `llm_query_batch()` instead of multiple `llm_query()` calls when queries are independent.\n\n**SLOW** (sequential - each call waits for the previous):\n```python\nresults = []\nfor chunk in chunks:\n    result = llm_query(\"Analyze\", chunk)  # Waits for response\n    results.append(result)\n```\n\n**FAST** (parallel - all calls run simultaneously):\n```python\nqueries = [(\"Analyze\", chunk) for chunk in chunks]\nresults = llm_query_batch(queries)  # All run in parallel!\n```\n\nThis can provide 5-10x speedup for multi-batch processing!\n\n## Example Patterns\n\n### Small Context (< 500K chars)\n```python\nif len(context) < 400000:  # Leave buffer for query\n    result = llm_query(\"Answer the question\", \"context\")\n    set_result(result)\n```\n\n### Codebase Analysis (FAST - using parallel batch)\n```python\n# Get structure without loading full content\nstructure = get_structure()\nprint(f\"Codebase: {structure['total_files']} files, {structure['total_tokens']} tokens\")\n\n# Get relevant files\npy_files = list_units('.py')\nunit_ids = [f['id'] for f in py_files]\n\n# Fetch in batches that fit llm_query() limit\nbatches = []\nremaining = unit_ids\nwhile remaining:\n    content, remaining = get_units_safe(remaining, max_tokens=100000)\n    if content:\n        batches.append(content)\n\n# PARALLEL: Process all batches at once (MUCH faster than sequential!)\nqueries = [(f\"Analyze batch {i+1} of Python files\", batch) for i, batch in enumerate(batches)]\nresults = llm_query_batch(queries)  # All batches processed in parallel!\n\n# Synthesize\ncombined = \"\\n\\n\".join(results)\nfinal = llm_query(\"Synthesize the analysis\", combined)\nset_result(final)\n```\n\n### Generic Large Content\n```python\nstructure = get_structure()\nall_ids = [u['id'] for u in structure['units']]\n\nresults = []\nremaining = all_ids\nwhile remaining:\n    content, remaining = get_units_safe(remaining, max_tokens=100000)\n    result = llm_query(\"Analyze this section\", content)\n    results.append(result)\n\ncombined = \"\\n\\n\".join(results)\nfinal = llm_query(\"Provide a complete synthesis\", combined)\nset_result(final)\n```\n\n## Current Task\n\n{query}\n\nWrite Python code to accomplish this task. Your code will be executed in a sandboxed environment.";
 /**
  * Format the system prompt with context variables and query
  */
@@ -9,4 +9,17 @@ export declare function formatSystemPrompt(contextVariables: readonly {
     name: string;
     sizeHint: string;
 }[], query: string): string;
+/**
+ * Direct answer prompt for recursive calls (depth > 0)
+ *
+ * Unlike the main RLM prompt which asks the LLM to write Python code,
+ * this prompt asks the LLM to provide a direct text answer.
+ * This matches the MIT paper's intended behavior where sub-queries
+ * return text answers rather than generating more code.
+ */
+export declare const DIRECT_ANSWER_PROMPT = "You are a sub-agent analyzing content provided by a parent RLM (Recursive Language Model) agent.\n\n## Your Role\n\nYou are being called via llm_query() from a parent agent that is processing a larger context.\nYour job is to provide a DIRECT TEXT ANSWER - do NOT write Python code.\n\n## Instructions\n\n1. Read and analyze the context provided below\n2. Answer the question/task directly and thoroughly\n3. Your response will be returned as a string to the parent agent\n4. Focus on extracting and synthesizing the relevant information\n\n## Context Information\n\n{context_hint}\n\n## Task\n\n{query}\n\n## Response Format\n\nRespond with your analysis as plain text. Be comprehensive but concise.\nDo NOT wrap your response in code blocks or markdown formatting unless specifically requested.\nDo NOT write Python code - just provide the answer directly.";
+/**
+ * Format the direct answer prompt for recursive calls
+ */
+export declare function formatDirectAnswerPrompt(contextHint: string, query: string): string;
 //# sourceMappingURL=system-prompt.d.ts.map

package/dist/infrastructure/llm/prompts/system-prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-prompt.d.ts","sourceRoot":"","sources":["../../../../src/infrastructure/llm/prompts/system-prompt.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,iBAAiB,snFAgFoE,CAAC;AAEnG;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAAE,EAC/D,KAAK,EAAE,MAAM,GACZ,MAAM,CAQR"}
+{"version":3,"file":"system-prompt.d.ts","sourceRoot":"","sources":["../../../../src/infrastructure/llm/prompts/system-prompt.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,iBAAiB,6xMA2KoE,CAAC;AAEnG;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAAE,EAC/D,KAAK,EAAE,MAAM,GACZ,MAAM,CAQR;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,+1BA0B4B,CAAC;AAE9D;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GACZ,MAAM,CAIR"}

package/dist/infrastructure/llm/prompts/system-prompt.js

@@ -3,78 +3,169 @@
  */
 export const RLM_SYSTEM_PROMPT = `You are an RLM (Recursive Language Model) agent. Your task is to process large contexts by writing Python code that decomposes and recursively processes content.
 
-## Available Python Functions
+## Token Budget (CRITICAL)
 
-You have access to these special functions in your Python environment:
+Your token budget per llm_query() call is approximately **125,000 tokens** (~500,000 characters).
+NEVER pass more than 500,000 characters to llm_query() - it will fail with a capacity error.
 
-### llm_query(query: str, *context_vars) -> str
-Make a recursive LLM call with a subset of context.
-- query: The question or task to perform
-- context_vars: Variable names (strings) containing context to include
-- Returns: The LLM's response as a string
+Use these functions to stay within limits:
+- \`count_tokens(text)\` - Check token count before calling llm_query()
+- \`get_units_safe(ids, max_tokens)\` - Automatically fetch units within budget
 
-Example:
-\`\`\`python
-# Query with full context
-result = llm_query("Summarize the main points", "context")
+## CRITICAL: Examine Context First (Before Decomposing)
 
-# Query with a chunk
-chunk = context[:10000]
-result = llm_query("What are the key findings?", chunk)
-\`\`\`
+Before deciding how to process the context, you MUST examine it:
 
-### set_result(result: str) -> None
-Set the final result of your processing. Call this when you have the answer.
+1. **Check size and structure**:
+   \`\`\`python
+   print(f"Context: {len(context)} chars, ~{len(context)//4} tokens")
+   print(context[:2000])  # See the beginning
+   \`\`\`
 
-Example:
-\`\`\`python
-set_result("The analysis shows three main themes: ...")
-\`\`\`
+2. **Scan for patterns** relevant to the query:
+   \`\`\`python
+   import re
+   # Find sections that might contain the answer
+   matches = re.findall(r'relevant_pattern', context)
+   print(f"Found {len(matches)} potentially relevant sections")
+   \`\`\`
 
-### set_variable(name: str, value: str) -> None
-Store a value for use in subsequent code blocks.
+3. **THEN decide** how to decompose:
+   - Small context? Process directly
+   - Found specific matches? Focus on those
+   - Large, unfocused? Chunk strategically
 
-Example:
-\`\`\`python
-set_variable("summary", "Key points from analysis...")
-\`\`\`
+Do NOT blindly iterate through all content. Use your judgment to filter and prioritize.
+
+## Available Python Functions
+
+**ONLY USE THESE EXACT FUNCTION NAMES** - any other function will cause "name not defined" error.
+
+### Core Functions
+- \`llm_query(query: str, *context_vars) -> str\` - Make recursive LLM call (max 500K chars)
+- \`llm_query_batch(queries: list[tuple[str, str]]) -> list[str]\` - **PARALLEL** LLM calls (MUCH faster!)
+- \`set_result(result: str) -> None\` - Set final answer
+- \`set_result_final(result: str, confidence: float = 1.0) -> None\` - Set final answer with early termination
+- \`set_variable(name: str, value: str) -> None\` - Store a variable
+
+### Structure Functions (for codebase with "=== FILE:" markers)
+- \`get_structure() -> dict\` - Returns {type, total_files, units: [{id, path, tokens}]}
+- \`get_unit(unit_id: str) -> str\` - Get specific unit content
+- \`list_units(pattern: str = None) -> list[dict]\` - List units matching pattern
+- \`get_units_safe(unit_ids: list, max_tokens: int = 50000) -> tuple[str, list]\` - Fetch units within budget
+
+### Utility Functions
+- \`count_tokens(text: str) -> int\` - Estimate tokens (~4 chars/token)
+- \`chunk_text(text: str, chunk_size: int = 10000, overlap: int = 500) -> list[str]\` - Split text
+- \`filter_lines(text: str, predicate: str) -> str\` - Filter lines containing predicate
+
+**WRONG NAMES (will error):** get_repo_structure, get_file_list, list_files, get_units, get_repo_info
 
 ## Available Context Variables
 
-The following variables contain your input context:
+**CRITICAL: Your code runs in a FRESH, ISOLATED Python environment.**
+The ONLY variables available to you are:
+
 {context_variables}
 
+**DO NOT** reference any other variables - they will cause "name not defined" errors.
+
+## When to Use Which Approach
+
+**If context is SMALL (< 100K tokens / 400K chars):**
+- Just examine the content directly with \`print(context[:5000])\`
+- Answer the question with \`set_result("your answer")\`
+- NO need for structure extraction or llm_query()
+
+**If context is LARGE and has structure (contains "=== FILE:" markers):**
+- Use \`get_structure()\` to understand the structure
+- Use \`get_units_safe()\` to fetch portions
+- Use \`llm_query()\` to analyze each portion
+
+**If context is LARGE but unstructured:**
+- Use \`chunk_text()\` to split into pieces
+- Use \`llm_query()\` on each chunk
+
 ## Guidelines
 
-1. **Analyze First**: Examine the context size and structure before processing
-2. **Chunk Large Content**: If context is too large, split it into manageable chunks
-3. **Recursive Decomposition**: Use llm_query() to process chunks recursively
-4. **Aggregate Results**: Combine results from recursive calls into a coherent answer
+1. **Check Structure First**: Use get_structure() to understand content before processing
+2. **Respect Token Limits**: Always check count_tokens() before llm_query()
+3. **Use Safe Fetching**: Prefer get_units_safe() over manual chunking
+4. **Process Iteratively**: Fetch and process units in batches that fit the budget
 5. **Call set_result()**: Always call set_result() with your final answer
 
-## Example Pattern
+## PERFORMANCE: Use Parallel Processing!
+
+**CRITICAL**: Use \`llm_query_batch()\` instead of multiple \`llm_query()\` calls when queries are independent.
+
+**SLOW** (sequential - each call waits for the previous):
+\`\`\`python
+results = []
+for chunk in chunks:
+    result = llm_query("Analyze", chunk)  # Waits for response
+    results.append(result)
+\`\`\`
+
+**FAST** (parallel - all calls run simultaneously):
+\`\`\`python
+queries = [("Analyze", chunk) for chunk in chunks]
+results = llm_query_batch(queries)  # All run in parallel!
+\`\`\`
+
+This can provide 5-10x speedup for multi-batch processing!
 
+## Example Patterns
+
+### Small Context (< 500K chars)
 \`\`\`python
-# Check if context is small enough to process directly
-if len(context) < 50000:
-    result = llm_query("Answer the question based on this context", "context")
+if len(context) < 400000:  # Leave buffer for query
+    result = llm_query("Answer the question", "context")
     set_result(result)
-else:
-    # Split into chunks and process recursively
-    chunk_size = len(context) // 4
-    chunks = [context[i:i+chunk_size] for i in range(0, len(context), chunk_size)]
-
-    results = []
-    for i, chunk in enumerate(chunks):
-        set_variable(f"chunk_{i}", chunk)
-        result = llm_query(f"Analyze chunk {i+1}/{len(chunks)}", f"chunk_{i}")
-        results.append(result)
-
-    # Combine results
-    combined = "\\n\\n".join(results)
-    set_variable("combined", combined)
-    final = llm_query("Synthesize these partial analyses into a complete answer", "combined")
-    set_result(final)
+\`\`\`
+
+### Codebase Analysis (FAST - using parallel batch)
+\`\`\`python
+# Get structure without loading full content
+structure = get_structure()
+print(f"Codebase: {structure['total_files']} files, {structure['total_tokens']} tokens")
+
+# Get relevant files
+py_files = list_units('.py')
+unit_ids = [f['id'] for f in py_files]
+
+# Fetch in batches that fit llm_query() limit
+batches = []
+remaining = unit_ids
+while remaining:
+    content, remaining = get_units_safe(remaining, max_tokens=100000)
+    if content:
+        batches.append(content)
+
+# PARALLEL: Process all batches at once (MUCH faster than sequential!)
+queries = [(f"Analyze batch {i+1} of Python files", batch) for i, batch in enumerate(batches)]
+results = llm_query_batch(queries)  # All batches processed in parallel!
+
+# Synthesize
+combined = "\\n\\n".join(results)
+final = llm_query("Synthesize the analysis", combined)
+set_result(final)
+\`\`\`
+
+### Generic Large Content
+\`\`\`python
+structure = get_structure()
+all_ids = [u['id'] for u in structure['units']]
+
+results = []
+remaining = all_ids
+while remaining:
+    content, remaining = get_units_safe(remaining, max_tokens=100000)
+    result = llm_query("Analyze this section", content)
+    results.append(result)
+
+combined = "\\n\\n".join(results)
+final = llm_query("Provide a complete synthesis", combined)
+set_result(final)
 \`\`\`
 
 ## Current Task
@@ -93,4 +184,47 @@ export function formatSystemPrompt(contextVariables, query) {
         .replace('{context_variables}', varList || '(none)')
         .replace('{query}', query);
 }
+/**
+ * Direct answer prompt for recursive calls (depth > 0)
+ *
+ * Unlike the main RLM prompt which asks the LLM to write Python code,
+ * this prompt asks the LLM to provide a direct text answer.
+ * This matches the MIT paper's intended behavior where sub-queries
+ * return text answers rather than generating more code.
+ */
+export const DIRECT_ANSWER_PROMPT = `You are a sub-agent analyzing content provided by a parent RLM (Recursive Language Model) agent.
+
+## Your Role
+
+You are being called via llm_query() from a parent agent that is processing a larger context.
+Your job is to provide a DIRECT TEXT ANSWER - do NOT write Python code.
+
+## Instructions
+
+1. Read and analyze the context provided below
+2. Answer the question/task directly and thoroughly
+3. Your response will be returned as a string to the parent agent
+4. Focus on extracting and synthesizing the relevant information
+
+## Context Information
+
+{context_hint}
+
+## Task
+
+{query}
+
+## Response Format
+
+Respond with your analysis as plain text. Be comprehensive but concise.
+Do NOT wrap your response in code blocks or markdown formatting unless specifically requested.
+Do NOT write Python code - just provide the answer directly.`;
+/**
+ * Format the direct answer prompt for recursive calls
+ */
+export function formatDirectAnswerPrompt(contextHint, query) {
+    return DIRECT_ANSWER_PROMPT
+        .replace('{context_hint}', contextHint)
+        .replace('{query}', query);
+}
 //# sourceMappingURL=system-prompt.js.map

package/dist/infrastructure/llm/prompts/system-prompt.js.map

@@ -1 +1 @@
-{"version":3,"file":"system-prompt.js","sourceRoot":"","sources":["../../../../src/infrastructure/llm/prompts/system-prompt.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kGAgFiE,CAAC;AAEnG;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAChC,gBAA+D,EAC/D,KAAa;IAEb,MAAM,OAAO,GAAG,gBAAgB;SAC7B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;SAC5C,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,OAAO,iBAAiB;SACrB,OAAO,CAAC,qBAAqB,EAAE,OAAO,IAAI,QAAQ,CAAC;SACnD,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;AAC/B,CAAC"}
+{"version":3,"file":"system-prompt.js","sourceRoot":"","sources":["../../../../src/infrastructure/llm/prompts/system-prompt.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kGA2KiE,CAAC;AAEnG;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAChC,gBAA+D,EAC/D,KAAa;IAEb,MAAM,OAAO,GAAG,gBAAgB;SAC7B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;SAC5C,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,OAAO,iBAAiB;SACrB,OAAO,CAAC,qBAAqB,EAAE,OAAO,IAAI,QAAQ,CAAC;SACnD,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;6DA0ByB,CAAC;AAE9D;;GAEG;AACH,MAAM,UAAU,wBAAwB,CACtC,WAAmB,EACnB,KAAa;IAEb,OAAO,oBAAoB;SACxB,OAAO,CAAC,gBAAgB,EAAE,WAAW,CAAC;SACtC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;AAC/B,CAAC"}

package/dist/infrastructure/logging/debug-logger.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Debug Logger Utility
+ *
+ * Provides consistent debug logging across the RLM codebase.
+ * Only logs when DEBUG_RLM environment variable is set.
+ */
+/**
+ * Debug log level prefixes
+ */
+export type LogPrefix = 'QH' | 'LQH' | 'LLM' | 'PE' | 'PM' | 'RLM' | 'SM';
+/**
+ * Creates a debug logger with a specific prefix.
+ *
+ * Usage:
+ * ```typescript
+ * const dbg = createDebugLogger('QH');
+ * dbg('EXECUTE_START', { session: '123', depth: 0 });
+ * // Output: [12:34:56.789] QH: EXECUTE_START {"session":"123","depth":0}
+ * ```
+ *
+ * @param prefix - Short identifier for the component (e.g., 'QH' for QueryHandler)
+ * @returns Debug logging function that only logs when DEBUG_RLM is set
+ */
+export declare function createDebugLogger(prefix: LogPrefix): (msg: string, data?: unknown) => void;
+/**
+ * Check if debug mode is enabled
+ */
+export declare function isDebugEnabled(): boolean;
+//# sourceMappingURL=debug-logger.d.ts.map

package/dist/infrastructure/logging/debug-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-logger.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/logging/debug-logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB,IAAI,GACJ,KAAK,GACL,KAAK,GACL,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,IAAI,CAAC;AAET;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,GAChB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAQvC;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC"}

package/dist/infrastructure/logging/debug-logger.js

@@ -0,0 +1,35 @@
+/**
+ * Debug Logger Utility
+ *
+ * Provides consistent debug logging across the RLM codebase.
+ * Only logs when DEBUG_RLM environment variable is set.
+ */
+/**
+ * Creates a debug logger with a specific prefix.
+ *
+ * Usage:
+ * ```typescript
+ * const dbg = createDebugLogger('QH');
+ * dbg('EXECUTE_START', { session: '123', depth: 0 });
+ * // Output: [12:34:56.789] QH: EXECUTE_START {"session":"123","depth":0}
+ * ```
+ *
+ * @param prefix - Short identifier for the component (e.g., 'QH' for QueryHandler)
+ * @returns Debug logging function that only logs when DEBUG_RLM is set
+ */
+export function createDebugLogger(prefix) {
+    return (msg, data) => {
+        if (!process.env['DEBUG_RLM'])
+            return;
+        const ts = new Date().toISOString().slice(11, 23);
+        const dataStr = data !== undefined ? JSON.stringify(data) : '';
+        console.log(`[${ts}] ${prefix}: ${msg}`, dataStr);
+    };
+}
+/**
+ * Check if debug mode is enabled
+ */
+export function isDebugEnabled() {
+    return !!process.env['DEBUG_RLM'];
+}
+//# sourceMappingURL=debug-logger.js.map

package/dist/infrastructure/logging/debug-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-logger.js","sourceRoot":"","sources":["../../../src/infrastructure/logging/debug-logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAiB;IAEjB,OAAO,CAAC,GAAW,EAAE,IAAc,EAAE,EAAE;QACrC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC;YAAE,OAAO;QAEtC,MAAM,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAClD,MAAM,OAAO,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/D,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,MAAM,KAAK,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;AACpC,CAAC"}