affaan-m/ecc

knowledge-ops

Knowledge base management, ingestion, sync, and retrieval across multiple storage layers (local files, MCP memory, vector stores, Git repos).

Zobacz źródło

Jak używać

  1. Skopiuj polecenie instalacji i sprawdź źródła przed instalacją we własnym środowisku agenta.
  2. W oryginale sprawdź wymagane narzędzia, dane dostępowe i obsługiwane środowiska.
  3. Opisz dane wejściowe i oczekiwany rezultat; porównaj wynik ze źródłami.
npx skills add https://github.com/affaan-m/ecc --skill knowledge-ops

Przed rozpoczęciem

  • Instalacja nie obejmuje subskrypcji modelu, limitu API ani uprawnień do plików.
  • Gwiazdki i instalacje pokazują aktywność, a nie niezależny test jakości lub bezpieczeństwa.
Oryginalny dokument Skill

Treść z repozytorium z zachowaniem nagłówków, przykładów, kodu, tabel, linków i obrazów.

Knowledge Operations

Manage a multi-layered knowledge system for ingesting, organizing, syncing, and retrieving knowledge across multiple stores.

Prefer the live workspace model:

  • code work lives in the real cloned repos
  • active execution context lives in GitHub, Linear, and repo-local working-context files
  • broader human-facing notes can live in a non-repo context/archive folder
  • durable cross-machine memory belongs in the knowledge base, not in a shadow repo workspace

When to Activate

  • User wants to save information to their knowledge base
  • Ingesting documents, conversations, or data into structured storage
  • Syncing knowledge across systems (local files, MCP memory, Supabase, Git repos)
  • Deduplicating or organizing existing knowledge
  • User says "save this to KB", "sync knowledge", "what do I know about X", "ingest this", "update the knowledge base"
  • Any knowledge management task beyond simple memory recall

Knowledge Architecture

Layer 1: Active execution truth

  • Sources: GitHub issues, PRs, discussions, release notes, Linear issues/projects/docs
  • Use for: the current operational state of the work
  • Rule: if something affects an active engineering plan, roadmap, rollout, or release, prefer putting it here first

Layer 2: Claude Code Memory (Quick Access)

  • Path: ~/.claude/projects/*/memory/
  • Format: Markdown files with frontmatter
  • Types: user preferences, feedback, project context, reference
  • Use for: quick-access context that persists across conversations
  • Automatically loaded at session start

Layer 3: MCP Memory Server (Structured Knowledge Graph)

  • Access: MCP memory tools (createentities, createrelations, addobservations, searchnodes)
  • Use for: Semantic search across all stored memories, relationship mapping
  • Cross-session persistence with queryable graph structure

Layer 4: Knowledge base repo / durable document store

  • Use for: curated durable notes, session exports, synthesized research, operator memory, long-form docs
  • Rule: this is the preferred durable store for cross-machine context when the content is not repo-owned code

Layer 5: External Data Store (Supabase, PostgreSQL, etc.)

  • Use for: Structured data, large document storage, full-text search
  • Good for: Documents too large for memory files, data needing SQL queries

Layer 6: Local context/archive folder

  • Use for: human-facing notes, archived gameplans, local media organization, temporary non-code docs
  • Rule: writable for information storage, but not a shadow code workspace
  • Do not use for: active code changes or repo truth that should live upstream

Ingestion Workflow

When new knowledge needs to be captured:

1. Classify

What type of knowledge is it?

  • Business decision -> memory file (project type) + MCP memory
  • Active roadmap / release / implementation state -> GitHub + Linear first
  • Personal preference -> memory file (user/feedback type)
  • Reference info -> memory file (reference type) + MCP memory
  • Large document -> external data store + summary in memory
  • Conversation/session -> knowledge base repo + short summary in memory

2. Deduplicate

Check if this knowledge already exists:

  • Search memory files for existing entries
  • Query MCP memory with relevant terms
  • Check whether the information already exists in GitHub or Linear before creating another local note
  • Do not create duplicates. Update existing entries instead.

3. Store

Write to appropriate layer(s):

  • Always update Claude Code memory for quick access
  • Use MCP memory for semantic searchability and relationship mapping
  • Update GitHub / Linear first when the information changes live project truth
  • Commit to the knowledge base repo for durable long-form additions

4. Index

Update any relevant indexes or summary files.

Sync Operations

Conversation Sync

Periodically sync conversation history into the knowledge base:

  • Sources: Claude session files, Codex sessions, other agent sessions
  • Destination: knowledge base repo
  • Generate a session index for quick browsing
  • Commit and push

Workspace State Sync

Mirror important workspace configuration and scripts to the knowledge base:

  • Generate directory maps
  • Redact sensitive config before committing
  • Track changes over time
  • Do not treat the knowledge base or archive folder as the live code workspace

GitHub / Linear Sync

When the information affects active execution:

  • update the relevant GitHub issue, PR, discussion, release notes, or roadmap thread
  • attach supporting docs to Linear when the work needs durable planning context
  • only mirror a local note afterwards if it still adds value

Cross-Source Knowledge Sync

Pull knowledge from multiple sources into one place:

  • Claude/ChatGPT/Grok conversation exports
  • Browser bookmarks
  • GitHub activity events
  • Write status summary, commit and push

Memory Patterns

# Short-term: current session context
Use TodoWrite for in-session task tracking

# Medium-term: project memory files
Write to ~/.claude/projects/*/memory/ for cross-session recall

# Long-term: GitHub / Linear / KB
Put active execution truth in GitHub + Linear
Put durable synthesized context in the knowledge base repo

# Semantic layer: MCP knowledge graph
Use mcp__memory__create_entities for permanent structured data
Use mcp__memory__create_relations for relationship mapping
Use mcp__memory__add_observations for new facts about known entities
Use mcp__memory__search_nodes to find existing knowledge

Best Practices

  • Keep memory files concise. Archive old data rather than letting files grow unbounded.
  • Use frontmatter (YAML) for metadata on all knowledge files.
  • Deduplicate before storing. Search first, then create or update.
  • Prefer one canonical home per fact set. Avoid parallel copies of the same plan across local notes, repo files, and tracker docs.
  • Redact sensitive information (API keys, passwords) before committing to Git.
  • Use consistent naming conventions for knowledge files (lowercase-kebab-case).
  • Tag entries with topics/categories for easier retrieval.

Quality Gate

Before completing any knowledge operation:

  • no duplicate entries created
  • sensitive data redacted from any Git-tracked files
  • indexes and summaries updated
  • appropriate storage layer chosen for the data type
  • cross-references added where relevant

Powiązane zadania

z tego samego repozytorium

Więcej Skills

Wszystkie Skills
affaan-m
Społeczność

rust-testing

Rust testing patterns including unit tests, integration tests, async testing, property-based testing, mocking, and coverage. Follows TDD methodology. Use when writing Rust tests — unit, integration, async, property-based, or coverage.

Instalacje / 24h
489
GitHub Stars
308,2 tys.
Aktualizacja
20 lis
affaan-m
Społeczność

search-first

Research-before-coding workflow: search npm/PyPI, MCP servers, skills, and GitHub for existing tools before writing custom code, then adopt, extend, or build. Launches the researcher agent for non-trivial needs. Use when starting a feature, adding a dependency or integration, or about to write a utility that may already exist.

Instalacje / 1h
5
GitHub Stars
308,2 tys.
Aktualizacja
20 lis
affaan-m
Społeczność

browser-qa

Run automated post-deploy UI verification with a browser automation MCP (claude-in-chrome, Playwright, or Puppeteer): console-error and Core Web Vitals smoke checks, form and auth-flow interaction tests, screenshot visual regression across three breakpoints, and axe-core accessibility audits ending in a SHIP / DO-NOT-SHIP verdict. Use when testing a deployed feature on staging or preview, before shipping frontend changes, reviewing a frontend PR, or checking responsive layout and accessibility.

Instalacje / 1h
2
GitHub Stars
307,9 tys.
Aktualizacja
20 lis
affaan-m
Społeczność

docker-patterns

Docker and Docker Compose patterns for local development, hardened CLI installer harnesses, container security, networking, volumes, and multi-service orchestration. Use when creating or reviewing Dockerfiles and Compose services, testing installers across Linux distributions, or planning accurate native macOS and Windows validation.

Instalacje / 1h
2
GitHub Stars
307,9 tys.
Aktualizacja
20 lis