liuup/claude-code-analysis

Features

• Source Code Analysis - Provides a static reading of a terminal coding assistant's TypeScript source, documenting its architecture, startup path, tool pipeline, memory, and permission design.
• Hybrid Short-and-Long Term Memory - Examines layered file-based long-term and session memory, conversation compaction, and relevance-based recall that keep sessions within context limits.
• Agent Conversation Loops - Drives interactive, headless, sub-agent, background, and remote sessions through one streaming loop that calls the model and runs tools.
• Sub-Agent Task Delegation - Supports delegated sub-agents, background workers, teammates, and swarms so larger coding tasks can be split and run in parallel.
• Agent Session Memory - Reviews layered file-based memory, session summaries, and conversation compaction that keep long-running agent sessions within token limits.
• Conversation History Management - Summarizes long conversations with a text-only, no-tools prompt built from a cache-safe prefix to shrink context while keeping essential state.
• Conversation Compaction - Summarizes long sessions near the token limit, strips images and large attachments, retries on overflow, and restores tool declarations afterward.
• Shared Agent Execution Cores - Routes queries, sub-agents, tool calls, and permission checks through one shared execution core so every entry point follows identical control flow.
• Tool-Calling Agent Loops - Streams model output, runs requested tool calls, feeds results back until the model stops asking, and batches concurrency-safe calls in parallel.
• Agent Memory Persistence - Stores agent memory as plain, layered files that users can inspect and control, carrying knowledge across sessions.
• Markdown Memory Stores - Stores long-term memory as plain markdown files under scoped directories with a size-capped index so details load on demand and users can inspect everything.
• Agent Source Code Reports - Dissects a terminal coding assistant's source to explain its shared execution core, startup path, tool pipeline, sub-agents, and UI layers.
• AI Agent Architecture Study Guides - Documents the architecture and startup path of a local coding agent from a static reading of its TypeScript source.
• Sandbox Auditing - Evaluates how permission checks, OS-level sandbox isolation, secret scanning, and telemetry privacy controls limit what the agent can do to a machine.
• OS-Level Sandboxing - Runs shell commands inside kernel-level isolation with file and network allowlists, gated by validation, hooks, and allow, deny, or ask decisions.
• AI Agent Permissions - Reviews the permission pipeline with hooks and allow, deny, or ask decisions, alongside sandbox isolation and secret scanning, that constrain the agent.
• Tool Call Permission Pipelines - Covers the staged pipeline each tool call passes through: hooks that modify input, then allow, deny or ask decisions with rejection messages.
• Unified Execution Entry Points - Routes queries, sub-agents, tools, and permission checks through one shared execution core so every entry point follows the same control flow and safety rules.
• Agent Action Confirmations - Prompts the user for approval before the agent runs any operation not explicitly allowed, so a human can refuse risky actions.
• Agent Tooling Extensions - Explains how skills, hooks, built-in tools, and external MCP servers extend the agent, including discovery, permissioning, and runtime execution.
• Agent Memory Architectures - Explains how an agent stores information across multiple memory layers and compresses long sessions, based on a static reading of its source.
• Agent Memory Stores - Explains layered, file-based agent memory and how long sessions are compacted to stay within the context limit.
• Coding Agent Orchestrators - Documents how a coding agent coordinates delegated sub-agents, background workers, teammates, and swarms through shared task lists and file-based mailboxes.
• Tool Execution Approvals - Maps each tool type to its own approval dialog with a generic fallback, so users confirm file edits, shell commands, and web fetches through tailored prompts.
• Background Memory Extraction - Runs a restricted background agent that reads recent messages with a limited tool set and writes durable memories without slowing the main session.
• Coding Agent Competitor Comparisons - Contrasts the terminal coding agent with rival assistants, checking claims against source evidence and public information to show what sets it apart.
• Collaborative Coding Agent Teams - Provides a dedicated dialog for viewing swarm and teammate agents as they work together on a shared task.
• Memory Indexes - Keeps long-term notes as separate markdown files behind a short, size-capped index that is always loaded so details are read on demand.
• Conversation State Persistence - Loads a saved session by recency, ID or file path, repairs broken message chains, and restores state to continue the conversation.
• Automatic Context Compaction - Triggers conversation summarization automatically when token usage nears the context limit, with a safety buffer and a stop after repeated failures.
• Mailbox-Based Agent Communication - Teammate agents exchange messages through lock-protected file inboxes and shared task lists, with in-process or terminal-pane backends for spawning workers.
• Early Tool Execution - Describes starting concurrency-safe tools as soon as their inputs parse mid-stream, tracking execution state, and cancelling sibling tools on failure.
• Memory File Injection - Reads a size-capped memory index from a memory directory and adds it to the model prompt so context carries across sessions.
• Multi-Agent Orchestration - Describes how a single agent scales into delegated sub-agents, background workers, teammates, and swarms sharing tasks, messages, and permissions.
• Subagent Delegation - Spawns a child agent session that inherits part of the context and tools, then returns its result to the main thread.
• Parallel Tool Call Batching - Groups consecutive concurrency-safe tool calls to run in parallel and isolates state-changing calls into sequential steps to preserve write order.
• Post-Compaction State Restoration - Re-injects recently read files, active plans, active skills, and tool declarations after summarizing so the agent continues with needed context.
• Prompt Assembly Systems - Builds final model instructions from separate prioritized parts, with a cacheable stable prefix split from session-specific content, instead of one monolithic prompt.
• Teammate Mailboxes - Provides file-based teammate inboxes with lock-protected writes so multiple agents can send and read messages concurrently without corrupting data.
• Memory File Management - Examines how an agent stores memory as layered, file-based records that users can inspect and review rather than opaque hidden state.
• Append-Only Persistence - Persists each conversation entry by appending to a per-session JSONL file so history survives crashes and can be replayed.
• Model-Selected Memory Recall - Scans memory file headers and has a lightweight model choose up to five relevant files instead of loading every memory into the prompt.
• Conversation Context Caches - Summarizes long conversations near the token limit by reusing a shared prompt-cache prefix, then restores key files, plans, and tool declarations.
• MCP and Agent Skills - Explains how skills, tool calls, and external MCP servers extend the agent and how each one runs at runtime.
• Sandboxed Shell Executions - Describes wrapping model-generated shell commands in an OS-level sandbox on supported platforms, restricting file and network access to policy.
• Agent Kernel Virtualization - Explains how query handling, sub-agents, tools, and permission checks share one common core so every action follows the same control path.
• Agent Security Auditing - Examines what user information a coding agent collects and sends out, the risks involved, and the safeguards that reduce them.
• Sandbox Permissions - Analyzes how sandbox isolation and tool permission controls reduce the risk of unsafe local operations by an agent.
• Sandbox Permission Policies - Converts permission and sandbox settings into one runtime configuration of allowed and denied read, write, and network targets with built-in defaults and protected paths.
• Agent Skill Extenders - Documents how skills, tool calls, and external MCP servers extend an agent's abilities, including how each is built and behaves at runtime.
• Local-First Remote Extension - Runs primarily on the user's machine while allowing optional extension to remote sessions, bridges, and swarms when more reach or capacity is needed.
• Terminal UI Components - Supplies a self-built set of terminal components such as dialogs, tabs, themes, selectors, wizards, lists and spinners so every screen looks consistent.

Star history