Sessory

KO | EN

gitlite — search

#javascript #react #android #deep-learning #linux #docker #nodejs #kubernetes #vue #awesome-list #pytorch #ios #openai #open-source

(★ 78)

Shared memory for AI coding sessions.

Sessory 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<h1 align="center">Sessory</h1>

<p align="center">
  <b>Turn your AI coding sessions into searchable, shareable engineering knowledge.</b><br>
  <i>GitHub shows what changed. Sessory shows how the AI got there.</i>
</p>

---

## Why

Developers now write, debug, and refactor with AI coding agents every day. But that work is invisible. The final PR shows the *diff* — it never shows **how the AI got there**.

Every AI coding session is a rich engineering artifact:

- the task and the prompt
- the files it inspected
- the commands it ran
- the **bottleneck** it hit
- the **mistakes** it made and **how they were corrected**
- the final changes and how they were verified

Today all of that disappears inside one developer's terminal the moment the session ends. **Sessory captures it, extracts the insight, and makes it searchable** — so it becomes knowledge you (and eventually your team) can reuse.

This repo is the **local-first MVP**: capture and explore *your own* sessions first. Team sharing comes later.

## What it does

- 🪝 **Zero-effort capture** — install once; every Claude Code session is saved automatically when it ends.
- 🧠 **Insight extraction, not just storage** — each session is classified into a structured schema: what kind of work, whether it landed, the bottleneck, the failure, and how it was corrected.
- 🔎 **Searchable archive** — find past sessions by title, file, command, error, or tag.
- 📊 **Three views** — a per-session trace, a sortable table of everything, and settings.
- 🔒 **Local-first & no API key** — everything stays in one SQLite file on your machine; summaries reuse your existing Claude Code login.

## How it works

After a one-time install, all four steps happen on their own:

```
  Claude Code session ends
          │   a SessionEnd hook fires (installed once, applies to every session)
          ▼
  1. Capture    read the transcript → a structured trace (task, files, commands, errors, timeline)
          ▼
  2. Store      save it as one row in a local SQLite database
          ▼
  3. Classify   a background `claude -p` call extracts the classification + insight
          ▼
  4. Explore    a local dashboard to browse, search, and analyze your sessions
```

- **Source of truth:** your Claude Code transcripts in `~/.claude/projects`. Sessory reads them, never moves them.
- **Everything stays local:** one database at `~/.sessory/sessory.db`. No accounts, no uploads, no API keys.
- **Never in your way:** capture is instant at session end; the summary fills in a few seconds later, in the background.

## Quick start

```bash
npm install -g sessory

sessory init          # turn on automatic capture (one time)
sessory dashboard     # → http://localhost:4319
```

That's it. Use Claude Code as you normally would — when a session ends it's captured and summarized on its own, and shows up in the dashboard.

| Command | What it does |
|---------|--------------|
| `sessory dashboard` | Scan, then serve the dashboard at `http://localhost:4319` |
| `sessory init` | Install the auto-capture `SessionEnd` hook |
| `sessory scan` | Refresh the archive from `~/.claude/projects` |
| `sessory classify all` | Backfill summaries for any un-classified sessions |
| `sessory ignore <repo-or-project>` | Never capture a repo/project (and purge any already captured) |
| `sessory unignore <pattern>` | Remove an ignore pattern |

Sessions are stored locally in `~/.sessory/sessory.db`.

### From source (development)

```bash
git clone https://github.com/juntoku9/Sessory.git
cd Sessory && npm install
npm run dashboard     # runs from source via tsx
```

## What's in a session

Sessory keeps the full structured trace, but the value is the **extracted classification** stored on each session:

```jsonc
{
  "activity": ["bugfix", "test"],        // multi-label — what kind of work
  "status": "completed",                  // completed | partial | abandoned | blocked
  "goal": "...", "changes": "...",        // the human-readable card
  "verification": "...",
  "tags": ["stripe", "webhook"],          // open keywords for search
  "significance": 0.8,                    // 0–1, so trivial sessions can be filtered
  "insight": {                            // the part a diff can't show
    "achievement": "...",
    "done": ["..."],
    "bottleneck": "...", "bottleneckType": "test-failure",
    "failures": "...", "correction": "...",
    "failureTypes": ["test-failure"]
  },
  "derived": {                            // computed from the transcript — never guessed
    "languages": ["TypeScript"], "fileCount": 7,
    "commands": 12, "errorsHit": 2, "durationMs": 540000
  }
}
```

The `*Type` fields use a **controlled vocabulary** so they aggregate — the foundation for future progress/insight dashboards (e.g. *"what bottlenecks slow the team down most?"*).

## The dashboard

| Tab | What it shows |
|-----|---------------|
| **Sessions** | Browse and search; click a session for its full trace — summary card, insight, files, timeline. |
| **Skills** | Every skill invoked across sessions — invocations, projects, last used, 7-day trend. Click a skill to see where it ran. |
| **Tables** | Every session as a sortable table (activity, status, significance, bottleneck, duration…). Click a row to open it. |
| **Settings** | Toggle auto-capture, re-scan, backfill summaries, and see status. |

## Team deployment (Postgres)

Sessory stores sessions through a small storage interface with two adapters:
**SQLite** (local, the default) and **Postgres** (shared, for teams). Point one
environment variable at a Postgres database and the entire CLI *and* dashboard read
and write there instead — same schema, no code change:

```bash
export SESSORY_DATABASE_URL=postgresql://user:pass@db.internal:5432/sessory
npm run dashboard        # the dashboard now reads from Postgres
npm run scan             # captures now write to Postgres
```

A company can host one Postgres **in its own cluster (on-prem)**, have each
developer point `SESSORY_DATABASE_URL` at it, and everyone's sessions land in one
shared, searchable archive that the dashboard reads from. The table is created
automatically on first use. The Settings tab shows the active backend.

> This is the storage layer — the foundation for team sharing. Per-developer auth,
> redaction, and sync are the next steps (see roadmap). Until those land, treat a
> shared database as trusted/internal only.

## Roadmap

- [x] Parse Claude Code transcripts into structured sessions
- [x] Local SQLite archive + search
- [x] Dashboard: Sessions, Skills, Tables, Settings
- [x] Auto-capture via a `SessionEnd` hook
- [x] Classification + process-insight extraction
- [x] Skill-invocation tracking
- [x] Pluggable storage: SQLite (local) or Postgres (shared)
- [x] Per-repo / per-project excludes (`sessory ignore`)
- [ ] Aggregate progress dashboard (`GROUP BY` the structured fields)
- [ ] Redaction (scrub secrets before a shared backend)
- [ ] Team sharing: per-developer auth, sync, and shareable session pages
- [ ] Cross-agent capture (Codex, Cursor, …)

## Privacy

Sessory is local-only by default, and capture applies to **every** Claude Code session on your machine — including sensitive repos. Nothing leaves your computer.

Exclude a repo or project from capture (and purge anything already captured) with:

```bash
sessory ignore <repo-path-or-project-name>
sessory ignore                 # list current excludes
sessory unignore <pattern>     # re-enable
```

Redaction (scrubbing secrets) is next on the roadmap and will land before any sharing feature.

## Project layout

| File | Purpose |
|------|---------|
| `src/parser.ts` | Claude Code `.jsonl` → `Session` |
| `src/classify.ts` | Extract the classification + insight via `claude -p` |
| `src/db.ts` | Storage facade — picks SQLite or Postgres from config |
| `src/store.ts` | Storage interface (both adapters implement it) |
| `src/sqlite-store.ts` | SQLite adapter (local, default) |
| `src/postgres-store.ts` | Postgres adapter (shared, for teams) |
| `src/scan.ts` | Scan `~/.claude/projects`; capture a single session |
| `src/init.ts` | Install/remove the `SessionEnd` auto-capture hook |
| `src/ignore.ts` | Per-repo/project capture excludes |
| `src/server.ts` | Local dashboard server |
| `public/index.html` | Dashboard UI |

## Contributing

Issues and PRs welcome. The codebase intentionally favors small, surgical changes and minimal dependencies (see `CLAUDE.md`).

## License

Sessory

Sessory 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Sessory

Sessory 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README