README
¶
The coding agent that remembers your repo.
Memcode
Most coding agents start every session from zero. memcode keeps a persistent model of your repo in .memcode: the subsystems, what you worked on last week, which approaches failed and why, and the preferences you have corrected it on. The longer you use it, the less you have to explain.
One Go binary, two ways to run it. Code is the interactive agent in your terminal. Agents is the same binary as a self-hosted gateway, answering on the chat surfaces you already use — and running agents you have given a standing objective and permission to work on it unattended. Both run against whatever models you have: your own API keys, a local endpoint like Ollama, or a hosted memcode account.
Screenshots
Code
Run memcode in a repo and you get a full terminal coding agent.
It remembers. Ask it to pick up where you left off last week and it can. It knows your repo's layout, what has been tried before, and the preferences you have corrected it on. Memory lives in .memcode, so it travels with the repo and your whole team benefits.
Pick a model or let it decide. Out of the box it uses cheap models for routine work and strong models when the task is hard or risky. Pin any model with /model when you want control.
Reads the room. When you are correcting it, it slows down, asks before acting, and stops cutting corners. When things are calm it stays out of your way.
Plan first when it matters. /plan researches your codebase, drafts an approach, and gets a second model's review before you approve it. Execution then sticks to what you approved.
Work in parallel. Hand off side quests to sub-agents and background jobs, keep working, and check on them with /jobs and /tail.
A terminal UI that keeps up. Multiline editing, slash-command autocomplete, streaming output, interrupt and redirect mid-turn, themes, and a live context meter.
Everything you'd expect. MCP servers, Agent Skills, hooks, code navigation and diagnostics, vision and PDF input, instructions from MEMCODE.md, AGENTS.md, or CLAUDE.md, and automatic updates.
Agents
Message your agent from wherever you already are. It runs your task and replies in the same conversation. Fix a bug from Telegram on the train, ask for a status update over SMS, forward an email and get it handled.
Twelve channels. Telegram, Discord, Slack, GitHub, WhatsApp, Email, Signal, Matrix, Mattermost, Microsoft Teams, Google Chat, and SMS. memcode gateway setup walks you through connecting each one.
Voice. Send a voice note instead of typing. Replies can come back as voice too, per channel and off by default.
You decide who gets in. Unknown senders have to pair first: they get a code, you approve it. Allow-lists per channel on top of that.
Coming from Hermes or OpenClaw? memcode hermes migrate or memcode claw migrate brings over your channels, API keys, skills, and long-term memory in one command.
Agents that run on their own
An agent can be given a durable objective and permission to run
autonomously — then it works on that objective on a schedule, with nobody
watching. It is the same agent either way; autonomy is a setting, not a
separate kind. You set it up by talking to memcode admin.
Objective and autonomy are separate grants on purpose: an agent may hold a goal you only ever work on together, and an agent may run unattended on a schedule with no standing objective at all. The second case is why this matters — an unattended run is policy-gated (authority approved in advance, by hash), journals every consequential action, confines file access to explicit grants, and can suspend durably to ask you something rather than guessing. Plain scheduled agents never had any of that.
It can also delegate real work to a scoped worker with browser, MCP, shell and
filesystem access, and drive your own signed-in Chrome rather than a
logged-out profile. See docs/autonomous-agents.md.
Install
curl -fsSL https://memcode.ai/install.sh | sh
Or with Go:
go install github.com/memcode-ai/memcode@latest
Or build from source:
git clone https://github.com/memcode-ai/memcode
cd memcode && go build -o memcode .
Then run memcode in a repo.
Use any model
MEMCODE_ENDPOINT_URL=http://localhost:11434/v1 memcode # Ollama, local
MEMCODE_ENDPOINT_URL=https://api.openai.com/v1 memcode # your OpenAI key (OPENAI_API_KEY)
MEMCODE_ENDPOINT_URL=https://api.anthropic.com memcode # your Anthropic key (ANTHROPIC_API_KEY)
Your provider API keys are picked up automatically from the standard environment variables.
With a memcode account you get one balance across every vendor, a key vault for BYOK, and hosted web search:
memcode login
Documentation
The user manual lives at memcode.ai/docs:
- Code: commands, model routing, memory, plan mode, MCP, skills, custom instructions, configuration.
- Agents: per-channel setup guides for every gateway channel, pairing, and voice.
Internals and reference docs live in this repo:
- ROUTING.md: how Automatic mode picks models.
- HOOKS.md: the hook surface.
- COMPACTION.md: context compaction.
- docs/gateway/README.md: gateway operations and channel secrets.
- protocol/PROTOCOL.md: the wire protocol every backend speaks.
Architecture
The CLI is the agent: all model selection, escalation, and recovery run client-side; every backend is a plain serving surface speaking one OpenAI-compatible wire. Point memcode at your own API keys, a local endpoint like Ollama, or a hosted memcode.ai account.
License
MIT. See LICENSE.
Documentation
¶
Overview ¶
Command memcode is an agentic coding CLI that builds and maintains a persistent model of your codebase for better context and memory.
Source Files
Directories
¶
| Path | Synopsis |
|---|---|
|
internal
|
|
|
agent
Package agent holds the agent runtime and its supporting subsystems.
|
Package agent holds the agent runtime and its supporting subsystems. |
|
agent/acceptance
Package acceptance closes memcode's interaction loop by reading the room AFTER the work: did the agent's changes survive contact with the human? Git is the objective evidence most agents never look at — a commit is the strongest "yes", a revert the strongest "no", a manual edit a "close, but".
|
Package acceptance closes memcode's interaction loop by reading the room AFTER the work: did the agent's changes survive contact with the human? Git is the objective evidence most agents never look at — a commit is the strongest "yes", a revert the strongest "no", a manual edit a "close, but". |
|
agent/autonomy
Package personal implements the domain-general durable state and runtime primitives for autonomous agents.
|
Package personal implements the domain-general durable state and runtime primitives for autonomous agents. |
|
agent/compaction
Package compaction is the PURE, testable core of in-session context compaction: deciding WHERE to cut a running conversation and rendering the cut-off part into a plain transcript for an Anthropic summarizer.
|
Package compaction is the PURE, testable core of in-session context compaction: deciding WHERE to cut a running conversation and rendering the cut-off part into a plain transcript for an Anthropic summarizer. |
|
agent/continuation
Package continuation is the ONE durable suspend/resume mechanism for an agent turn that stops mid-flight to wait for a human.
|
Package continuation is the ONE durable suspend/resume mechanism for an agent turn that stops mid-flight to wait for a human. |
|
agent/edit
Package edit implements the safe edit transaction used by the agent: read → verify the anchor is unique → patch → re-read → show the diff.
|
Package edit implements the safe edit transaction used by the agent: read → verify the anchor is unique → patch → re-read → show the diff. |
|
agent/focus
Package focus is memcode's COGNITIVE / attention axis — what the human is attending to — the complement of package room (the emotional / interaction axis).
|
Package focus is memcode's COGNITIVE / attention axis — what the human is attending to — the complement of package room (the emotional / interaction axis). |
|
agent/gitporcelain
Package gitporcelain holds small shared helpers for parsing git's porcelain output.
|
Package gitporcelain holds small shared helpers for parsing git's porcelain output. |
|
agent/input
Package input routes a raw interactive line — coalesce / steer / queue / interrupt — so the agent collaborates the way people actually type instead of treating every Enter as a new task.
|
Package input routes a raw interactive line — coalesce / steer / queue / interrupt — so the agent collaborates the way people actually type instead of treating every Enter as a new task. |
|
agent/introspect
Package introspect is memcode's read-only intelligence surface — the commands the agent reaches through the single `memcode` tool (overview, map, context, why, recall, next, recap, memories, sources, session, acceptance, doctor, jobs) and the TUI's "orient me" slash shortcuts, plus the two ambiguity classifiers (plan-intent, follow-up steer-vs-queue) and the personality greeting.
|
Package introspect is memcode's read-only intelligence surface — the commands the agent reaches through the single `memcode` tool (overview, map, context, why, recall, next, recap, memories, sources, session, acceptance, doctor, jobs) and the TUI's "orient me" slash shortcuts, plus the two ambiguity classifiers (plan-intent, follow-up steer-vs-queue) and the personality greeting. |
|
agent/jobs
Package jobs is memcode's background-job layer — the async extension of the shell lanes.
|
Package jobs is memcode's background-job layer — the async extension of the shell lanes. |
|
agent/ledger
Package ledger holds the cost-accounting readout types and pure aggregation logic carved off the agent Session god-object.
|
Package ledger holds the cost-accounting readout types and pure aggregation logic carved off the agent Session god-object. |
|
agent/mood
Package mood detects interaction *friction* — how a user is engaging with the agent — from their terminal input, using a deterministic, dependency-free lexical heuristic.
|
Package mood detects interaction *friction* — how a user is engaging with the agent — from their terminal input, using a deterministic, dependency-free lexical heuristic. |
|
agent/permissions
Package permissions classifies the risk of an action and decides — given the active mode — whether it may run, needs approval, or is blocked.
|
Package permissions classifies the risk of an action and decides — given the active mode — whether it may run, needs approval, or is blocked. |
|
agent/plan
Package plan holds the plan-mode lifecycle as a real state machine.
|
Package plan holds the plan-mode lifecycle as a real state machine. |
|
agent/protocol
Package protocol drives an interactive memcode session over the stream-json control protocol (newline-delimited JSON on stdio) — the machine-facing twin of the TUI.
|
Package protocol drives an interactive memcode session over the stream-json control protocol (newline-delimited JSON on stdio) — the machine-facing twin of the TUI. |
|
agent/room
Package room reads the *room* — the current state of the human↔agent interaction — and turns it into a runtime policy.
|
Package room reads the *room* — the current state of the human↔agent interaction — and turns it into a runtime policy. |
|
agent/runtime
Package runtime: this file is the thin seam to the read-only intelligence Engine (internal/agent/introspect).
|
Package runtime: this file is the thin seam to the read-only intelligence Engine (internal/agent/introspect). |
|
agent/secrets
Package secrets keeps the agent from leaking credentials.
|
Package secrets keeps the agent from leaking credentials. |
|
agent/tools
Admin toolset — the `memcode admin` session's ONLY tools (plus ask_user).
|
Admin toolset — the `memcode admin` session's ONLY tools (plus ask_user). |
|
artifacts
Package artifacts is the CLI's client for memcode.ai's artifact hosting: the agent publishes a self-contained HTML page and gets a stable, unguessable URL (memcode.ai/code/artifact/<id>) back.
|
Package artifacts is the CLI's client for memcode.ai's artifact hosting: the agent publishes a self-contained HTML page and gets a stable, unguessable URL (memcode.ai/code/artifact/<id>) back. |
|
assemble
Package assemble is the context compiler.
|
Package assemble is the context compiler. |
|
atomicfile
Package atomicfile writes a file so a crash mid-write never leaves it truncated: content goes to a temp file in the SAME directory, is fsync'd, then renamed over the target (an atomic operation on POSIX).
|
Package atomicfile writes a file so a crash mid-write never leaves it truncated: content goes to a temp file in the SAME directory, is fsync'd, then renamed over the target (an atomic operation on POSIX). |
|
authflow
Package authflow is the browser login flow shared by `memcode login` (cobra) and the TUI's /login slash command.
|
Package authflow is the browser login flow shared by `memcode login` (cobra) and the TUI's /login slash command. |
|
banner
Package banner renders memcode's startup wordmark banners.
|
Package banner renders memcode's startup wordmark banners. |
|
browser
Package browser drives a long-lived Chrome instance via the Chrome DevTools Protocol (chromedp) so the agent can fully interact with web pages as tools — the same dispatch as read_file/bash.
|
Package browser drives a long-lived Chrome instance via the Chrome DevTools Protocol (chromedp) so the agent can fully interact with web pages as tools — the same dispatch as read_file/bash. |
|
browserrender
Package browserrender is memcode's OPTIONAL local browser-render capability: the last-resort fetch tier for JavaScript-rendered pages that raw GET and the server-side web_fetch (both no-JS) cannot read.
|
Package browserrender is memcode's OPTIONAL local browser-render capability: the last-resort fetch tier for JavaScript-rendered pages that raw GET and the server-side web_fetch (both no-JS) cannot read. |
|
buildinfo
Package buildinfo reports build-time metadata.
|
Package buildinfo reports build-time metadata. |
|
channels
Package channels defines the gateway's channel-adapter contract: a normalized inbound message and the interface each external surface (Telegram, Discord, Slack, …) implements.
|
Package channels defines the gateway's channel-adapter contract: a normalized inbound message and the interface each external surface (Telegram, Discord, Slack, …) implements. |
|
channels/discord
Package discord is the gateway's Discord channel adapter.
|
Package discord is the gateway's Discord channel adapter. |
|
channels/email
Package email is the gateway's email channel: a mailbox the agent answers.
|
Package email is the gateway's email channel: a mailbox the agent answers. |
|
channels/matrix
Package matrix is the gateway's Matrix channel adapter.
|
Package matrix is the gateway's Matrix channel adapter. |
|
channels/mattermost
Package mattermost is the gateway's Mattermost channel adapter, aimed at self-hosted servers.
|
Package mattermost is the gateway's Mattermost channel adapter, aimed at self-hosted servers. |
|
channels/msteams
Package msteams is the gateway's Microsoft Teams adapter over the Bot Framework: an Azure Bot registration POSTs activities to our webhook, and replies go back to the activity's serviceUrl as REST calls authenticated with an Azure AD client-credentials token.
|
Package msteams is the gateway's Microsoft Teams adapter over the Bot Framework: an Azure Bot registration POSTs activities to our webhook, and replies go back to the activity's serviceUrl as REST calls authenticated with an Azure AD client-credentials token. |
|
channels/signal
Package signal is the gateway's Signal channel adapter.
|
Package signal is the gateway's Signal channel adapter. |
|
channels/slack
Package slack is the gateway's Slack channel adapter.
|
Package slack is the gateway's Slack channel adapter. |
|
channels/telegram
Package telegram is the gateway's Telegram channel adapter.
|
Package telegram is the gateway's Telegram channel adapter. |
|
checkpoint
Package checkpoint stores per-turn PRE-IMAGES of files the agent edits, so a bad run can be rewound without touching git: before edit_file mutates a file, its current bytes (or its absence) are snapshotted under .memcode/checkpoints/<session>/<seq>/.
|
Package checkpoint stores per-turn PRE-IMAGES of files the agent edits, so a bad run can be rewound without touching git: before edit_file mutates a file, its current bytes (or its absence) are snapshotted under .memcode/checkpoints/<session>/<seq>/. |
|
cloudclient
Package cloudclient is the CLI's HTTP client for the memcode gateway's SIDE-CHANNEL surfaces: /v1/advisor, /v1/websearch, /v1/webfetch, and the /v1/byok key-management routes.
|
Package cloudclient is the CLI's HTTP client for the memcode gateway's SIDE-CHANNEL surfaces: /v1/advisor, /v1/websearch, /v1/webfetch, and the /v1/byok key-management routes. |
|
config
Package config loads and persists per-project memcode configuration, stored under a .memcode directory at the project root.
|
Package config loads and persists per-project memcode configuration, stored under a .memcode directory at the project root. |
|
doctor
Package doctor runs deterministic health checks over a memcode project — the built-in answer to "is the runtime actually doing what we think?".
|
Package doctor runs deterministic health checks over a memcode project — the built-in answer to "is the runtime actually doing what we think?". |
|
doctrine
Package doctrine is the memcode prompt doctrine — client-owned since the one-wire architecture (the CLI is the agent; backends serve models, they never compose prompts).
|
Package doctrine is the memcode prompt doctrine — client-owned since the one-wire architecture (the CLI is the agent; backends serve models, they never compose prompts). |
|
events
Package events defines the canonical event kinds and a typed helper for appending them.
|
Package events defines the canonical event kinds and a typed helper for appending them. |
|
explore
Package explore runs a fan-out of read-only "reader" sub-agents over a repository and synthesizes their findings into one answer.
|
Package explore runs a fan-out of read-only "reader" sub-agents over a repository and synthesizes their findings into one answer. |
|
forks
Package forks holds vendored forks of third-party Go modules that memcode patches locally.
|
Package forks holds vendored forks of third-party Go modules that memcode patches locally. |
|
forks/vaxis
Package vaxis is a terminal user interface for modern terminals
|
Package vaxis is a terminal user interface for modern terminals |
|
forks/vaxis/cmd/vtwidth
command
vtwidth is a utility to measure the width of a string as it will be rendered in the terminal
|
vtwidth is a utility to measure the width of a string as it will be rendered in the terminal |
|
forks/vaxis/octreequant
Package octreequant implements an image quantizer, for transforming bitmap images to palette images, before encoding them to SIXEL.
|
Package octreequant implements an image quantizer, for transforming bitmap images to palette images, before encoding them to SIXEL. |
|
forks/vaxis/sixel
Package sixel encodes and decodes DEC sixel images.
|
Package sixel encodes and decodes DEC sixel images. |
|
forks/vaxis/ui
Package ui provides a Flutter-inspired widget, layout, and painting layer for terminal applications built with Vaxis.
|
Package ui provides a Flutter-inspired widget, layout, and painting layer for terminal applications built with Vaxis. |
|
forks/vaxis/ui/uitest
Package uitest provides small helpers for testing ui widgets without a terminal.
|
Package uitest provides small helpers for testing ui widgets without a terminal. |
|
forks/vaxis/vxfw/image
Package image provides a vxfw widget for rendering vaxis images.
|
Package image provides a vxfw widget for rendering vaxis images. |
|
forks/vaxis/widgets/term/pty
Package pty provides pseudo-terminal support for the terminal widget.
|
Package pty provides pseudo-terminal support for the terminal widget. |
|
gateway/config
Package config is the gateway's self-hosted configuration, split the way memcode already splits everything (and the way Hermes does): secrets — the bot tokens — live in the global .env (written by `memcode gateway setup`, never hand-set), and NON-secret settings live here in gateway.yaml.
|
Package config is the gateway's self-hosted configuration, split the way memcode already splits everything (and the way Hermes does): secrets — the bot tokens — live in the global .env (written by `memcode gateway setup`, never hand-set), and NON-secret settings live here in gateway.yaml. |
|
gateway/importer
MCP server migration.
|
MCP server migration. |
|
gateway/server
Package server is the memcode gateway runtime — the first external surface of memcode's event/agent spine.
|
Package server is the memcode gateway runtime — the first external surface of memcode's event/agent spine. |
|
gateway/state
Package state is the gateway's durable bookkeeping — the state that MUST survive a restart for the gateway to behave correctly: a durable INBOX of accepted-but-not-yet-processed messages (so a message is never lost between being acked to the provider and being run), and each polling channel's ack cursor (so a restart resumes where it left off).
|
Package state is the gateway's durable bookkeeping — the state that MUST survive a restart for the gateway to behave correctly: a durable INBOX of accepted-but-not-yet-processed messages (so a message is never lost between being acked to the provider and being run), and each polling channel's ack cursor (so a restart resumes where it left off). |
|
gitlog
Package gitlog is a tiny, dependency-free reader over `git log`, shared by the context compiler, provenance, predict and producer attribution.
|
Package gitlog is a tiny, dependency-free reader over `git log`, shared by the context compiler, provenance, predict and producer attribution. |
|
hooks
Package hooks runs user-defined shell commands at agent lifecycle points — the extensibility seam for policy and automation the prompt can't provide (deterministic guards, notifications, context injection).
|
Package hooks runs user-defined shell commands at agent lifecycle points — the extensibility seam for policy and automation the prompt can't provide (deterministic guards, notifications, context injection). |
|
jobs
Package jobs runs and tracks detached background agent sessions.
|
Package jobs runs and tracks detached background agent sessions. |
|
knowledge
Package knowledge gives memcode the baseline a senior engineer just HAS — curated, authoritative facts and idioms for common stacks (Vercel, Next, React, Node, Supabase…), embedded in the binary so they travel into any repo.
|
Package knowledge gives memcode the baseline a senior engineer just HAS — curated, authoritative facts and idioms for common stacks (Vercel, Next, React, Node, Supabase…), embedded in the binary so they travel into any repo. |
|
learn
Package learn is the reconciler: it turns source documents and deterministic evidence into adjudicated claims.
|
Package learn is the reconciler: it turns source documents and deterministic evidence into adjudicated claims. |
|
lessons
Package lessons is the distilled-failure memory: strategy-level lessons ("when X breaks, do Y") extracted from the agent's own failure-and-repair episodes, accumulated as lesson_signal events, and promoted to standing plaintext files once they recur — the preference_signal promotion rigor applied to failures (≥3 signals, ≥2 sessions, weighted score ≥ 2.0).
|
Package lessons is the distilled-failure memory: strategy-level lessons ("when X breaks, do Y") extracted from the agent's own failure-and-repair episodes, accumulated as lesson_signal events, and promoted to standing plaintext files once they recur — the preference_signal promotion rigor applied to failures (≥3 signals, ≥2 sessions, weighted score ≥ 2.0). |
|
llm
Package llm is the metered model-execution gateway: the ONE path every model call goes through.
|
Package llm is the metered model-execution gateway: the ONE path every model call goes through. |
|
lsp
Package lsp is memcode's resident Language Server Protocol client — the "give the agent eyes" layer.
|
Package lsp is memcode's resident Language Server Protocol client — the "give the agent eyes" layer. |
|
mcp
Package mcp gives memcode an MCP (Model Context Protocol) client: it discovers the servers configured across scopes (local / project / user), connects to them (stdio, streamable HTTP, or SSE), lists their tools, and exposes a single Call entrypoint.
|
Package mcp gives memcode an MCP (Model Context Protocol) client: it discovers the servers configured across scopes (local / project / user), connects to them (stdio, streamable HTTP, or SSE), lists their tools, and exposes a single Call entrypoint. |
|
membench
Package membench evaluates memcode's session-memory retrieval against public conversational-memory benchmarks (LongMemEval, LoCoMo) with ZERO model calls.
|
Package membench evaluates memcode's session-memory retrieval against public conversational-memory benchmarks (LongMemEval, LoCoMo) with ZERO model calls. |
|
objectives
Package objectives manages the human-authored goals that give the engine its sense of direction ("what we're trying to do").
|
Package objectives manages the human-authored goals that give the engine its sense of direction ("what we're trying to do"). |
|
overview
Package overview synthesizes a CANONICAL current-state overview of a project — the answer to "what is this now?" — from fresh signals (recent commits, active objectives, current claims, recent-active subsystems) rather than rebuilding it from random old docs/memories each time.
|
Package overview synthesizes a CANONICAL current-state overview of a project — the answer to "what is this now?" — from fresh signals (recent commits, active objectives, current claims, recent-active subsystems) rather than rebuilding it from random old docs/memories each time. |
|
plans
Package plans is the user-level store of saved plans — one markdown file per plan under ~/.memcode/plans, mirroring Claude Code's ~/.claude/plans.
|
Package plans is the user-level store of saved plans — one markdown file per plan under ~/.memcode/plans, mirroring Claude Code's ~/.claude/plans. |
|
policy
Package policy is memcode's user-authored behavior layer: typed settings on named decision points, resolved deterministically at runtime.
|
Package policy is memcode's user-authored behavior layer: typed settings on named decision points, resolved deterministically at runtime. |
|
predict
Package predict infers where a developer was working and what they were about to do next.
|
Package predict infers where a developer was working and what they were about to do next. |
|
prefs
Package prefs is the preference-learning reducer.
|
Package prefs is the preference-learning reducer. |
|
producer
Package producer attributes work to who/what produced it — a human or a specific AI tool — from commit metadata.
|
Package producer attributes work to who/what produced it — a human or a specific AI tool — from commit metadata. |
|
provenance
Package provenance answers "why is this here?" for a file, directory or subsystem — the question humans constantly ask and agents are bad at.
|
Package provenance answers "why is this here?" for a file, directory or subsystem — the question humans constantly ask and agents are bad at. |
|
provider
Package provider defines the (model, embedding, edit-apply) boundaries the engine talks to, plus the default Claude model tiers.
|
Package provider defines the (model, embedding, edit-apply) boundaries the engine talks to, plus the default Claude model tiers. |
|
providers/anthropic
Package anthropicwire is the Anthropic Messages API adapter — the ONE implementation of the Messages dialect (cache_control placement, adaptive thinking, streaming decode, tool calls, native web search, usage parsing), shared by the hosted gateway (its own or the user's BYOK key) and the CLI's direct endpoint mode (api.anthropic.com).
|
Package anthropicwire is the Anthropic Messages API adapter — the ONE implementation of the Messages dialect (cache_control placement, adaptive thinking, streaming decode, tool calls, native web search, usage parsing), shared by the hosted gateway (its own or the user's BYOK key) and the CLI's direct endpoint mode (api.anthropic.com). |
|
providers/compat
Package compat is the CLI's ONLY turn transport: a stdlib-only HTTP client speaking OpenAI-compat chat/completions — streaming SSE, tools + forced tool_choice, image/file parts — against any base URL: the memcode gateway at {api}/v1 (Memcode=true: the optional extensions ride) or any arbitrary compat endpoint (Memcode=false: pure standard wire).
|
Package compat is the CLI's ONLY turn transport: a stdlib-only HTTP client speaking OpenAI-compat chat/completions — streaming SSE, tools + forced tool_choice, image/file parts — against any base URL: the memcode gateway at {api}/v1 (Memcode=true: the optional extensions ride) or any arbitrary compat endpoint (Memcode=false: pure standard wire). |
|
providers/gemini
Package geminiwire is the Gemini adapter (google.golang.org/genai) — the ONE implementation of the Gemini dialect for BOTH backends: the Developer API (API key) and Vertex AI (service-account JSON, passed in — credential RESOLUTION stays with the caller).
|
Package geminiwire is the Gemini adapter (google.golang.org/genai) — the ONE implementation of the Gemini dialect for BOTH backends: the Developer API (API key) and Vertex AI (service-account JSON, passed in — credential RESOLUTION stays with the caller). |
|
providers/memcode
Package memcode is the memcode PROTOCOL's provider: the OpenAI-compat chat/completions dialect PLUS the memcode extensions — the two-system stable/volatile convention, the memcode_opaque reasoning round-trip, the `memcode` response object, the enforced `memcode_billing` lane, session affinity via `user`, and the GET /v1/models routing CONTROL PLANE the CLI-side selection policy runs on.
|
Package memcode is the memcode PROTOCOL's provider: the OpenAI-compat chat/completions dialect PLUS the memcode extensions — the two-system stable/volatile convention, the memcode_opaque reasoning round-trip, the `memcode` response object, the enforced `memcode_billing` lane, session affinity via `user`, and the GET /v1/models routing CONTROL PLANE the CLI-side selection policy runs on. |
|
providers/openai
Package openaiwire is the OpenAI Responses API adapter — the ONE implementation of the Responses dialect (request encoding, streaming decode, reasoning-item round-trip, tool calls, usage parsing), shared by the hosted gateway (which injects its own or the user's BYOK key) and the CLI's direct endpoint mode (api.openai.com / api.x.ai).
|
Package openaiwire is the OpenAI Responses API adapter — the ONE implementation of the Responses dialect (request encoding, streaming decode, reasoning-item round-trip, tool calls, usage parsing), shared by the hosted gateway (which injects its own or the user's BYOK key) and the CLI's direct endpoint mode (api.openai.com / api.x.ai). |
|
providers/provcore
Package provcore is the shared kernel under the provider WIRE adapters: the bounded retry loop, the tuned turn HTTP client, the native web-search tool swap, and the context-overflow classification — protocol plumbing shared by every adapter (the gateway's and the extracted ones alike), with NO routing policy, keys, or metering in it.
|
Package provcore is the shared kernel under the provider WIRE adapters: the bounded retry loop, the tuned turn HTTP client, the native web-search tool swap, and the context-overflow classification — protocol plumbing shared by every adapter (the gateway's and the extracted ones alike), with NO routing policy, keys, or metering in it. |
|
recall
Package recall answers natural-language questions about a repository's prose memory — "where did we decide X?", "what's our policy on Y?" — by ranking the corpus of source docs, adjudicated claims, and human decisions against the question with BM25 plus memcode-aware boosts (claim status, recency, scope, source kind, exact phrase).
|
Package recall answers natural-language questions about a repository's prose memory — "where did we decide X?", "what's our policy on Y?" — by ranking the corpus of source docs, adjudicated claims, and human decisions against the question with BM25 plus memcode-aware boosts (claim status, recency, scope, source kind, exact phrase). |
|
repofiles
Package repofiles enumerates the files that are actually part of a project — honoring .gitignore — so the engine never mistakes vendored, generated, cached or ignored files (node_modules, docker volumes, build output) for real source.
|
Package repofiles enumerates the files that are actually part of a project — honoring .gitignore — so the engine never mistakes vendored, generated, cached or ignored files (node_modules, docker volumes, build output) for real source. |
|
sandbox
Package sandbox wraps agent shell commands in an OS-level containment layer — defense-in-depth UNDER the permission classifier, not a replacement for it.
|
Package sandbox wraps agent shell commands in an OS-level containment layer — defense-in-depth UNDER the permission classifier, not a replacement for it. |
|
scripts
Package scripts is the repo-local store of reusable multi-step command sequences — a proven recipe ("rebuild the cli", "commit, push, deploy") saved once and replayed by name instead of re-derived every time.
|
Package scripts is the repo-local store of reusable multi-step command sequences — a proven recipe ("rebuild the cli", "commit, push, deploy") saved once and replayed by name instead of re-derived every time. |
|
sessionlog
Package sessionlog is memcode's episodic memory: a local, append-only record of the high-level causal trail of a session — user messages, assistant messages, meaningful actions (commands, edits, commits), and approvals — written to disk as it happens, independent of the LLM context window.
|
Package sessionlog is memcode's episodic memory: a local, append-only record of the high-level causal trail of a session — user messages, assistant messages, meaningful actions (commands, edits, commits), and approvals — written to disk as it happens, independent of the LLM context window. |
|
skills
Package skills gives memcode discoverable, lazy-loaded "traits" — the same mechanism Claude Code uses: a markdown file with a name + a "when to use" blurb, its body loaded on demand when the model decides a task matches.
|
Package skills gives memcode discoverable, lazy-loaded "traits" — the same mechanism Claude Code uses: a markdown file with a name + a "when to use" blurb, its body loaded on demand when the model decides a task matches. |
|
sources
Package sources discovers the instruction/memory/doc artifacts left by AI coding tools and humans (CLAUDE.md, .claude/, .cursor/rules, AGENTS.md, copilot/windsurf/aider configs, README, docs, ADRs) and records them as doctrine *candidates*.
|
Package sources discovers the instruction/memory/doc artifacts left by AI coding tools and humans (CLAUDE.md, .claude/, .cursor/rules, AGENTS.md, copilot/windsurf/aider configs, README, docs, ADRs) and records them as doctrine *candidates*. |
|
stack
Package stack is a deterministic project tech-stack detector.
|
Package stack is a deterministic project tech-stack detector. |
|
store
Package store is the persistence layer for the memcode state engine.
|
Package store is the persistence layer for the memcode state engine. |
|
structure
Package structure derives a repository's topology — its subsystems and the dependencies between them — from language-agnostic, deterministic signals: the directory tree, dependency manifests, ownership and change history.
|
Package structure derives a repository's topology — its subsystems and the dependencies between them — from language-agnostic, deterministic signals: the directory tree, dependency manifests, ownership and change history. |
|
subscription/claudesub
Package claudesub turns a Claude Pro/Max subscription into a memcode backend by reusing the login the Claude Code CLI already stored.
|
Package claudesub turns a Claude Pro/Max subscription into a memcode backend by reusing the login the Claude Code CLI already stored. |
|
subscription/codex
Package codex turns a ChatGPT (Codex) subscription into a memcode backend by reusing the login the Codex CLI already stored.
|
Package codex turns a ChatGPT (Codex) subscription into a memcode backend by reusing the login the Codex CLI already stored. |
|
subscription/copilot
Package copilot turns a GitHub Copilot subscription into a memcode backend: it finds the GitHub token the machine already has (an env var or `gh auth token`), exchanges it for a short-lived Copilot API token, and returns the endpoint + identity headers the Copilot API requires.
|
Package copilot turns a GitHub Copilot subscription into a memcode backend: it finds the GitHub token the machine already has (an env var or `gh auth token`), exchanges it for a short-lived Copilot API token, and returns the endpoint + identity headers the Copilot API requires. |
|
subscription/grok
Package grok turns a SuperGrok / X Premium+ subscription into a memcode backend via xAI's OAuth device-code flow.
|
Package grok turns a SuperGrok / X Premium+ subscription into a memcode backend via xAI's OAuth device-code flow. |
|
sync
Package sync writes project memory to AI-editor context files (CLAUDE.md, .github/copilot-instructions.md, .cursor/rules, .windsurfrules).
|
Package sync writes project memory to AI-editor context files (CLAUDE.md, .github/copilot-instructions.md, .cursor/rules, .windsurfrules). |
|
textutil
Package textutil holds small string helpers shared across packages.
|
Package textutil holds small string helpers shared across packages. |
|
theme
Package theme defines memcode's color themes: a registry of named palettes (semantic color roles for TUI styles, diff RGBs, and chroma syntax-highlight style names) plus the active-theme accessor used by the renderer.
|
Package theme defines memcode's color themes: a registry of named palettes (semantic color roles for TUI styles, diff RGBs, and chroma syntax-highlight style names) plus the active-theme accessor used by the renderer. |
|
todos
Package todos is the agent's operational work tracker — a lightweight checklist the agent maintains itself so it doesn't lose its place when a request has several moving parts.
|
Package todos is the agent's operational work tracker — a lightweight checklist the agent maintains itself so it doesn't lose its place when a request has several moving parts. |
|
triggers/github
Package github is the gateway's GitHub trigger: an inbound webhook receiver, not a chat channel.
|
Package github is the gateway's GitHub trigger: an inbound webhook receiver, not a chat channel. |
|
triggers/googlechat
Package googlechat is the gateway's Google Chat adapter.
|
Package googlechat is the gateway's Google Chat adapter. |
|
triggers/sms
Package sms is the gateway's SMS adapter over Twilio: inbound messages arrive as form-encoded webhooks (signature-verified), replies go out through the Messages API.
|
Package sms is the gateway's SMS adapter over Twilio: inbound messages arrive as form-encoded webhooks (signature-verified), replies go out through the Messages API. |
|
triggers/whatsapp
Package whatsapp is the gateway's WhatsApp adapter over the Meta Cloud API.
|
Package whatsapp is the gateway's WhatsApp adapter over the Meta Cloud API. |
|
update
Package update implements self-update against the public GitHub Releases repo (memcode-ai/memcode — the same source the curl|sh installer uses).
|
Package update implements self-update against the public GitHub Releases repo (memcode-ai/memcode — the same source the curl|sh installer uses). |
|
vxui
Package vxui is memcode's interactive renderer, built on vaxis's Elm-style `ui` framework (StatefulWidget/State/Build/HandleEvent).
|
Package vxui is memcode's interactive renderer, built on vaxis's Elm-style `ui` framework (StatefulWidget/State/Build/HandleEvent). |
|
webjwt
Package webjwt is the ONE verifier for platform-signed inbound-webhook bearer tokens (Bot Framework, Google Chat): RS256 against a published JWKS, with issuer/audience/expiry enforced and the key set cached — an unknown kid triggers a refetch at most once per interval, so key rotation works but a forged-kid flood is not amplified into JWKS hammering.
|
Package webjwt is the ONE verifier for platform-signed inbound-webhook bearer tokens (Bot Framework, Google Chat): RS256 against a published JWKS, with issuer/audience/expiry enforced and the key set cached — an unknown kid triggers a refetch at most once per interval, so key rotation works but a forged-kid flood is not amplified into JWKS hammering. |
|
websites
Package websites is the CLI's client for memcode.ai's Websites feature — AI-built static sites.
|
Package websites is the CLI's client for memcode.ai's Websites feature — AI-built static sites. |
|
wire
Package common is the memcode PROTOCOL contract: the wire types shared by the CLI (the client) and the api gateway (the server), the sdk/agent ↔ CLI stream-json envelope, the abstract Intent, shared error sentinels, and the model/pricing metadata both ledgers price against.
|
Package common is the memcode PROTOCOL contract: the wire types shared by the CLI (the client) and the api gateway (the server), the sdk/agent ↔ CLI stream-json envelope, the abstract Intent, shared error sentinels, and the model/pricing metadata both ledgers price against. |
|
tools
|
|
|
keyprobe
command
keyprobe is a tiny raw-stdin key inspector.
|
keyprobe is a tiny raw-stdin key inspector. |
Click to show internal directories.
Click to hide internal directories.