A second brain template for software developers — built on plain Markdown and an AI coding agent that maintains it with you. The name is a portmanteau of meow and diary.

Meowary gives your AI coding agent persistent, searchable memory. Decisions, trade-offs, architecture rationale, team context — captured once, reused every session. The agent reads your notes before acting, so it stops asking things you already documented.

Clone the repo, run setup.sh, run /bootstrap, start your first day with /morning.

Both agents share the same workflows, skills, scripts, and reference material. generate.sh produces each agent's configuration directory from a single canonical source (.shared/). You choose your agent during setup; switching later costs one command.

Meowary borrows Zettelkasten staged understanding: raw capture → source notes → atomic cross-linked articles. QMD semantic search surfaces the right context before every action.

Bullet Journal rapid logging: dump everything into today's Inbox during the day. /evening sorts it. One command opens the day; one closes it.

Evergreen Notes and Digital Gardening: articles are never finished, only more developed. Health scripts flag staleness.

The same agent that writes your daily notes also reviews your pull requests — reading architecture decisions, team structure, and project history first. Organized by PARA (Projects, Areas, Resources, Archive).

• Progressive disclosure. The agent loads only what the current task needs. Morning routine and implementation session load entirely different context.
• CLI tools over MCP. Standalone tools (jira, confluence, gh, glab, qmd, repomix) — visible, reproducible, no server lifecycle.
• Human control. Slash commands are atomic. HARD-GATE checkpoints pause for your confirmation. Tiered execution (quick/standard/full) controls depth.
• Knowledge graph feeds coding. The agent reads architecture decisions before reviewing code and writes new conventions back after coding.
• Agent-agnostic content. All workflows, skills, and scripts live in .shared/ and work with any supported agent.

git clone https://github.com/retran/meowary my-journal
cd my-journal
bash setup.sh

setup.sh installs mise, uses it to install all required tools, asks which agent you use, and runs generate.sh to produce the agent configuration. Works on macOS, Linux, and WSL. Safe to re-run.

setup.sh creates .env from .env.example. Three required values:

ATLASSIAN_EMAIL=you@example.com
ATLASSIAN_API_TOKEN=your-atlassian-api-token
ATLASSIAN_INSTANCE=your-instance.atlassian.net

mise loads .env automatically when you enter the directory.

Re-run setup.sh or uncomment tools in mise.toml and run mise install:

# gh = "latest"        # GitHub CLI
# glab = "latest"      # GitLab CLI
# "ubi:ankitpokhrel/jira-cli[exe=jira]" = "latest"
# "npm:confluence-cli" = "latest"

After installing, authenticate each tool (gh auth login, glab auth login, jira init).

Start your agent from the Meowary root directory, then:

/bootstrap     # set up your identity and context (once)
/morning       # start your first day

All shared content lives in .shared/ (canonical source, committed to git). Agent-specific directories (.opencode/, .claude/) are generated and gitignored.

bash generate.sh opencode        # generate OpenCode config
bash generate.sh claude          # generate Claude Code config
bash generate.sh opencode claude # generate both

generate.sh copies workflows, skills, scripts, commands, agents, and reference material into each agent's expected directory structure. For Claude Code, it also transforms agent frontmatter (OpenCode's permission model → Claude's tools/disallowedTools).

To switch agents: edit .agent-config (one agent name per line), run mise run generate.

Three-zone structure per day:

On Mondays, /morning adds weekly planning. On Fridays, /evening adds weekly wrap-up.

Weekly notes at journal/weekly/YYYY-WNN.md. Monday: set weekly focus and goals from carry-overs. Friday: compile accomplishments, identify failures, run resource scan, review waiting-for items. /weekly for manual review.

resources/ is the knowledge graph. Articles are nodes; cross-references are edges. Grows via:

• Daily capture — /evening promotes durable facts from the day's notes
• Deliberate ingestion — /r ingest <url> processes sources into articles
• Enrichment — /r enrich <article> deepens from Confluence, Jira, codebase

Articles start as stubs and develop over time. Health scripts flag orphans, stale articles, broken links.

/do <phase> [project-slug] [tier] dispatches lifecycle work. Tiers: quick (fast), standard (default), full (comprehensive).

Skills are domain-specific instruction sets loaded on demand. Both agents use the same skill files from .shared/skills/.

Files marked † are created by /bootstrap or on first use.

meowary/
├── .shared/                  # Canonical source (committed)
│   ├── workflows/            # Step-by-step procedures (24 files)
│   ├── skills/               # Domain-specific instruction sets
│   ├── scripts/              # Health checks, sync, indexing
│   ├── commands/             # Slash command definitions
│   ├── agents/               # Sub-agent definitions
│   ├── reference/            # Structure, security, conventions
│   ├── context-templates/    # Templates for context/ files
│   ├── meta-templates/       # Templates for meta/ files
│   ├── opencode/             # OpenCode-specific config (package.json)
│   ├── claude/               # Claude Code-specific config (settings.json, mcp.json)
│   ├── AGENTS.md.template    # OpenCode memory file template
│   └── CLAUDE.md.template    # Claude Code memory file template
├── .opencode/                # Generated — gitignored
├── .claude/                  # Generated — gitignored
├── journal/
│   ├── daily/                # YYYY-MM-DD.md
│   ├── weekly/               # YYYY-WNN.md
│   ├── meetings/             # YYYY-MM-DD-<slug>.md
│   ├── recurring-events.md †
│   ├── waiting-for.md †
│   └── reading-list.md †
├── projects/                 # Time-bound work
│   └── <slug>/
│       ├── README.md         # Dashboard (status, tasks)
│       ├── dev-log.md        # Cross-session work log
│       ├── specs/            # Problem specs
│       ├── plans/            # Implementation plans
│       └── drafts/           # Proposals, RFCs, ADRs
├── areas/                    # Ongoing responsibilities
│   └── <slug>/README.md
├── resources/                # Knowledge graph
│   ├── <domain>/
│   └── synthesis/
├── archive/                  # Completed projects/areas
├── inbox/                    # Captures and source notes
├── context/
│   ├── context.md †          # Identity, team, projects
│   ├── safety.md             # Security rules
│   └── env-snapshot.md †
├── codebases/
│   └── <name>.md †           # Per-repo: stack, build, test, conventions
├── meta/
│   ├── tags.md †
│   ├── confluence-sync.json †
│   └── resources-log.md †
├── generate.sh               # Produce agent dirs from .shared/
├── setup.sh                  # First-run installer
├── update.sh                 # Framework updater
├── mise.toml                 # Tool dependencies
├── VERSION
├── qmd.yml                   # Semantic search config
└── .env.example              # Credentials template

bash update.sh                      # update to latest release
bash update.sh --check              # check if newer release exists
bash update.sh --version 0.2.0     # specific version
bash update.sh --non-interactive    # skip prompts

Updates .shared/, generate.sh, setup.sh, update.sh, mise.toml, and VERSION. Never modifies journal/, projects/, areas/, resources/, archive/, inbox/, context/, codebases/, meta/, or .env. Re-runs generate.sh after updating.

Open the repo as an Obsidian vault. Apply these settings for cross-editor compatibility:

Useful plugins: Dataview (query by property), Calendar (navigate daily notes), Periodic Notes (alternative to /morning).

In opencode.json (or equivalent Claude Code config), set the external directory permission to your repos:

"external_directory": {
  "~/workspace/**": "allow"
}

This lets the agent review and modify code in your projects while using journal context.

Knowledge management: PARA, Bullet Journal, Zettelkasten, Evergreen Notes, Digital Gardening.

See CONTRIBUTING.md.

MIT — Copyright (c) 2026 Andrew Vasilyev