Output of Revelation CLI tool of the Gideon CLI codebase.

summary.md

src/agent/agent.rs

        // ENUMS:
        enum AgentAction { ReadFile(path: String), WriteFile(path: String, content: String), Finish(message: String), Current(message: String) }
        enum AgentMode { Chat, Tool }
        enum AgentObservation { ReadFile(path: String, content: String), WriteFile(path: String, success: bool), Current(message: String) }
        enum AgentStatus { Done, Waiting, Thinking, Error(_0: String) }

        // FUNCTIONS:
        fn build_action(
            prompt: &str
        ) -> anyhow::Result<LlmAction>
        fn build_prompt(
            ctx: &AgentContext
        ) -> String
        fn format_history(
            history: &[AgentObservation]
        ) -> String
        fn format_workspace(
            workspace: &WorkspaceContext
        ) -> String
        fn ollama_generate(
            prompt: &str,
            system: Option<&str>,
            json: bool
        ) -> anyhow::Result<String>
        fn prompt_chat(
            ctx: &AgentContext
        ) -> anyhow::Result<String>
        fn prompt_ollama_json(
            prompt: &str
        ) -> anyhow::Result<T>

        // STRUCTS:
        struct Agent
            // PROPERTIES:
            id: String, tools: AgentTools, workspace: Arc<WorkspaceContext>

            // METHODS:
            fn new() -> Self
            fn default() -> Self
            fn run_agent_loop(
                self,
                task: Task,
                event_tx: UnboundedSender<RuntimeEvent>
            ) -> anyhow::Result<TaskResult>
            fn decide_mode(
                self,
                ctx: &AgentContext
            ) -> anyhow::Result<AgentMode>
            fn decide_next_action(
                self,
                ctx: &AgentContext
            ) -> anyhow::Result<AgentAction>
        struct AgentBus
            // PROPERTIES:
            tx: UnboundedSender<AgentEvent>, event_tx: UnboundedSender<RuntimeEvent>
        struct AgentContext
            // PROPERTIES:
            prompt: String, workspace: WorkspaceContext, history: Vec<AgentObservation>, artifacts: Vec<Artifact>, logs: Vec<String>, spawned_tasks: Vec<Task>

            // METHODS:
            fn new(
                user_prompt: String
            ) -> Self
        struct LlmAction
            // PROPERTIES:
            action: String, path: Option<String>, content: Option<String>, message: Option<String>
        struct LlmMode
            // PROPERTIES:
            mode: String

src/agent/event.rs

        // ENUMS:
        enum AgentEvent { NewTask(task: Task), Thinking(task: Task), Working(task: Task, message: String), Finished(result: TaskResult), TaskEvent(task: Task, event: TaskEvent) }
        enum RuntimeEvent { System(_0: SystemEvent), Agent(_0: AgentEvent) }
        enum TaskEvent { Thinking, Started, Log(_0: String), Working(_0: String), Finished(_0: String), Error(_0: String) }

src/agent/prompt.rs

        // FUNCTIONS:
        fn build_sys_action(
            template: &str,
            args: &[&str]
        ) -> String
        fn build_sys_prompt(
            template: &str,
            prompt: &str
        ) -> String

src/agent/runtime.rs

        // STRUCTS:
        struct AgentRegistry
        struct AgentRuntime
            // PROPERTIES:
            cmd_rx: UnboundedReceiver<AgentEvent>, event_tx: UnboundedSender<RuntimeEvent>, registry: AgentRegistry

            // METHODS:
            fn spawn_agent(
                self,
                task: Task
            )

src/agent/system.rs

        // ENUMS:
        enum SystemEvent { SpawnAgent(agent_id: String), TaskAdd(task_id: String), TaskSpawned(task: Task), TaskQueued(task_id: String), TaskStarted(task_id: String), TaskCompleted(result: TaskResult), TaskFailed(task_id: String, error: String), AgentSpawned(agent_id: String), AgentFinished(agent_id: String), TaskGroupFinished(group_id: String), AllIdle }

        // FUNCTIONS:
        fn handle_event(
            event: AgentEvent,
            runtime: &AgentRuntime
        )
        fn new_agent_system() -> (AgentBus, AgentRuntime, UnboundedReceiver<RuntimeEvent>)
        fn run_agent_manager(
            runtime: AgentRuntime
        )

src/agent/task.rs

        // ENUMS:
        enum Artifact { FileRead(path: String, content: String), FileWrite(path: String), Observation(_0: String), ToolOutput(_0: String) }
        enum TaskStatus { Completed, Failed(_0: String), Interrupted }

        // STRUCTS:
        struct Task
            // PROPERTIES:
            id: String, prompt: String
        struct TaskResult
            // PROPERTIES:
            task_id: String, status: TaskStatus, summary: Option<String>, artifacts: Vec<Artifact>, logs: Vec<String>, spawned_tasks: Vec<Task>, chat: Option<String>

src/agent/tool.rs

        // STRUCTS:
        struct AgentTools
            // PROPERTIES:
            fs: FileSystemTool, mcp: McpClient
        struct FileInfo
            // PROPERTIES:
            inode: String, content: String, path: String, name: String, extension: Option<String>, size: u64, language: Option<String>, is_directory: bool, modified_at: Option<SystemTime>
        struct FileSystemTool
            // PROPERTIES:
            vfs: Vfs

            // METHODS:
            fn search(
                self,
                query: &str
            ) -> anyhow::Result<Vec<FileInfo>>
            fn read(
                self,
                path: &str
            ) -> anyhow::Result<String>
            fn write(
                self,
                path: &str,
                content: &str
            ) -> anyhow::Result<()>
            fn create(
                self,
                path: &str,
                content: &str
            ) -> anyhow::Result<()>
        struct Vfs
            // METHODS:
            fn new() -> Self
            fn search_files(
                self,
                query: &str
            ) -> Result<Vec<FileInfo>, Error>
            fn create_file(
                self,
                path: &str,
                content: &str
            ) -> Result<(), Error>
            fn read_file(
                self,
                path: &str
            ) -> Result<String, Error>
            fn write_file(
                self,
                path: &str,
                content: &str
            ) -> Result<(), Error>

src/agent/workspace.rs

        // STRUCTS:
        struct WorkspaceContext
            // PROPERTIES:
            files: Vec<FileInfo>

            // METHODS:
            fn new(
                files: Vec<FileInfo>
            ) -> Self
            fn load() -> anyhow::Result<Self>

src/app.rs

    // ENUMS:
    enum AppMode { Normal, Command, Editing, LeaderPending }
    enum Role {  }

    // STRUCTS:
    struct App
        // PROPERTIES:
        is_initialized: bool, offset: i32, ai_list_state: ListState, user_list_state: ListState, ai_area: Rect, user_area: Rect, should_exit: Arc<AtomicBool>, cursor_visible: bool, last_cursor_toggle: std::time::Instant, tabs: Vec<String>, active_tab: usize, key_config: KeyConfig, input_buffer: String, history: Vec<String>, user_history: Vec<String>, ai_history: Vec<String>, logger: Logger, logs: Vec<String>, messages: Vec<Message>, mode: AppMode, agent_status: AgentStatus, spinner_index: usize, agent_bus: AgentBus, rx: UnboundedReceiver<RuntimeEvent>

        // METHODS:
        fn new(
            should_exit: Arc<AtomicBool>,
            agent_bus: AgentBus,
            rx: UnboundedReceiver<RuntimeEvent>
        ) -> Self
        fn next_tab(self)
        fn prev_tab(self)
        fn history_mode(self)
        fn handle_exit(self)
        fn handle_command(
            self,
            input: &str
        )
        fn handle_submit(self)
        fn handle_events(self) -> anyhow::Result<bool>
        fn scroll_all_to_bottom(
            self,
            width: u16
        )
        fn scroll_list(
            self,
            mouse_pos: (u16, u16),
            delta: i32
        )
        fn tick(self)
        fn reduce(
            self,
            event: RuntimeEvent
        )
        fn reduce_agent_event(
            self,
            event: AgentEvent
        )
        fn reduce_system_event(
            self,
            event: SystemEvent
        )
        fn apply_cursor_blink(self)
        fn apply_scroll(
            state: &mut ListState,
            delta: i32
        )
        fn apply_task_event(
            self,
            task: Task,
            event: TaskEvent
        )
        fn apply_task_finished(
            self,
            result: TaskResult
        )
        fn get_ui_data(self) -> UiState<'_>
    struct KeyConfig
        // PROPERTIES:
        next_tab: (KeyCode, KeyModifiers), prev_tab: (KeyCode, KeyModifiers)

        // METHODS:
        fn default() -> Self
    struct Message
        // PROPERTIES:
        role: Role, content: String

src/backend/server.rs

        // STRUCTS:
        struct CodeReviewArgs
            // PROPERTIES:
            language: String, focus_areas: Option<Vec<String>>
        struct MyServer
            // METHODS:
            fn hello(self) -> String
            fn get_info(self) -> ServerInfo
            fn add(
                self,
                _: Parameters<AddVars>
            ) -> String
            fn greeting(self) -> Vec<PromptMessage>
            fn code_review(
                self,
                _: Parameters<CodeReviewArgs>
            ) -> Result<GetPromptResult, McpError>

src/backend/tool.rs

        // STRUCTS:
        struct AddParams
            // PROPERTIES:
            a: i32, b: i32
        struct AddVars
            // PROPERTIES:
            a: i32, b: i32
        struct Calculator
            // METHODS:
            fn add(
                self,
                _: Parameters<AddParams>
            ) -> String
        struct TempTool
            // METHODS:
            fn add(
                self,
                _: Parameters<AddVars>
            ) -> String

src/backend/tool_registry.rs

        // FUNCTIONS:
        fn load_tools(
            root: &Path
        ) -> ToolRegistry
        fn parse_tool(
            content: &str,
            path: &Path
        ) -> Option<ToolDefinition>

        // STRUCTS:
        struct ToolDefinition
            // PROPERTIES:
            name: String, route: String, file: String
        struct ToolRegistry
            // PROPERTIES:
            tools: HashMap<String, ToolDefinition>

src/cli_process.rs

    // FUNCTIONS:
    fn run_my_ui() -> Result<(), Box<dyn std::error::Error>>

src/context.rs

    // FUNCTIONS:
    fn bootstrap_runtime(
        root: &Path
    )
    fn extract_ai_title(
        content: &str
    ) -> String
    fn load_crate_ai_context(
        root: &Path,
        crate_path: &Path
    )
    fn load_root_client_context(
        root: &Path
    )
    fn rel(
        root: &Path,
        path: &Path
    ) -> String
    fn resolve_active_crates(
        _root: &Path,
        _ctx: &Context
    ) -> Vec<String>

src/logger.rs

    // STRUCTS:
    struct Log
        // PROPERTIES:
        session: u64, role: String, content: String, time: u64
    struct Logger
        // PROPERTIES:
        session_id: u64

        // METHODS:
        fn new(
            session_id: u64
        ) -> Self
        fn log_to_file(
            self,
            role: &str,
            content: &str
        ) -> io::Result<()>
        fn load_history(self) -> (Vec<String>, Vec<String>)

src/main.rs

    // FUNCTIONS:
    fn main() -> anyhow::Result<()>

src/poc.rs

    // FUNCTIONS:
    fn format_prompt_messages(
        msgs: Vec<rmcp::model::PromptMessage>
    ) -> String

    // STRUCTS:
    struct McpClient
        // PROPERTIES:
        server: MyServer

        // METHODS:
        fn hello(self) -> anyhow::Result<String>
        fn greeting(self) -> anyhow::Result<Vec<PromptMessage>>
        fn code_review(
            self,
            args: CodeReviewArgs
        ) -> anyhow::Result<String>

src/reg_command.rs

    // ENUMS:
    enum Command { Start, StartServer, StartClient }

    // FUNCTIONS:
    fn parse() -> Cli

    // STRUCTS:
    struct Cli
        // PROPERTIES:
        verbose: bool, command: Command

src/router.rs

    // FUNCTIONS:
    fn execute(
        cli: Cli,
        ctx: Context
    )

src/runner.rs

    // STRUCTS:
    struct Runner
        // PROPERTIES:
        terminal: Terminal<CrosstermBackend<Stdout>>, _guard: TerminalGuard, should_exit: Arc<AtomicBool>

        // METHODS:
        fn default() -> Self
        fn new() -> Self
        fn run(
            self,
            app: App
        ) -> io::Result<()>
    struct TerminalGuard
        // METHODS:
        fn drop(self)

src/runtime.rs

    // STRUCTS:
    struct GideonCLIProcess
        // METHODS:
        fn run(
            self,
            ctx: &Context
        )
        fn check1(
            self,
            ctx: &Context
        )
        fn check2(
            self,
            _ctx: &Context
        )
        fn check3(
            self,
            _ctx: &Context
        )
        fn check4(
            self,
            _ctx: &Context
        )

src/ui.rs

    // FUNCTIONS:
    fn create_hint_widget(
        state: UiState<'_>
    ) -> Paragraph<'_>
    fn create_input_widget(
        state: UiState
    ) -> Paragraph<'a>
    fn render_conversation(
        f: &mut Frame,
        app: &mut App,
        area: Rect
    )
    fn render_history(
        f: &mut Frame,
        app: &mut App,
        area: Rect
    )
    fn render_tabs(
        f: &mut Frame,
        state: &UiState,
        area: Rect
    )
    fn render_ui(
        f: &mut Frame,
        app: &mut App
    )

    // STRUCTS:
    struct UiState
        // PROPERTIES:
        active_tab: usize, agent_status: &'a AgentStatus, ai_history: &'a [String], cursor_visible: bool, history: &'a [String], input_buffer: &'a str, logs: &'a [String], messages: &'a [Message], mode: &'a AppMode, spinner_index: usize, tabs: &'a [String], user_history: &'a [String]

EMPTY FILES

   ...