@archznn/crewloop-skills 0.2.0 → 0.4.0

package/servers/dashboard/src/state.ts

@@ -0,0 +1,115 @@
+import type { DashboardEvent, Session, DashboardState, AgentSource, EventStatus } from './types';
+
+export interface StateStoreOptions {
+  maxEventsPerSession: number;
+  sessionMaxAgeMs: number;
+}
+
+export class StateStore {
+  private sessions: Map<string, Session> = new Map();
+  private options: StateStoreOptions;
+
+  constructor(options: StateStoreOptions) {
+    this.options = options;
+  }
+
+  applyEvent(event: DashboardEvent): Session {
+    let session = this.sessions.get(event.session_id);
+
+    if (!session) {
+      session = this.createSession(event.session_id, event.source);
+    }
+
+    session.source = event.source;
+    session.last_event_at = event.timestamp;
+    session.events.unshift(event);
+
+    if (session.events.length > this.options.maxEventsPerSession) {
+      session.events.length = this.options.maxEventsPerSession;
+    }
+
+    if (event.tool) {
+      session.tool_counts[event.tool] = (session.tool_counts[event.tool] || 0) + 1;
+    }
+
+    if (event.skill) {
+      session.active_skill = event.skill;
+      session.active_confidence = event.event_type === 'skill_change' ? 'explicit' : 'heuristic';
+    }
+
+    session.status = deriveSessionStatus(event);
+
+    this.sessions.set(event.session_id, session);
+    return session;
+  }
+
+  setActiveSkill(
+    sessionId: string,
+    skill: string | undefined,
+    confidence: 'explicit' | 'heuristic' | 'unknown'
+  ): Session | undefined {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return undefined;
+    }
+    session.active_skill = skill;
+    session.active_confidence = confidence;
+    return session;
+  }
+
+  getSession(id: string): Session | undefined {
+    return this.sessions.get(id);
+  }
+
+  getAllSessions(): Session[] {
+    return Array.from(this.sessions.values()).sort(
+      (a, b) => b.last_event_at - a.last_event_at
+    );
+  }
+
+  getState(): DashboardState {
+    return {
+      sessions: Object.fromEntries(this.sessions),
+    };
+  }
+
+  pruneInactive(now: number = Date.now()): number {
+    let removed = 0;
+    for (const [id, session] of this.sessions) {
+      if (now - session.last_event_at > this.options.sessionMaxAgeMs) {
+        this.sessions.delete(id);
+        removed++;
+      }
+    }
+    return removed;
+  }
+
+  private createSession(id: string, source: AgentSource): Session {
+    const now = Date.now();
+    const session: Session = {
+      id,
+      source,
+      events: [],
+      tool_counts: {},
+      started_at: now,
+      last_event_at: now,
+    };
+    this.sessions.set(id, session);
+    return session;
+  }
+}
+
+function deriveSessionStatus(event: DashboardEvent): EventStatus | undefined {
+  switch (event.event_type) {
+    case 'session_start':
+    case 'tool_start':
+    case 'skill_change':
+      return 'running';
+    case 'tool_end':
+      return event.status || 'success';
+    case 'session_end':
+      return 'success';
+    default:
+      return undefined;
+  }
+}

package/servers/dashboard/src/types.ts

@@ -0,0 +1,110 @@
+export type AgentSource = 'kimi' | 'codex' | 'opencode' | 'log-watcher';
+
+export type EventType =
+  | 'session_start'
+  | 'session_end'
+  | 'tool_start'
+  | 'tool_end'
+  | 'skill_change';
+
+export type EventStatus = 'running' | 'success' | 'error';
+
+export interface DashboardEvent {
+  id: string;
+  timestamp: number;
+  source: AgentSource;
+  session_id: string;
+  event_type: EventType;
+  skill?: string;
+  tool?: string;
+  detail?: string;
+  status?: EventStatus;
+  duration_ms?: number;
+}
+
+export interface Session {
+  id: string;
+  source: AgentSource;
+  active_skill?: string;
+  active_confidence?: 'explicit' | 'heuristic' | 'unknown';
+  status?: EventStatus;
+  events: DashboardEvent[];
+  tool_counts: Record<string, number>;
+  started_at: number;
+  last_event_at: number;
+}
+
+export interface DashboardState {
+  sessions: Record<string, Session>;
+}
+
+export interface ClientActiveSkill {
+  name: string;
+  confidence: 'explicit' | 'heuristic' | 'unknown';
+}
+
+export interface ClientEvent {
+  id: string;
+  timestamp: number;
+  event_type: EventType;
+  tool?: string;
+  detail?: string;
+  status?: EventStatus;
+  duration_ms?: number;
+  skill?: string;
+}
+
+export interface ClientSession {
+  id: string;
+  source: AgentSource;
+  skill?: string;
+  activeSkill?: ClientActiveSkill;
+  status?: EventStatus;
+  events: ClientEvent[];
+  startTime: number;
+  lastActivity: number;
+  toolCounts: Record<string, number>;
+}
+
+export interface ClientSnapshotMessage {
+  type: 'snapshot';
+  sessions: ClientSession[];
+}
+
+export interface ClientUpdateMessage {
+  type: 'update';
+  session: ClientSession;
+  isActive: boolean;
+}
+
+export interface ClientPongMessage {
+  type: 'pong';
+}
+
+export type ClientWebSocketMessage =
+  | ClientSnapshotMessage
+  | ClientUpdateMessage
+  | ClientPongMessage;
+
+export interface SkillMeta {
+  name: string;
+  description: string;
+  icon: string;
+}
+
+export type ToolToSkillMap = Record<string, string | undefined>;
+
+export interface SkillInferenceResult {
+  skill: string | undefined;
+  confidence: 'explicit' | 'heuristic' | 'unknown';
+}
+
+export interface ServerConfig {
+  port: number;
+  host: string;
+  packageRoot: string;
+  maxEventsPerSession: number;
+  sessionMaxAgeMs: number;
+  pruneIntervalMs: number;
+}
+

package/servers/dashboard/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "public", "bin"]
+}

package/servers/obsidian-mcp/README.md

@@ -0,0 +1,82 @@
+# Obsidian MCP Second Brain
+
+Local MCP server that connects the `loop-engineering-agents` skill bundle to an Obsidian vault at `~/.lea`, acting as a second brain / RAG for AI agents.
+
+## Vault Architecture
+
+The vault at `~/.lea` follows a three-layer memory architecture. Agents should read `AGENT.md` on first use and `MEMORY.md` at the start of major tasks. Notes are organized into:
+
+- `memory/` — raw working-memory session logs
+- `Memory/` — durable user profile and preferences
+- `Knowledge/` — long-lived technical guides and decisions
+- `Journal/` — important session logs and dashboards
+- `Notes/` — temporary notes and drafts
+- `_Inbox/` — agent proposals before promotion
+
+See [`references/obsidian-mcp-usage.md`](../../references/obsidian-mcp-usage.md) for the full usage guide.
+
+## Installation
+
+```bash
+cd servers/obsidian-mcp
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+To use local sentence-transformer embeddings (heavier), install:
+
+```bash
+pip install -e ".[embeddings]"
+```
+
+Otherwise the server falls back to a lightweight TF-IDF embedder.
+
+## Configuration in Kimi Code
+
+Add to your `mcpServers` config (usually `~/.kimi-code/config.toml` or via the UI):
+
+```toml
+[mcpServers.obsidian-mcp]
+command = "/path/to/servers/obsidian-mcp/.venv/bin/python"
+args = ["-m", "obsidian_mcp.main"]
+```
+
+Or via JSON:
+
+```json
+{
+  "mcpServers": {
+    "obsidian-mcp": {
+      "command": "/path/to/servers/obsidian-mcp/.venv/bin/python",
+      "args": ["-m", "obsidian_mcp.main"]
+    }
+  }
+}
+```
+
+## MCP Tools
+
+- `read_note` — read a note from the vault
+- `search_notes` — search by text, vector, graph, or hybrid
+- `create_note` — create a new note
+- `update_note` — update or append content to an existing note
+- `delete_note` — delete a note
+- `list_notes` — list notes in the vault
+- `get_related_notes` — get related notes via links and graph traversal
+- `sync_from_bundle` — re-index the bundle and local vault
+- `learn_from_text` — detect concepts/decisions in text and create notes automatically
+
+## First Use
+
+1. Make sure Obsidian is installed.
+2. Create / open the vault at `~/.lea` in Obsidian.
+3. Run `sync_from_bundle` to index the bundle as the initial knowledge base.
+4. Use `search_notes` to query knowledge.
+5. Use `learn_from_text` whenever new concepts or decisions appear in conversation.
+
+## Tests
+
+```bash
+pytest tests/ -q
+```

package/servers/obsidian-mcp/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "obsidian-mcp"
+version = "0.1.0"
+description = "MCP server connecting loop-engineering-agents to a local Obsidian vault"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp>=1.0.0",
+    "pyyaml>=6.0",
+    "scikit-learn>=1.3.0",
+]
+
+[project.optional-dependencies]
+embeddings = [
+    "sentence-transformers>=2.2.0",
+]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+]
+
+[project.scripts]
+obsidian-mcp = "obsidian_mcp.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/obsidian_mcp"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

package/servers/obsidian-mcp/src/obsidian_mcp/config.py

@@ -0,0 +1,47 @@
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+def _default_bundle_path() -> Path:
+    env_path = os.environ.get("CREWLOOP_BUNDLE_PATH")
+    if env_path:
+        return Path(env_path)
+    return Path(__file__).resolve().parents[4]
+
+
+@dataclass
+class PrivacyConfig:
+    enabled: bool = True
+    block_api_keys: bool = True
+    block_private_keys: bool = True
+    block_env_files: bool = True
+    block_emails: bool = True
+    block_credit_cards: bool = True
+    allowed_strings: list[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class Config:
+    vault_path: Path = field(default_factory=lambda: Path.home() / ".lea")
+    index_dir: Path = field(default_factory=lambda: Path.home() / ".lea" / ".index")
+    bundle_path: Path = field(default_factory=_default_bundle_path)
+    embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2"
+    chunk_size: int = 512
+    chunk_overlap: int = 64
+    vector_limit: int = 20
+    text_limit: int = 20
+    graph_depth: int = 1
+    sensitive_patterns: list[str] = field(default_factory=list)
+    privacy: PrivacyConfig = field(default_factory=PrivacyConfig)
+
+    def __post_init__(self):
+        object.__setattr__(self, "vault_path", Path(self.vault_path).expanduser().resolve())
+        object.__setattr__(self, "index_dir", Path(self.index_dir).expanduser().resolve())
+        object.__setattr__(self, "bundle_path", Path(self.bundle_path).expanduser().resolve())
+        privacy = self.privacy
+        if isinstance(privacy, dict):
+            privacy = PrivacyConfig(**privacy)
+        elif not isinstance(privacy, PrivacyConfig):
+            privacy = PrivacyConfig()
+        object.__setattr__(self, "privacy", privacy)

package/servers/obsidian-mcp/src/obsidian_mcp/indexer/embeddings.py

@@ -0,0 +1,105 @@
+import hashlib
+import logging
+from typing import Protocol
+
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+logger = logging.getLogger(__name__)
+
+
+class Embedder(Protocol):
+    def encode(self, texts: list[str]) -> list[list[float]]: ...
+    def is_available(self) -> bool: ...
+    def uses_stored_embeddings(self) -> bool: ...
+
+
+class SentenceTransformerEmbedder:
+    def __init__(self, model_name: str):
+        self.model_name = model_name
+        self._model = None
+
+    def _load(self):
+        if self._model is None:
+            try:
+                from sentence_transformers import SentenceTransformer
+                self._model = SentenceTransformer(self.model_name)
+            except Exception as exc:
+                logger.warning("sentence-transformers not available: %s", exc)
+                raise
+
+    def is_available(self) -> bool:
+        try:
+            from sentence_transformers import SentenceTransformer
+            return SentenceTransformer is not None
+        except Exception:
+            return False
+
+    def uses_stored_embeddings(self) -> bool:
+        return True
+
+    def encode(self, texts: list[str]) -> list[list[float]]:
+        self._load()
+        embeddings = self._model.encode(texts, convert_to_numpy=True, show_progress_bar=False)
+        return [e.tolist() for e in embeddings]
+
+
+class TfidfEmbedder:
+    def __init__(self):
+        self._vectorizer = TfidfVectorizer()
+        self._fitted = False
+
+    def is_available(self) -> bool:
+        return True
+
+    def uses_stored_embeddings(self) -> bool:
+        return False
+
+    def encode(self, texts: list[str]) -> list[list[float]]:
+        if not self._fitted:
+            matrix = self._vectorizer.fit_transform(texts)
+            self._fitted = True
+        else:
+            matrix = self._vectorizer.transform(texts)
+        return matrix.toarray().tolist()
+
+
+class EmbedderFactory:
+    @staticmethod
+    def create(model_name: str) -> Embedder:
+        st = SentenceTransformerEmbedder(model_name)
+        if st.is_available():
+            return st
+        logger.warning("falling back to TF-IDF embedder")
+        return TfidfEmbedder()
+
+
+def chunk_text(text: str, chunk_size: int, overlap: int) -> list[tuple[str, int, int]]:
+    if not text:
+        return []
+    chunks = []
+    start = 0
+    text_len = len(text)
+    while start < text_len:
+        end = min(start + chunk_size, text_len)
+        if end < text_len:
+            expanded = end
+            while expanded < text_len and text[expanded] not in ("\n", " "):
+                expanded += 1
+            if expanded < text_len:
+                end = expanded
+        chunk_value = text[start:end].strip()
+        if chunk_value:
+            start_line = text.count("\n", 0, start) + 1
+            end_line = text.count("\n", 0, end) + 1
+            chunks.append((chunk_value, start_line, end_line))
+        if end >= text_len:
+            break
+        next_start = end - overlap
+        if next_start <= start:
+            next_start = end
+        start = next_start
+    return chunks
+
+
+def chunk_id(note_path: str, text: str) -> str:
+    return hashlib.sha256(f"{note_path}:{text}".encode()).hexdigest()[:16]

package/servers/obsidian-mcp/src/obsidian_mcp/indexer/indexer.py

@@ -0,0 +1,79 @@
+import hashlib
+import logging
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.indexer.embeddings import EmbedderFactory, chunk_id, chunk_text
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.models import Chunk, GraphEdge, Note
+from obsidian_mcp.vault.repository import VaultRepository
+
+logger = logging.getLogger(__name__)
+
+
+class Indexer:
+    def __init__(self, config: Config, vault: VaultRepository, store: IndexStore | None = None):
+        self.config = config
+        self.vault = vault
+        self.store = store or IndexStore(config.index_dir / "index.db")
+        self.embedder = EmbedderFactory.create(config.embedding_model)
+
+    def _hash(self, text: str) -> str:
+        return hashlib.sha256(text.encode()).hexdigest()[:16]
+
+    def index_note(self, note: Note, force: bool = False):
+        meta = self.store.get_note_meta(note.path)
+        mtime = note.mtime.timestamp() if note.mtime else 0.0
+        content_hash = self._hash(note.content)
+        if not force and meta and meta["mtime"] == mtime and meta["hash"] == content_hash:
+            return
+
+        self.store.delete_chunks_for_note(note.path)
+        self.store.delete_edges_for_note(note.path)
+
+        chunks_data = chunk_text(note.content, self.config.chunk_size, self.config.chunk_overlap)
+        chunks = [
+            Chunk(
+                id=chunk_id(note.path, text),
+                note_path=note.path,
+                text=text,
+                start_line=start,
+                end_line=end,
+            )
+            for text, start, end in chunks_data
+        ]
+
+        if chunks and self.embedder.uses_stored_embeddings():
+            try:
+                embeddings = self.embedder.encode([c.text for c in chunks])
+                for chunk, emb in zip(chunks, embeddings):
+                    chunk.embedding = emb
+            except Exception as exc:
+                logger.warning("embedding failed for %s: %s", note.path, exc)
+
+        self.store.upsert_chunks(chunks)
+
+        edges = [
+            GraphEdge(source=note.path, target=target, relation="links", weight=1.0)
+            for target in note.links
+        ]
+        self.store.upsert_edges(edges)
+        self.store.upsert_note_meta(note.path, mtime, content_hash)
+
+    def index_all(self, force: bool = False):
+        notes = self.vault.read_all()
+        for note in notes:
+            self.index_note(note, force=force)
+
+    def compute_backlinks(self):
+        self.store.delete_backlinks()
+        edges = self.store.get_all_edges()
+        targets = {}
+        for edge in edges:
+            if edge.relation == "links":
+                targets.setdefault(edge.target, []).append(edge.source)
+        backlink_edges = [
+            GraphEdge(source=target, target=source, relation="backlink", weight=0.8)
+            for target, sources in targets.items()
+            for source in sources
+        ]
+        self.store.upsert_edges(backlink_edges)