symbiote-cli 0.1.0

package/hooks/pre-tool-use.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+INPUT=$(cat)
+
+CWD=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('cwd',''))" 2>/dev/null) || exit 0
+TOOL=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('tool_name',''))" 2>/dev/null) || exit 0
+FILE=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('tool_input',{}).get('file_path',''))" 2>/dev/null) || exit 0
+
+[ -z "$CWD" ] && exit 0
+
+BRAIN_DIR="$CWD/.brain"
+[ -d "$BRAIN_DIR" ] || exit 0
+
+case "$TOOL" in
+    Read|Edit|Write) ;;
+    *) exit 0 ;;
+esac
+
+[ -z "$FILE" ] && exit 0
+
+PORT_FILE="$BRAIN_DIR/port"
+[ -f "$PORT_FILE" ] || exit 0
+PORT=$(cat "$PORT_FILE" 2>/dev/null | tr -d '[:space:]')
+[ -z "$PORT" ] && exit 0
+
+ENCODED_FILE=$(python3 -c "import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1]))" "$FILE" 2>/dev/null) || exit 0
+ENCODED_TOOL=$(python3 -c "import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1]))" "$TOOL" 2>/dev/null) || exit 0
+ENCODED_ROOT=$(python3 -c "import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1]))" "$CWD" 2>/dev/null) || exit 0
+
+RESULT=$(curl -s --max-time 3 "http://127.0.0.1:${PORT}/internal/hook-context?file=${ENCODED_FILE}&tool=${ENCODED_TOOL}&root=${ENCODED_ROOT}" 2>/dev/null) || exit 0
+
+CONTEXT=$(echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); c=d.get('additionalContext',''); print(c) if c else sys.exit(1)" 2>/dev/null) || exit 0
+
+python3 -c "
+import json,sys
+print(json.dumps({
+    'hookSpecificOutput': {
+        'hookEventName': 'PreToolUse',
+        'additionalContext': sys.argv[1]
+    }
+}))
+" "$CONTEXT"
+exit 0

package/hooks/session-start.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# Symbiote SessionStart hook for Claude Code
+# Fires on session startup. Stdout is injected into Claude's context.
+
+dir="$PWD"
+found=false
+for i in 1 2 3 4 5; do
+  if [ -d "$dir/.brain" ]; then
+    found=true
+    break
+  fi
+  parent="$(dirname "$dir")"
+  [ "$parent" = "$dir" ] && break
+  dir="$parent"
+done
+
+if [ "$found" = false ]; then
+  exit 0
+fi
+
+# Auto-start symbiote serve if not already running
+port_file="$dir/.brain/port"
+if [ -f "$port_file" ]; then
+  port=$(cat "$port_file" | tr -d '[:space:]')
+  # Check if the server is actually responding
+  if ! curl -sf --max-time 1 "http://127.0.0.1:$port/internal/health" > /dev/null 2>&1; then
+    # Port file exists but server is dead — clean up and restart
+    rm -f "$port_file"
+    nohup npx symbiote-cli serve --no-open > /dev/null 2>&1 &
+    sleep 1
+  fi
+else
+  # No port file — start the server
+  nohup npx symbiote-cli serve --no-open > /dev/null 2>&1 &
+  sleep 1
+fi
+
+cat << 'EOF'
+## Symbiote — Project Brain Active
+
+This codebase is indexed by Symbiote, providing a living knowledge graph with code structure, dependencies, impact analysis, and developer DNA.
+
+**Before making changes, use these MCP tools:**
+- `get_context_for_file` — Dependencies, dependents, constraints for any file (use BEFORE editing)
+- `get_developer_dna` — The developer's coding style and preferences (use to match their conventions)
+- `query_graph` — Search symbols, trace call chains, find dependents
+- `semantic_search` — Natural language search over the codebase
+- `get_health` — Dead code, circular deps, coupling hotspots, constraint violations
+- `get_impact` — Blast radius analysis: what breaks if you change a symbol
+- `detect_changes` — Git diff mapped to affected graph nodes
+- `get_constraints` — Active project rules (enforce these)
+- `get_decisions` — Architectural decisions with rationale
+
+**IMPORTANT — When the developer corrects you or states a preference:**
+You MUST call the `record_instruction` MCP tool to capture it in Symbiote's DNA system. This is how Symbiote learns across sessions and tools. Do this IN ADDITION to any other memory you save. Examples of when to call it:
+- "don't use semicolons" → call `record_instruction` with instruction="Don't use semicolons"
+- "prefer early returns" → call `record_instruction` with instruction="Prefer early returns over nested conditions"
+- "no, use X instead of Y" → call `record_instruction` with the correction
+
+**Workflow:**
+1. Start with `get_developer_dna` to understand the developer's style
+2. Use `get_context_for_file` before reading or editing any file
+3. Use `get_constraints` to know what rules to follow
+4. When the developer corrects you, ALWAYS call `record_instruction` with their feedback
+EOF
+
+exit 0

package/package.json

@@ -0,0 +1,103 @@
+{
+    "name": "symbiote-cli",
+    "version": "0.1.0",
+    "description": "Symbiote bonds with your AI tools — giving them memory, context, and your coding DNA.",
+    "type": "module",
+    "imports": {
+        "#storage/*": "./dist/src/storage/*",
+        "#core/*": "./dist/src/core/*",
+        "#cortex/*": "./dist/src/cortex/*",
+        "#dna/*": "./dist/src/dna/*",
+        "#brain/*": "./dist/src/brain/*",
+        "#events/*": "./dist/src/events/*",
+        "#mcp/*": "./dist/src/mcp/*",
+        "#utils/*": "./dist/src/utils/*",
+        "#commands/*": "./dist/src/commands/*",
+        "#hooks/*": "./dist/src/hooks/*",
+        "#init/*": "./dist/src/init/*"
+    },
+    "bin": {
+        "symbiote": "dist/bin/symbiote.js"
+    },
+    "main": "./dist/src/index.js",
+    "types": "./dist/src/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/src/index.d.ts",
+            "import": "./dist/src/index.js"
+        }
+    },
+    "files": [
+        "dist/",
+        "skills/",
+        "hooks/",
+        "README.md",
+        "LICENSE"
+    ],
+    "engines": {
+        "node": ">=20"
+    },
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc --watch",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "type-check": "tsc --noEmit",
+        "prepublishOnly": "npm run build"
+    },
+    "dependencies": {
+        "@clack/prompts": "^0.10.0",
+        "@duckdb/node-api": "1.5.0-r.1",
+        "@huggingface/transformers": "^3.8.1",
+        "@modelcontextprotocol/sdk": "^1.27.1",
+        "chokidar": "^4.0.0",
+        "glob": "^11.0.0",
+        "graphology": "^0.25.4",
+        "graphology-communities-louvain": "^2.0.1",
+        "graphology-metrics": "^2.3.0",
+        "picocolors": "^1.1.0",
+        "tree-sitter": "^0.22.0",
+        "tree-sitter-c": "^0.23.0",
+        "tree-sitter-cpp": "^0.23.0",
+        "tree-sitter-go": "^0.23.0",
+        "tree-sitter-java": "^0.23.0",
+        "tree-sitter-javascript": "^0.23.0",
+        "tree-sitter-php": "^0.23.0",
+        "tree-sitter-python": "^0.23.0",
+        "tree-sitter-ruby": "^0.23.0",
+        "tree-sitter-rust": "^0.23.0",
+        "tree-sitter-typescript": "^0.23.0",
+        "zod": "^4.3.6"
+    },
+    "devDependencies": {
+        "@types/node": "^22.0.0",
+        "typescript": "^5.7.0",
+        "vite-tsconfig-paths": "^6.1.1",
+        "vitest": "^3.0.0"
+    },
+    "keywords": [
+        "ai",
+        "mcp",
+        "mcp-server",
+        "ai-coding",
+        "claude",
+        "cursor",
+        "copilot",
+        "windsurf",
+        "code-context",
+        "code-intelligence",
+        "tree-sitter",
+        "knowledge-graph",
+        "developer-tools"
+    ],
+    "author": {
+        "name": "Mohamed Ashraf",
+        "email": "cupo.ashraf@gmail.com"
+    },
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/MohmmedAshraf/symbiote.git"
+    },
+    "homepage": "https://github.com/MohmmedAshraf/symbiote"
+}

package/skills/symbiote-init/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: symbiote-init
+description: Initialize Symbiote for the current project. Scans the codebase and extracts developer DNA (coding preferences), project constraints, and architectural decisions from the current context. Use when the developer runs /symbiote-init, asks to "initialize symbiote", "set up symbiote", or "scan my project". Requires symbiote-cli to be installed (npx symbiote-cli install).
+---
+
+# Symbiote Project Init
+
+Initialize Symbiote for the current project — scan codebase and extract DNA + intent.
+
+MCP server is already registered globally by `symbiote install`. This skill only scans and extracts.
+
+## Process
+
+1. Scan the codebase
+2. Build extraction lists from context
+3. Dispatch subagent to record everything
+4. Print one-line summary
+
+## Step 1: Scan
+
+```bash
+npx symbiote-cli scan
+```
+
+## Step 2: Build Extraction Lists
+
+Read your context (CLAUDE.md, memories, rule files) and build three separate lists:
+
+### DNA (coding preferences) → `record_instruction`
+
+Extract how the developer writes code:
+
+- Formatting (indentation, quotes, semicolons, line length)
+- Language conventions (strict TypeScript, ESM, etc.)
+- Code structure (early returns, composition, small functions)
+- Anti-patterns (no `any`, no dead code, no comments)
+- Testing preferences (TDD, isolation, framework)
+- Workflow (conventional commits, small commits)
+
+### Constraints (project rules) → `propose_constraint`
+
+Extract rules the project enforces:
+
+- "All mutations through server actions"
+- "Validate external input with Zod at boundaries"
+- "Tests must mirror src/ structure"
+
+### Decisions (architectural choices) → `propose_decision`
+
+Extract choices with rationale:
+
+- "Chose Vitest over Jest for native ESM support"
+- "Using DuckDB for graph storage — local-first, no external deps"
+- "Switched to Drizzle for better type safety"
+
+### What to Skip (applies to all three)
+
+- File paths or directory descriptions
+- Tool/product feature lists
+- Author identity
+- CLI commands or usage examples
+- Anything describing WHAT the project IS rather than rules/choices/preferences
+
+### Formatting Rules (applies to all three)
+
+Each entry must be:
+
+- One clear, grammatically correct sentence
+- Self-contained — understandable without context
+- Specific — not vague or overly broad
+
+## Step 3: Dispatch Subagent
+
+Launch a single Agent to record everything. Pass it all three lists.
+
+**Agent prompt template:**
+
+```
+Record the following Symbiote entries using MCP tools. Call tools in parallel where possible.
+
+**DNA entries** — use `record_instruction` with `isExplicit: true` for each:
+1. [instruction]
+2. [instruction]
+
+**Constraints** — use `propose_constraint` for each with `scope: "global"` and a slugified `id`:
+1. [constraint]
+2. [constraint]
+
+**Decisions** — use `propose_decision` for each with `scope: "global"` and a slugified `id`:
+1. [decision]
+2. [decision]
+
+Return counts: { dna: N, constraints: N, decisions: N, failed: N }
+```
+
+## Step 4: Output
+
+One line, nothing more:
+
+```
+Symbiote initialized — scanned 350 files, recorded 18 DNA entries, 5 constraints, 3 decisions.
+```
+
+Do NOT render tables, lists, or per-entry details.