innernet

Your existing folders and, optionally, public GitHub repositories are the source material. Local JSON indexes power both readers.

Explore	What you will find
Search · / and /search	A familiar search box, highlighted results, live suggestions, spelling corrections and project knowledge panels.
Innerpedia · /wiki	Project articles with README overviews, folder trees, technology, Git history and related projects. Browse categories, statistics or a random article.
Agents · /search?q=is:agent&t=agents	The other half of the index: every dot folder an agent or tool keeps (.claude, .codex, .cursor, .xo...), each with an article of its instructions, memory, sessions and activity.
Field guide · /#guide	The second half of the home page: an illustrated walkthrough of the crawl, search and privacy rules, an interactive recipe for turning a folder into an article, and a prompt that hands Innernet to an AI assistant.
History · /activity	Every page you opened, one session per browser tab, kept as plain files on this machine with a copy in its own database. The header's arrows step back and forward.

The public demo (Vercel)

The same app runs as a public demo at https://innernet-nine.vercel.app. Instead of this machine, it indexes the open-source repositories of github.com/quirq-ai:

pnpm index:demo   # clone the public quirq-ai repos (anonymous HTTPS) and build data/demo/index.json
pnpm dev:demo     # preview the demo locally

data/demo/index.json is committed, and every path in it is a GitHub URL. Vercel builds always run the demo (VERCEL=1); locally INNERNET_DEMO=1 switches it on (lib/mode.ts). In the demo the localhost guard is off, a banner says what you are looking at, folders link to GitHub instead of VS Code, and the guide plays the committed 720p film. With a database it keeps the pages and searches visitors open for 30 days, anonymously (the demo's history); without one, history stays in the browser.

How it works

flowchart LR
    folders["Your folders"] --> crawler["Crawler<br>READMEs, manifests, Git metadata"]
    crawler --> index["Local index<br>data/index.json"]
    index --> search["Search<br>Find a project"]
    index --> wiki["Innerpedia<br>Read its story"]

The crawler records folder structure, project descriptions, languages, dependencies and Git history. Innerpedia assembles articles from that information; folders with less project context become stubs. Shared names get disambiguation pages, and categories connect projects across your directory tree.

Search runs on the server with MiniSearch. The app uses Next.js, React, TypeScript and Tailwind CSS, with Markdown rendered by react-markdown and remark-gfm.

Projects and agents

Every page belongs to one of two halves. A folder whose name starts with a dot is an agent's: .claude, .codex, .cursor, .agents, .xo, .openclaw and the like, wherever they sit in your sources, together with everything inside them. Everything else is a project's. The rule lives in lib/agents.ts.

Each agent's folder gets an article of its own, an octagon among the circles and squares: which tool keeps it and which project it belongs to, then Instructions and memory (its CLAUDE.md, AGENTS.md, SOUL.md, IDENTITY.md, rules and memory/ notes, shown as written) and Sessions and activity (how many sessions or transcripts it keeps and when, from file names, sizes and dates; their contents are never read). A project's article names the agents that keep folders in it.

Two kinds of dot folder are not agents. Folders a tool generates (.git, .next, .turbo, .venv, .cache and similar) are skipped like node_modules, and folders that hold credentials (.ssh, .aws, .docker, .clerk and similar) are never entered. An agent's worktrees are checkouts of projects indexed elsewhere, so they are skipped too.

Get started

You need Node.js 20.9 or newer and pnpm. Run the commands from the repository directory so the server can find its index.

1. Install

git clone https://github.com/quirq-ai/innernet.git
cd innernet
pnpm install

2. Choose your folders

Edit innernet.config.json before indexing. The defaults are:

{
  "roots": ["~/Programming"],
  "maxDepth": 6
}

Add or replace roots with the folders you want to explore. maxDepth controls how many levels of folders get their own pages.

3. Index and open

pnpm index
pnpm dev

Open localhost:3470, search for a familiar project, or visit Innerpedia and the field guide. Both pnpm dev and pnpm start bind to 127.0.0.1.

The first dev run or build needs network access to fetch fonts. Afterward, the fonts are served locally.

Choose and sync sources

Open Sources next to Guide to visit the /sources page. Check Local for the folders configured in innernet.config.json, Remote for public GitHub repositories, or both to search and browse them together. At least one source must be selected. Under Remote, enter a GitHub username or organization, as a name or account URL. The default is quirq-ai. Optionally list repository names or repository URLs belonging to that account, one per line; an empty list means all its public repositories. Save sources applies these choices and saves them in data/sources.json across tabs and restarts. Then use Sync now to fetch the selected repositories.

Sync now rebuilds the saved selection and refreshes the page. Local runs the same crawler as pnpm index and writes data/index.json. Remote anonymously downloads public repositories into .github-cache. The default quirq-ai account with an empty repository list uses data/github.json and, before its first sync, the included data/demo/index.json snapshot. Other account or repository selections each use a separate data/github-<hash>.json snapshot, so changing Remote never shows pages from the previous selection. A new selection has no remote pages until synced. Both selected means both are refreshed. Progress and the outcome appear on the page, and source changes and syncs are recorded in the current tab's activity session. Only one button-triggered sync runs at a time. Sources is available locally; the public demo cannot change or sync sources. A command-line rebuild is picked up on the next request without a restart.

For a single run, override the configured roots and depth:

INNERNET_ROOTS="~/projects,~/notes" INNERNET_MAX_DEPTH=3 pnpm index

To inspect a trial index without replacing the app's index:

INNERNET_ROOTS="~/projects" INNERNET_OUT=/tmp/innernet-test.json pnpm index

The app reads the selected indexes from its project folder. INNERNET_OUT only changes where the command-line local crawler writes; it does not change the app's index paths. The local part of Sync now always updates data/index.json.

Find and edit stored data

The Where your data lives section below the source choices shows the exact paths used by this installation, including environment overrides. Copy path copies a location, Open folder opens it in the file manager, and Edit file opens the current tab's activity file, local folder configuration or saved source choices in a text editor when the file exists.

Data	Default location	How to change it
This tab's activity	~/.innernet/history/<session>/innernet.jsonl	Edit or remove JSON lines, then reload History. Keep at, app and kind on each event.
All activity	~/.innernet/history/	Each session is a folder; other apps can add their own JSONL files.
Generated local pages	data/index.json	Edit the original folders, then sync Local.
Generated GitHub pages	data/github-<hash>.json per account/repository selection; data/github.json for the default	Sync Remote to download a fresh public snapshot. Only the default quirq-ai selection falls back to data/demo/index.json.
Source choices	data/sources.json	Edit the Local/Remote choices, GitHub account and optional repositories on Sources, then save.
Local roots and depth	innernet.config.json	Edit roots and maxDepth, then sync Local.
Database copy	~/.innernet/db/	Use the database tools below; edit history files rather than database internals.
Downloaded repositories	.github-cache/	Disposable clones used by remote sync.
App build files and traces	.next/, or the configured build directory	Regenerated by Next.js.

Search results and Innerpedia pages are rendered from the JSON indexes; there is no separate HTML file to edit for each generated page. The Sources page also identifies the app folder and browser storage: the session ID and navigation trail in sessionStorage, and the theme preference in localStorage. Activity and the database stay on this machine with Local, Remote, or both selected. Remote chooses public content to read; it does not switch this installation to the hosted demo.

Search your folders

Start with ordinary words, then narrow the results with operators. Search covers project names, paths, descriptions, README text, dependencies and agent notes.

Try	Finds
lang:rust	Folders whose leading languages include Rust.
in:experiments	Folders inside a matching ancestor folder.
kind:repo	Git repositories.
fw:next	Projects using Next.js.
is:article	Innerpedia articles.
is:stub	Folders with less project context.
is:agent	Agents' folders and everything in them. is:project finds the rest.
kind:agent	An agent's own folder: .claude, .codex, .xo...

Combine them with free text, such as chat lang:ts fw:next. Quote values containing spaces, such as in:"side projects". Results can also be filtered using the Projects, Agents, Repositories, Documents and Folders tabs.

History

Innernet writes down what you open, in plain files on this machine. The files are the record and the format every app shares, with no index file and no schema registry: a session is a folder, and each app that takes part writes its own JSON Lines file inside it. The database keeps a copy of the lines, read in as they change.

~/.innernet/history/                  set INNERNET_HISTORY_DIR to keep it elsewhere
  2026-10-03T05-12-07Z_k3f9a2/        one folder per browser tab: its start time (UTC) and a short id
    innernet.jsonl                    one JSON object per line, appended by Innernet
    <any-app>.jsonl                   any other app or tool adds its own file

Every line is {"at":"<ISO time>","app":"<name>","kind":"<verb>", ...} plus whatever fields the app likes. Innernet writes visit, search, back and forward:

{"at":"2026-10-03T05:12:09.512Z","app":"innernet","kind":"visit","url":"/wiki/galileo","title":"galileo"}
{"at":"2026-10-03T05:12:31.020Z","app":"innernet","kind":"search","q":"agent","url":"/search?q=agent"}

Reading a session means reading every *.jsonl in its folder and sorting by at. App names are lowercase letters, digits, - and _; lines over 4 KB, lines that are not JSON and lines without a valid at and kind are skipped. To add your own activity, append a line to a file named after your app. This joins the newest session:

echo '{"at":"'$(date -u +%FT%TZ)'","app":"notes","kind":"edit","file":"todo.md"}' >> "$(ls -d ~/.innernet/history/*/ | tail -1)notes.jsonl"

/activity, the clock in the header, shows the sessions newest first, each opening onto its events merged across apps. The header's arrows step back and forward through the pages of the current tab. The browser writes through the app's own /api/activity route, which accepts only same-origin requests on localhost, and automated browsing visits are not recorded. The route appends the line to the file first, then reads that session's files into the database; /activity reads in every folder that changed before it shows the list, so a line another app appended shows on the next visit. Without the database the page reads the files, as it always has. Delete a session's folder to forget it; the database forgets it on its next read. The public demo keeps its visitors' history differently: see the demo's history.

Saving source choices adds a kind: "sources" event with the Local and Remote selections. Sync now also adds events to the requesting tab's session: kind: "sync" with status: "started", then "completed" or "failed". Completion includes the page count and elapsed time; failure includes an error message. These events are written by the server as part of the sync, through the same file-first history store.

The database

Innernet keeps a copy of what it serves in a small Postgres database. The files stay the so