SYMBOL INDEX (439 symbols across 58 files)

FILE: app/agent/base.py
  class BaseAgent (line 13) | class BaseAgent(BaseModel, ABC):
    class Config (line 45) | class Config:
    method initialize_agent (line 50) | def initialize_agent(self) -> "BaseAgent":
    method state_context (line 59) | async def state_context(self, new_state: AgentState):
    method update_memory (line 84) | def update_memory(
    method run (line 114) | async def run(
    method step (line 160) | async def step(self) -> str:
    method handle_stuck_state (line 166) | def handle_stuck_state(self):
    method is_stuck (line 173) | def is_stuck(self) -> bool:
    method messages (line 192) | def messages(self) -> List[Message]:
    method messages (line 197) | def messages(self, value: List[Message]):

FILE: app/agent/llm_wrapper.py
  class LLMCallbackWrapper (line 10) | class LLMCallbackWrapper:
    method __init__ (line 13) | def __init__(self, llm_instance):
    method _wrap_methods (line 22) | def _wrap_methods(self):
    method _save_conversation_to_file (line 104) | def _save_conversation_to_file(self, args, kwargs, result):
    method register_callback (line 138) | def register_callback(self, event_type: str, callback: Callable):
    method unregister_callback (line 150) | def unregister_callback(self, event_type: str, callback: Callable):
    method clear_callbacks (line 157) | def clear_callbacks(self, event_type: str = None):
    method _execute_callbacks (line 167) | def _execute_callbacks(self, event_type: str, data: Dict[str, Any]):
    method __getattr__ (line 176) | def __getattr__(self, name):

FILE: app/agent/manus.py
  class Manus (line 12) | class Manus(ToolCallAgent):

FILE: app/agent/planning.py
  class PlanningAgent (line 13) | class PlanningAgent(ToolCallAgent):
    method initialize_plan_and_verify_tools (line 43) | def initialize_plan_and_verify_tools(self) -> "PlanningAgent":
    method think (line 52) | async def think(self) -> bool:
    method act (line 83) | async def act(self) -> str:
    method get_plan (line 105) | async def get_plan(self) -> str:
    method run (line 116) | async def run(self, request: Optional[str] = None) -> str:
    method update_plan_status (line 122) | async def update_plan_status(self, tool_call_id: str) -> None:
    method _get_current_step_index (line 158) | async def _get_current_step_index(self) -> Optional[int]:
    method create_initial_plan (line 201) | async def create_initial_plan(self, request: str) -> None:
  function main (line 249) | async def main():

FILE: app/agent/react.py
  class ReActAgent (line 11) | class ReActAgent(BaseAgent, ABC):
    method think (line 26) | async def think(self) -> bool:
    method act (line 30) | async def act(self) -> str:
    method step (line 33) | async def step(self) -> str:

FILE: app/agent/swe.py
  class SWEAgent (line 10) | class SWEAgent(ToolCallAgent):
    method think (line 29) | async def think(self) -> bool:

FILE: app/agent/toolcall.py
  class ToolCallAgent (line 16) | class ToolCallAgent(ReActAgent):
    method think (line 35) | async def think(self) -> bool:
    method act (line 101) | async def act(self) -> str:
    method execute_tool (line 126) | async def execute_tool(self, command: ToolCall) -> str:
    method _handle_special_tool (line 165) | async def _handle_special_tool(self, name: str, result: Any, **kwargs):
    method _should_finish_execution (line 176) | def _should_finish_execution(**kwargs) -> bool:
    method _is_special_tool (line 180) | def _is_special_tool(self, name: str) -> bool:

FILE: app/config.py
  function get_project_root (line 9) | def get_project_root() -> Path:
  class LLMSettings (line 18) | class LLMSettings(BaseModel):
  class AppConfig (line 28) | class AppConfig(BaseModel):
  class Config (line 32) | class Config:
    method __new__ (line 37) | def __new__(cls):
    method __init__ (line 44) | def __init__(self):
    method _get_config_path (line 53) | def _get_config_path() -> Path:
    method _load_config (line 63) | def _load_config(self) -> dict:
    method _load_initial_config (line 68) | def _load_initial_config(self):
    method llm (line 98) | def llm(self) -> Dict[str, LLMSettings]:

FILE: app/exceptions.py
  class ToolError (line 1) | class ToolError(Exception):
    method __init__ (line 4) | def __init__(self, message):

FILE: app/flow/base.py
  class FlowType (line 11) | class FlowType(str, Enum):
  class BaseFlow (line 15) | class BaseFlow(BaseModel, ABC):
    class Config (line 22) | class Config:
    method __init__ (line 25) | def __init__(
    method primary_agent (line 49) | def primary_agent(self) -> Optional[BaseAgent]:
    method get_agent (line 53) | def get_agent(self, key: str) -> Optional[BaseAgent]:
    method add_agent (line 57) | def add_agent(self, key: str, agent: BaseAgent) -> None:
    method execute (line 62) | async def execute(

FILE: app/flow/flow_factory.py
  class FlowFactory (line 7) | class FlowFactory:
    method create_flow (line 11) | def create_flow(

FILE: app/flow/planning.py
  class PlanningFlow (line 17) | class PlanningFlow(BaseFlow):
    method __init__ (line 26) | def __init__(
    method get_executor (line 49) | def get_executor(self, step_type: Optional[str] = None) -> BaseAgent:
    method execute (line 66) | async def execute(
    method _create_initial_plan (line 115) | async def _create_initial_plan(self, request: str, job_id: str = None)...
    method _get_current_step_info (line 188) | async def _get_current_step_info(self) -> tuple[Optional[int], Optiona...
    method _execute_step (line 252) | async def _execute_step(self, executor: BaseAgent, step_info: dict) ->...
    method _mark_step_completed (line 281) | async def _mark_step_completed(self) -> None:
    method _get_plan_text (line 313) | async def _get_plan_text(self) -> str:
    method _generate_plan_text_from_storage (line 324) | def _generate_plan_text_from_storage(self) -> str:
    method _finalize_plan (line 389) | async def _finalize_plan(self) -> str:

FILE: app/flow/tracking_support.py
  class FlowTracker (line 9) | class FlowTracker:
    method patch_flow (line 13) | def patch_flow(flow_obj, session_id: str):

FILE: app/llm.py
  class LLM (line 18) | class LLM:
    method __new__ (line 21) | def __new__(
    method __init__ (line 30) | def __init__(
    method format_messages (line 53) | def format_messages(messages: List[Union[dict, Message]]) -> List[dict]:
    method ask (line 104) | async def ask(
    method ask_tool (line 184) | async def ask_tool(

FILE: app/schema.py
  class AgentState (line 7) | class AgentState(str, Enum):
  class Function (line 16) | class Function(BaseModel):
  class ToolCall (line 21) | class ToolCall(BaseModel):
  class Message (line 29) | class Message(BaseModel):
    method __add__ (line 38) | def __add__(self, other) -> List["Message"]:
    method __radd__ (line 49) | def __radd__(self, other) -> List["Message"]:
    method to_dict (line 58) | def to_dict(self) -> dict:
    method user_message (line 72) | def user_message(cls, content: str) -> "Message":
    method system_message (line 77) | def system_message(cls, content: str) -> "Message":
    method assistant_message (line 82) | def assistant_message(cls, content: Optional[str] = None) -> "Message":
    method tool_message (line 87) | def tool_message(cls, content: str, name, tool_call_id: str) -> "Messa...
    method from_tool_calls (line 92) | def from_tool_calls(
  class Memory (line 110) | class Memory(BaseModel):
    method add_message (line 114) | def add_message(self, message: Message) -> None:
    method add_messages (line 121) | def add_messages(self, messages: List[Message]) -> None:
    method clear (line 125) | def clear(self) -> None:
    method get_recent_messages (line 129) | def get_recent_messages(self, n: int) -> List[Message]:
    method to_dict_list (line 133) | def to_dict_list(self) -> List[dict]:

FILE: app/tool/base.py
  class BaseTool (line 7) | class BaseTool(ABC, BaseModel):
    class Config (line 12) | class Config:
    method __call__ (line 15) | async def __call__(self, **kwargs) -> Any:
    method execute (line 20) | async def execute(self, **kwargs) -> Any:
    method to_param (line 23) | def to_param(self) -> Dict:
  class ToolResult (line 35) | class ToolResult(BaseModel):
    class Config (line 42) | class Config:
    method __bool__ (line 45) | def __bool__(self):
    method __add__ (line 48) | def __add__(self, other: "ToolResult"):
    method __str__ (line 64) | def __str__(self):
    method replace (line 67) | def replace(self, **kwargs):
  class CLIResult (line 73) | class CLIResult(ToolResult):
  class ToolFailure (line 77) | class ToolFailure(ToolResult):
  class AgentAwareTool (line 81) | class AgentAwareTool:

FILE: app/tool/bash.py
  class _BashSession (line 16) | class _BashSession:
    method __init__ (line 27) | def __init__(self):
    method start (line 31) | async def start(self):
    method stop (line 47) | def stop(self):
    method run (line 55) | async def run(self, command: str):
  class Bash (line 116) | class Bash(BaseTool):
    method execute (line 134) | async def execute(

FILE: app/tool/browser_use_tool.py
  class BrowserUseTool (line 35) | class BrowserUseTool(BaseTool):
    method validate_parameters (line 99) | def validate_parameters(cls, v: dict, info: ValidationInfo) -> dict:
    method _ensure_browser_initialized (line 104) | async def _ensure_browser_initialized(self) -> BrowserContext:
    method execute (line 113) | async def execute(
    method get_current_state (line 246) | async def get_current_state(self) -> ToolResult:
    method cleanup (line 262) | async def cleanup(self):
    method __del__ (line 280) | def __del__(self):

FILE: app/tool/create_chat_completion.py
  class CreateChatCompletion (line 8) | class CreateChatCompletion(BaseTool):
    method __init__ (line 26) | def __init__(self, response_type: Optional[Type] = str):
    method _build_parameters (line 32) | def _build_parameters(self) -> dict:
    method _create_type_schema (line 58) | def _create_type_schema(self, type_hint: Type) -> dict:
    method _get_type_info (line 110) | def _get_type_info(self, type_hint: Type) -> dict:
    method _create_union_schema (line 120) | def _create_union_schema(self, types: tuple) -> dict:
    method execute (line 130) | async def execute(self, required: list | None = None, **kwargs) -> Any:

FILE: app/tool/file_saver.py
  class FileSaver (line 8) | class FileSaver(BaseTool):
    method execute (line 35) | async def execute(self, content: str, file_path: str, mode: str = "w")...

FILE: app/tool/google_search.py
  class GoogleSearch (line 9) | class GoogleSearch(BaseTool):
    method execute (line 31) | async def execute(self, query: str, num_results: int = 10) -> List[str]:

FILE: app/tool/planning.py
  class PlanningTool (line 14) | class PlanningTool(BaseTool):
    method execute (line 72) | async def execute(
    method _create_plan (line 120) | def _create_plan(
    method _update_plan (line 160) | def _update_plan(
    method _list_plans (line 209) | def _list_plans(self) -> ToolResult:
    method _get_plan (line 228) | def _get_plan(self, plan_id: Optional[str]) -> ToolResult:
    method _set_active_plan (line 244) | def _set_active_plan(self, plan_id: Optional[str]) -> ToolResult:
    method _mark_step (line 257) | def _mark_step(
    method _delete_plan (line 306) | def _delete_plan(self, plan_id: Optional[str]) -> ToolResult:
    method _format_plan (line 322) | def _format_plan(self, plan: Dict) -> str:

FILE: app/tool/python_execute.py
  class PythonExecute (line 7) | class PythonExecute(BaseTool):
    method execute (line 23) | async def execute(

FILE: app/tool/run.py
  function maybe_truncate (line 10) | def maybe_truncate(content: str, truncate_after: int | None = MAX_RESPON...
  function run (line 19) | async def run(

FILE: app/tool/str_replace_editor.py
  function maybe_truncate (line 38) | def maybe_truncate(content: str, truncate_after: int | None = MAX_RESPON...
  class StrReplaceEditor (line 47) | class StrReplaceEditor(BaseTool):
    method execute (line 91) | async def execute(
    method validate_path (line 135) | def validate_path(self, command: str, path: Path):
    method view (line 161) | async def view(self, path: Path, view_range: list[int] | None = None):
    method str_replace (line 208) | def str_replace(self, path: Path, old_str: str, new_str: str | None):
    method insert (line 256) | def insert(self, path: Path, insert_line: int, new_str: str):
    method undo_edit (line 295) | def undo_edit(self, path: Path):
    method read_file (line 307) | def read_file(self, path: Path):
    method write_file (line 314) | def write_file(self, path: Path, file: str):
    method _make_output (line 321) | def _make_output(

FILE: app/tool/terminate.py
  class Terminate (line 7) | class Terminate(BaseTool):
    method execute (line 22) | async def execute(self, status: str) -> str:

FILE: app/tool/tool_collection.py
  class ToolCollection (line 8) | class ToolCollection:
    method __init__ (line 11) | def __init__(self, *tools: BaseTool):
    method __iter__ (line 15) | def __iter__(self):
    method to_params (line 18) | def to_params(self) -> List[Dict[str, Any]]:
    method execute (line 21) | async def execute(
    method execute_all (line 33) | async def execute_all(self) -> List[ToolResult]:
    method get_tool (line 44) | def get_tool(self, name: str) -> BaseTool:
    method add_tool (line 47) | def add_tool(self, tool: BaseTool):
    method add_tools (line 52) | def add_tools(self, *tools: BaseTool):

FILE: app/utils/log_monitor.py
  class LogFileMonitor (line 9) | class LogFileMonitor:
    method __init__ (line 10) | def __init__(self, job_id=None, log_dir="logs"):
    method start_monitoring (line 27) | def start_monitoring(self):
    method parse_log_line (line 48) | def parse_log_line(self, line):
    method get_generated_files (line 60) | def get_generated_files(self):
    method get_log_entries (line 63) | def get_log_entries(self):
    method get_new_entries_since (line 66) | def get_new_entries_since(self, timestamp):
  class LogEventHandler (line 88) | class LogEventHandler(FileSystemEventHandler):
    method __init__ (line 89) | def __init__(self, monitor):
    method on_modified (line 93) | def on_modified(self, event):
    method on_created (line 104) | def on_created(self, event):

FILE: app/web/api.py
  function get_job_files (line 11) | def get_job_files(job_id):
  function get_job_logs (line 22) | def get_job_logs(job_id):

FILE: app/web/app.py
  function create_workspace (line 68) | def create_workspace(session_id: str) -> Path:
  function startup_event (line 78) | async def startup_event():
  class SessionRequest (line 88) | class SessionRequest(BaseModel):
  function get_home (line 93) | async def get_home(request: Request):
  function get_original_interface (line 103) | async def get_original_interface(request: Request):
  function get_connected_interface (line 109) | async def get_connected_interface(request: Request):
  function create_chat_session (line 119) | async def create_chat_session(
  function get_chat_result (line 147) | async def get_chat_result(session_id: str):
  function stop_processing (line 159) | async def stop_processing(session_id: str):
  function websocket_endpoint (line 173) | async def websocket_endpoint(websocket: WebSocket, session_id: str):
  class LLMCommunicationTracker (line 346) | class LLMCommunicationTracker:
    method __init__ (line 349) | def __init__(self, session_id: str, agent=None):
    method install_hooks (line 358) | def install_hooks(self):
    method uninstall_hooks (line 372) | def uninstall_hooks(self):
    method _wrap_completion (line 377) | def _wrap_completion(self, original_method):
  function get_generated_files (line 422) | async def get_generated_files():
  function get_system_logs (line 481) | async def get_system_logs(limit: int = 10):
  function get_log_content (line 499) | async def get_log_content(log_name: str, parsed: bool = False):
  function get_parsed_logs (line 520) | async def get_parsed_logs(limit: int = 10):
  function get_parsed_log (line 526) | async def get_parsed_log(log_name: str):
  function get_latest_log (line 539) | async def get_latest_log():
  function get_file_content (line 545) | async def get_file_content(file_path: str):
  function process_prompt (line 579) | async def process_prompt(session_id: str, prompt: str):
  function get_thinking_steps (line 845) | async def get_thinking_steps(session_id: str, start_index: int = 0):
  function get_progress (line 857) | async def get_progress(session_id: str):
  function get_system_logs (line 866) | async def get_system_logs(session_id: str):

FILE: app/web/llm_monitor.py
  class LLMMonitor (line 11) | class LLMMonitor:
    method __init__ (line 14) | def __init__(self):
    method register_interceptor (line 18) | def register_interceptor(self, func: Callable):
    method record_communication (line 23) | def record_communication(self, direction: str, content: Any):
    method get_communications (line 39) | def get_communications(self, start_idx: int = 0) -> List[Dict[str, Any]]:
    method clear (line 43) | def clear(self):
    method intercept_method (line 47) | def intercept_method(self, obj, method_name):
  function simulate_llm_thinking (line 77) | async def simulate_llm_thinking(

FILE: app/web/log_handler.py
  class SessionLogHandler (line 18) | class SessionLogHandler:
    method __init__ (line 19) | def __init__(self, session_id: str):
    method __call__ (line 22) | def __call__(self, record):
  class SimpleLogCapture (line 39) | class SimpleLogCapture:
    method __init__ (line 42) | def __init__(self, session_id: str):
    method info (line 45) | def info(self, message: str) -> None:
    method warning (line 50) | def warning(self, message: str) -> None:
    method error (line 55) | def error(self, message: str) -> None:
    method debug (line 60) | def debug(self, message: str) -> None:
    method exception (line 65) | def exception(self, message: str) -> None:
  function capture_session_logs (line 72) | def capture_session_logs(session_id: str):
  function add_log (line 96) | def add_log(session_id: str, level: str, message: str) -> None:
  function get_logs (line 112) | def get_logs(session_id: str) -> List[Dict]:
  function clear_logs (line 118) | def clear_logs(session_id: str) -> None:

FILE: app/web/log_parser.py
  class LogParser (line 11) | class LogParser:
    method __init__ (line 14) | def __init__(self, log_path: str):
    method parse (line 34) | def parse(self) -> Dict[str, Any]:
    method _extract_plan_info (line 75) | def _extract_plan_info(self) -> None:
    method _extract_step_info (line 89) | def _extract_step_info(self) -> None:
    method _extract_tool_executions (line 143) | def _extract_tool_executions(self) -> None:
    method _extract_errors_warnings (line 176) | def _extract_errors_warnings(self) -> None:
    method _calculate_progress (line 204) | def _calculate_progress(self) -> int:
    method _extract_timestamp (line 210) | def _extract_timestamp(self) -> str:
    method _extract_timestamp_for_line (line 242) | def _extract_timestamp_for_line(self, line: str) -> str:
    method _determine_status (line 256) | def _determine_status(self) -> str:
  function parse_log_file (line 283) | def parse_log_file(log_path: str) -> Dict[str, Any]:
  function get_latest_log_info (line 297) | def get_latest_log_info(logs_dir: str = None) -> Dict[str, Any]:
  function get_all_logs_info (line 328) | def get_all_logs_info(logs_dir: str = None, limit: int = 10) -> List[Dic...

FILE: app/web/static/archive/apiManager.js
  function sendRequest (line 7) | async function sendRequest(prompt) {
  function pollResults (line 43) | async function pollResults(sessionId) {
  function updateThinkingSteps (line 118) | function updateThinkingSteps(steps) {
  function formatCommunicationContent (line 202) | function formatCommunicationContent(content) {
  function updateTerminalOutput (line 222) | function updateTerminalOutput(outputs) {

FILE: app/web/static/archive/chatManager.js
  function addMessage (line 1) | function addMessage(content, sender) {
  function clearChat (line 29) | function clearChat() {
  function formatCodeBlocks (line 34) | function formatCodeBlocks(text) {

FILE: app/web/static/archive/fileViewerManager.js
  function fetchGeneratedFiles (line 1) | async function fetchGeneratedFiles() {
  function updateWorkspaceList (line 20) | function updateWorkspaceList(workspaces) {
  function updateFilesList (line 100) | function updateFilesList(files) {
  function viewFile (line 137) | async function viewFile(filePath) {
  function getReadableFileSize (line 166) | function getReadableFileSize(bytes) {

FILE: app/web/static/archive/logManager.js
  function updateLog (line 1) | function updateLog(logs) {
  function addLog (line 5) | function addLog(message, level) {
  function updateSystemLogs (line 9) | function updateSystemLogs(logs) {
  function addSystemLogsToChat (line 13) | function addSystemLogsToChat(logs) {

FILE: app/web/static/archive/main.js
  function sendMessage (line 109) | async function sendMessage() {

FILE: app/web/static/archive/new_chatManager.js
  class ChatManager (line 3) | class ChatManager {
    method constructor (line 4) | constructor(sendMessageCallback) {
    method init (line 12) | init() {
    method sendMessage (line 33) | sendMessage() {
    method addUserMessage (line 48) | addUserMessage(message) {
    method addAIMessage (line 55) | addAIMessage(message) {
    method addSystemMessage (line 62) | addSystemMessage(message) {
    method createMessageElement (line 69) | createMessageElement(className, content) {
    method formatMessage (line 85) | formatMessage(content) {
    method clearMessages (line 113) | clearMessages() {
    method scrollToBottom (line 118) | scrollToBottom() {
    method adjustTextareaHeight (line 123) | adjustTextareaHeight() {

FILE: app/web/static/archive/new_fileViewerManager.js
  class FileViewerManager (line 3) | class FileViewerManager {
    method constructor (line 4) | constructor() {
    method init (line 12) | init() {
    method showFile (line 23) | showFile(name, content) {
    method hideFileViewer (line 38) | hideFileViewer() {
    method applySyntaxHighlighting (line 43) | applySyntaxHighlighting(fileName) {
    method formatCode (line 82) | formatCode(code, language) {
    method formatHTML (line 105) | formatHTML(html) {

FILE: app/web/static/archive/new_main.js
  class App (line 11) | class App {
    method constructor (line 12) | constructor() {
    method init (line 28) | init() {
    method bindEvents (line 42) | bindEvents() {
    method handleSendMessage (line 67) | async handleSendMessage(message) {
    method handleWebSocketMessage (line 109) | handleWebSocketMessage(data) {
    method stopProcessing (line 152) | async stopProcessing() {
    method loadWorkspaceFiles (line 176) | async loadWorkspaceFiles() {
    method handleFileClick (line 192) | async handleFileClick(filePath) {

FILE: app/web/static/archive/new_thinkingManager.js
  class ThinkingManager (line 3) | class ThinkingManager {
    method constructor (line 4) | constructor() {
    method init (line 12) | init() {
    method addThinkingStep (line 18) | addThinkingStep(step) {
    method addThinkingSteps (line 35) | addThinkingSteps(steps) {
    method createStepElement (line 44) | createStepElement(step) {
    method getStepHeader (line 114) | getStepHeader(step) {
    method updateRecordCount (line 137) | updateRecordCount() {
    method clearThinking (line 144) | clearThinking() {
    method scrollToBottom (line 151) | scrollToBottom() {

FILE: app/web/static/archive/new_websocketManager.js
  class WebSocketManager (line 3) | class WebSocketManager {
    method constructor (line 4) | constructor(messageHandler) {
    method connect (line 13) | connect(sessionId) {
    method handleOpen (line 36) | handleOpen(event) {
    method handleMessage (line 43) | handleMessage(event) {
    method handleClose (line 56) | handleClose(event) {
    method handleError (line 64) | handleError(error) {
    method attemptReconnect (line 69) | attemptReconnect() {
    method send (line 88) | send(message) {
    method close (line 97) | close() {

FILE: app/web/static/archive/new_workspaceManager.js
  class WorkspaceManager (line 3) | class WorkspaceManager {
    method constructor (line 4) | constructor(fileClickCallback) {
    method init (line 12) | init() {
    method updateWorkspaces (line 18) | updateWorkspaces(workspaces) {
    method renderWorkspaces (line 26) | renderWorkspaces() {
    method createWorkspaceItem (line 56) | createWorkspaceItem(workspace) {
    method createFileItem (line 87) | createFileItem(file) {
    method getFileIcon (line 126) | getFileIcon(fileType) {
    method formatFileSize (line 148) | formatFileSize(size) {
    method formatDate (line 159) | formatDate(timestamp) {
    method startRefreshTimer (line 167) | startRefreshTimer() {
    method refreshWorkspaces (line 191) | async refreshWorkspaces() {

FILE: app/web/static/archive/terminalManager.js
  function initializeTerminal (line 1) | function initializeTerminal() {
  function updateTerminalOutput (line 32) | function updateTerminalOutput(outputs) {

FILE: app/web/static/archive/websocketManager.js
  function connectWebSocket (line 7) | function connectWebSocket(sessionId) {
  function chatContainsResult (line 68) | function chatContainsResult(result) {

FILE: app/web/static/connected_chatManager.js
  class ChatManager (line 3) | class ChatManager {
    method constructor (line 4) | constructor(sendMessageCallback) {
    method init (line 12) | init() {
    method sendMessage (line 33) | sendMessage() {
    method addUserMessage (line 48) | addUserMessage(message) {
    method addAIMessage (line 55) | addAIMessage(message) {
    method addSystemMessage (line 62) | addSystemMessage(message) {
    method createMessageElement (line 69) | createMessageElement(className, content) {
    method formatMessage (line 85) | formatMessage(content) {
    method clearMessages (line 113) | clearMessages() {
    method scrollToBottom (line 118) | scrollToBottom() {
    method adjustTextareaHeight (line 123) | adjustTextareaHeight() {

FILE: app/web/static/connected_fileViewerManager.js
  class FileViewerManager (line 3) | class FileViewerManager {
    method constructor (line 4) | constructor() {
    method init (line 12) | init() {
    method showFile (line 23) | showFile(name, content) {
    method hideFileViewer (line 39) | hideFileViewer() {
    method getFileType (line 44) | getFileType(fileName) {
    method applySyntaxHighlighting (line 50) | applySyntaxHighlighting(fileName) {
    method formatCode (line 89) | formatCode(code, language) {
    method formatHTML (line 112) | formatHTML(html) {

FILE: app/web/static/connected_interface.js
  class App (line 12) | class App {
    method constructor (line 13) | constructor() {
    method init (line 29) | init() {
    method bindEvents (line 48) | bindEvents() {
    method updateDynamicTexts (line 81) | updateDynamicTexts() {
    method handleSendMessage (line 106) | async handleSendMessage(message) {
    method handleWebSocketMessage (line 154) | handleWebSocketMessage(data) {
    method stopProcessing (line 209) | async stopProcessing() {
    method loadWorkspaceFiles (line 235) | async loadWorkspaceFiles() {
    method handleFileClick (line 251) | async handleFileClick(filePath) {

FILE: app/web/static/connected_thinkingManager.js
  class ThinkingManager (line 3) | class ThinkingManager {
    method constructor (line 4) | constructor() {
    method init (line 12) | init() {
    method addThinkingStep (line 18) | addThinkingStep(step) {
    method addThinkingSteps (line 40) | addThinkingSteps(steps) {
    method createStepElement (line 49) | createStepElement(step) {
    method getStepHeader (line 145) | getStepHeader(step) {
    method updateRecordCount (line 176) | updateRecordCount() {
    method clearThinking (line 183) | clearThinking() {
    method scrollToBottom (line 190) | scrollToBottom() {

FILE: app/web/static/connected_websocketManager.js
  class WebSocketManager (line 3) | class WebSocketManager {
    method constructor (line 4) | constructor(messageHandler) {
    method connect (line 14) | connect(sessionId) {
    method handleOpen (line 42) | handleOpen(event) {
    method handleMessage (line 50) | handleMessage(event) {
    method handleClose (line 65) | handleClose(event) {
    method handleError (line 73) | handleError(error) {
    method attemptReconnect (line 78) | attemptReconnect() {
    method send (line 104) | send(message) {
    method close (line 113) | close() {

FILE: app/web/static/connected_workspaceManager.js
  class WorkspaceManager (line 3) | class WorkspaceManager {
    method constructor (line 4) | constructor(fileClickCallback) {
    method init (line 14) | init() {
    method updateWorkspaces (line 20) | updateWorkspaces(workspaces) {
    method renderWorkspaces (line 28) | renderWorkspaces() {
    method createWorkspaceItem (line 58) | createWorkspaceItem(workspace) {
    method createFileItem (line 89) | createFileItem(file) {
    method getFileIcon (line 138) | getFileIcon(fileType) {
    method formatFileSize (line 160) | formatFileSize(size) {
    method formatDate (line 171) | formatDate(timestamp) {
    method startRefreshTimer (line 179) | startRefreshTimer() {
    method refreshWorkspaces (line 207) | async refreshWorkspaces() {

FILE: app/web/static/i18n.js
  constant SUPPORTED_LANGUAGES (line 4) | const SUPPORTED_LANGUAGES = {
  function getBrowserLanguage (line 118) | function getBrowserLanguage() {
  function setLanguage (line 125) | function setLanguage(lang) {
  function getCurrentLanguage (line 136) | function getCurrentLanguage() {
  function initLanguage (line 141) | function initLanguage() {
  function t (line 154) | function t(key, params = {}) {
  function updatePageTexts (line 170) | function updatePageTexts() {

FILE: app/web/thinking_tracker.py
  class ThinkingStep (line 13) | class ThinkingStep:
    method __init__ (line 16) | def __init__(
  class TaskStatus (line 25) | class TaskStatus(Enum):
  class ThinkingTracker (line 35) | class ThinkingTracker:
    method register_ws_send_callback (line 47) | def register_ws_send_callback(cls, session_id: str, callback: Any) -> ...
    method unregister_ws_send_callback (line 53) | def unregister_ws_send_callback(cls, session_id: str) -> None:
    method start_tracking (line 60) | def start_tracking(cls, session_id: str) -> None:
    method add_thinking_step (line 73) | def add_thinking_step(
    method add_communication (line 110) | def add_communication(cls, session_id: str, direction: str, content: s...
    method update_progress (line 125) | def update_progress(
    method add_conclusion (line 149) | def add_conclusion(
    method add_error (line 166) | def add_error(cls, session_id: str, message: str) -> None:
    method mark_stopped (line 175) | def mark_stopped(cls, session_id: str) -> None:
    method get_thinking_steps (line 182) | def get_thinking_steps(cls, session_id: str, start_index: int = 0) -> ...
    method get_progress (line 200) | def get_progress(cls, session_id: str) -> Dict[str, Any]:
    method get_status (line 213) | def get_status(cls, session_id: str) -> str:
    method clear_session (line 221) | def clear_session(cls, session_id: str) -> None:
    method add_log_entry (line 234) | def add_log_entry(cls, session_id: str, entry: Dict) -> None:
    method _notify_ws_log_update (line 273) | def _notify_ws_log_update(cls, session_id: str, log_entry: Dict):
    method _update_progress_from_log (line 294) | def _update_progress_from_log(cls, session_id: str, message: str):
    method add_log_entries (line 319) | def add_log_entries(cls, session_id: str, entries: List[Dict]) -> None:
    method get_logs (line 325) | def get_logs(cls, session_id: str, start_index: int = 0) -> List[Dict]:
  function generate_thinking_steps (line 371) | def generate_thinking_steps(

FILE: main.py
  function run_cli (line 10) | async def run_cli():
  function run_web (line 30) | async def run_web():
  function main (line 54) | def main():

FILE: run_flow.py
  function run_flow (line 10) | async def run_flow():

FILE: tools/debug_log_monitor.py
  class DebugEventHandler (line 32) | class DebugEventHandler(FileSystemEventHandler):
    method __init__ (line 35) | def __init__(self, log_file_path):
    method on_modified (line 39) | def on_modified(self, event):
  function test_log_monitor (line 54) | def test_log_monitor(job_id, log_dir=None):

FILE: web_run.py
  function check_websocket_dependencies (line 10) | def check_websocket_dependencies():
  function ensure_directories (line 17) | def ensure_directories():