convez.ai
SkillProdutividadeAvançado
benjsmith

Curiosity Engine

benjsmith/curiosity-engine

Wiki inteligente e auto-melhorável com curação autônoma e rastreamento de citações

Ver no GitHub
InicialPluginScore · de 0 a 100

Uma wiki de conhecimento auto-melhorável para agentes de código. Ingira fontes (PDFs, docs, planilhas), consulte com citações e deixe loops de curação autônoma melhorarem continuamente a base de conhecimento — cada mudança validada por revisor com contexto fresco e preservação de citações.

Instalação

$npx convez-ai benjsmith/curiosity-engine

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
57%
Último commit
há 1 mês
Versão
v1.9.2
Issues abertas
0
Contribuidores
2

Casos de uso

  • Construir bases de conhecimento de projetos com rastreamento automático de fontes
  • Curar e organizar documentação técnica com validação de citações
  • Integrar decisões e achados de agentes IA em repositórios de código
  • Consultar conhecimento estruturado com garantia de origem das informações

Veredito

Ferramenta sofisticada para quem precisa de wikis vivas e confiáveis. A abordagem de curação autônoma com ratchet de citações é inovadora, mas exige investimento em setup e compreensão de seus fluxos. Vale para equipes técnicas que valorizam rastreabilidade e manutenção contínua de conhecimento.

README

A tradução para o português deste README ainda está na fila.

Curiosity Engine

An example knowledge graph displayed by the skill's built-in viewer. An example knowledge graph displayed by the skill's built-in viewer.

A self-improving knowledge wiki for coding-agent CLIs. Drop sources in, ask questions, and let autonomous "curate" loops draft improvements in parallel — each gated by a citation-preserving ratchet, judged by a fresh-context reviewer, and committed if it earns its place. The wiki is plain markdown, git-tracked, and yours to edit.

What it does

Three stores, three verbs:

  • Vault (vault/, raw sources — PDFs, docs, spreadsheets, slides — append-only) → Curator (an autonomous agent) → Wiki (wiki/, eight markdown page types with [[wikilinks]] and (vault:path) citations, git-tracked).
  • ingest — "add this paper to the vault". Extracts text + tables + figures, indexes for keyword (and optional semantic) search.
  • query — "what do I know about X?". Answers with citations, ends with a probing follow-up question.
  • curate — "curate this wiki for an hour". Plan → execute → evaluate loop. Worker subagents draft improvements in parallel; a fresh-context reviewer grades each wave; hash-guarded scoring scripts the agent can't tamper with.

Features

Everything the skill does, in one line each:

  • Eight wiki page types with per-type floors enforced mechanically: sources, entities, concepts, analyses, evidence, facts, tables, figures.
  • Citation-preserving ratchet: score_diff.py rejects any edit that drops a citation or adds one whose source doesn't FTS5-match the claim. The wiki never regresses.
  • Built-in graph viewer at localhost:8090 — D3 force graph, type-grouped browser, fuzzy search, click-to-open modal with a hop-by-hop subgraph navigator. Or open wiki/ as an Obsidian vault. Or use VS Code + Foam.
  • Multimodal table & figure extraction from PDFs. Per-table tab-*.md pages, with row data mirrored to a queryable SQLite store. Numeric literal-transcription mode for scientific work.
  • Identifier resolution for chemicals (PubChem) and gene symbols (MyGene.info). Cached locally; lazy lookup at synthesis time only.
  • Class tables — entity-instance data (deals, patients, contracts, matters) with schemas declared on entity pages, rows citing vault provenance. Queryable via tables.py; joinable with the kuzu graph.
  • Three storage layers, one source-of-truth file per fact: plain markdown for prose, SQLite for class-entity row data, embedded kuzu property graph for wikilink + relational-edge traversal. The two databases are derived state.
  • Semantic vault search (optional, opt-in) — MiniLM + sqlite-vec layered over FTS5 for fuzzy queries on large corpora. Keyword stays primary.
  • Multi-project model — many projects in one wiki, derived from the citation graph (not declared by the user); recency-weighted curation, soft-delete, cross-wiki merge via the companion curiosity-merge skill.
  • Code-repo integration — register a code repo against a CE workspace; capture decisions, gotchas, agent findings into the workspace's vault. Curate runs against the workspace, never inside the code repo. Per-(repo, branch) session brief gives a fresh agent yesterday's context for files in the current diff.
  • Notes + todos as first-class types. /note, /day, /month, /year, /todo slash commands in Claude Code; same flows via natural language on other CLIs. Ticking [x] propagates across mention-sites and appends to the yearly completion archive.
  • Hash-guarded scoring + sweep scripts — snapshot at wave start, integrity check at wave end, drift aborts the wave. The curator can't edit its own metrics.
  • Multi-backend — Claude (default), Codex, Gemini, Copilot Chat, Cursor, fully local via Ollama. One JSON file (active_preset), one env var (CURATOR_PRESET) for per-session swap.

Quick start

# install the skill (pick one — all equivalent)
claude skill install curiosity-engine
npx skills add benjsmith/curiosity-engine
# or: git clone into ~/.claude/skills/curiosity-engine/

# set up a workspace
mkdir my-research && cd my-research
claude
> set up a knowledge base here
> add ~/papers/some-paper.pdf to the vault
> what do I know about transformer architectures?
> curate this wiki for an hour

The first command runs setup.sh, which creates the folder layout, initialises the wiki git repo, drops in a Claude Code settings file that auto-allows safe operations, and (optionally) installs companion tooling.

For non-Claude-Code CLIs (Codex, Gemini, Copilot Chat, Cursor, OpenClaude, Ollama, air-gapped, enterprise), see docs/setup-advanced.md.

Architecture

Three objects, three verbs, one autonomous loop.

  your files
      │
      ▼
  ┌─────────┐       ┌───────────┐      ┌─────────┐
  │  vault  │──────▶│  curator  │─────▶│  wiki   │
  │ (raw)   │ reads │  (agent)  │writes│ (notes) │
  └─────────┘       └───────────┘      └─────────┘
                         ▲                  │
                         │ ask              │ answer
                         └──────── you ─────┘

Inside the curator on each wave:

                ┌─────────────────┐
                │ 🎯 Orchestrator │
                └────────┬────────┘
                         │ dispatches per wave
           ┌─────────┬───┴────┬────────────┐
           ▼         ▼        ▼            ▼
       ┌───────┐ ┌────────┐ ┌───────┐ ┌──────────┐
       │Worker │ │Reviewer│ │ Spot  │ │   Link   │
       │Sonnet │ │ Opus   │ │auditor│ │proposer +│
       │writes │ │ batch  │ │ Opus  │ │classifier│
       │pages +│ │semantic│ │sampled│ │ Opus,    │
       │figures│ │  gate  │ │adversy│ │fresh ctx │
       └───┬───┘ └───┬────┘ └───┬───┘ └─────┬────┘
           └────┬────┴────┬─────┴──────┬────┘
                ▼         ▼            ▼
         score_diff  scrub_check  evolve_guard
         (citations  (injection   (script-hash
          · bloat ·   guard)       integrity)
          floors)
                │
                ▼ accept
      ┌─────────────────────────────────────────────┐
      │             State — three stores            │
      ├──────────────┬──────────────┬───────────────┤
      │ Docs (git)   │ Relational   │ Graph         │
      │ vault/       │ vault.db     │ graph.kuzu    │
      │ wiki/ 8 page │  FTS5 + vec  │  WikiLink     │
      │   types     │ tables.db    │  Cites        │
      │ .curator/log │  class rows  │  DataRef      │
      └──────┬───────┴──────────────┴───────────────┘
             │ feedback: epoch_summary · graph queries · FTS5
             └──────────────▶ Orchestrator

Full design rationale — why not RAG, how the ratchet works, where the skill struggles — in docs/architecture.md.

When it fits

Fits well when:

  • You're reading hundreds or thousands of substantial sources in a domain over weeks or months.
  • You care about provenance — every claim traceable to a vault file.
  • You want cross-source connections surfaced, not just stored.
  • You want understanding that persists across sessions and compounds.
  • You don't mind waiting a minute for accurate answers.

Good fits: personal research, literature reviews, research notebooks, due-diligence analysts, cross-field synthesis.

Doesn't fit when:

  • You want instant answers from a huge (>1000) doc store → use RAG (LlamaIndex, LangChain).
  • You're working on code → use your coding agent directly on the repo. (Codebase knowledge — decisions, gotchas, design notes — does fit; see docs/code-knowledge.md.)
  • You need multi-user collaboration → Obsidian sync, Notion, Confluence.
  • Your data is purely tabular with no source documents → use a database directly. (Entity-instance data tied to vault sources — deals, patients, contracts — is first-class.)

Learn more

Dependencies

  • Python 3 (stdlib for most scripts)
  • uv — workspace venv + script runner (auto-installed by setup.sh if missing)
  • kuzu — embedded property-graph database (auto-installed)
  • sentence-transformers + sqlite-vec (optional) — semantic vault search (~200MB model)
  • git — the wiki is a git repo
  • A frontier coding-agent CLI — Claude Code is primary; others work with adjustments (see docs/setup-advanced.md)

License

MIT. If you use the scientific-extraction pipeline in published work, please credit the design principles per docs/citation.md.

Ver o original no GitHub

Bom para

Relacionados