symbiote-cli 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "symbiote-cli",
-    "version": "0.2.2",
+    "version": "0.2.3",
     "description": "Symbiote bonds with your AI tools — giving them memory, context, and your coding DNA.",
     "type": "module",
     "imports": {

package/skills/symbiote-dna/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: symbiote-dna
+description: Manage Symbiote's Developer DNA — the learned coding preferences, style rules, and anti-patterns that persist across sessions. This skill should be used when the user asks to "show my coding preferences", "manage DNA", "update my coding style", "what are my coding rules", "switch DNA profile", "export DNA", "import DNA profile", or "share coding preferences".
+---
+
+# Symbiote Developer DNA
+
+Manage developer coding preferences that Symbiote learns and enforces across sessions.
+
+## What is Developer DNA
+
+DNA entries are coding rules Symbiote tracks with confidence scores. They have:
+
+- **rule** — the specific coding preference
+- **reason** — why it matters
+- **category** — formatting, patterns, architecture, workflow, testing, tooling, ai-collaboration
+- **confidence** — 0.0 to 1.0 (auto-promoted as patterns are observed)
+- **applies_to** — language/framework scope
+- **source** — explicit (user-stated), correction (from feedback), observed (from code patterns)
+
+## Commands
+
+### View Current DNA
+
+Use the `get_developer_dna` MCP tool. Filter by category:
+
+```
+get_developer_dna({ category: "formatting" })
+get_developer_dna({ category: "patterns" })
+get_developer_dna({})  // all entries
+```
+
+### Record a New Preference
+
+Use the `record_instruction` MCP tool:
+
+```
+record_instruction({
+    rule: "Always use early returns over nested if-else",
+    reason: "Reduces cognitive load and keeps functions flat",
+    category: "patterns",
+    applies_to: ["typescript", "javascript"],
+    source: "explicit"
+})
+```
+
+### CLI Profile Management
+
+```bash
+npx -y symbiote-cli dna              # Show active profile summary
+npx -y symbiote-cli dna list          # List all profiles
+npx -y symbiote-cli dna switch        # Switch active profile
+npx -y symbiote-cli dna export        # Export profile to .dna.json
+npx -y symbiote-cli dna import        # Import a shared profile
+npx -y symbiote-cli dna diff          # Compare two profiles
+```
+
+### Export and Share
+
+Export the current profile for team sharing:
+
+```bash
+npx -y symbiote-cli dna export
+```
+
+This creates a `.dna.json` file that teammates can import:
+
+```bash
+npx -y symbiote-cli dna import path/to/.dna.json
+```
+
+### Compare Profiles
+
+Diff two profiles to see divergence:
+
+```bash
+npx -y symbiote-cli dna diff
+```
+
+## Output
+
+When showing DNA, format as a clean grouped list:
+
+```
+## Developer DNA — {profile name}
+
+### Formatting ({count})
+- Use 4-space indentation everywhere (confidence: 1.0)
+- Single quotes for strings (confidence: 0.9)
+
+### Patterns ({count})
+- Prefer early returns over nesting (confidence: 1.0)
+- const over let, never var (confidence: 0.8)
+
+### Architecture ({count})
+- ...
+```

package/skills/symbiote-impact/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: symbiote-impact
+description: Trace the blast radius of a code change using Symbiote's dependency graph. This skill should be used when the user asks to "analyze impact", "what will this change break", "show affected files", "check blast radius", "impact analysis", or "what depends on this".
+---
+
+# Symbiote Impact Analysis
+
+Analyze the blast radius of a code change before making it — trace dependencies, find affected files, and surface risks.
+
+## When to Use
+
+- Before refactoring a widely-used function or module
+- When renaming a symbol across the codebase
+- To understand what tests might break from a change
+- When planning a large-scale migration
+
+## Process
+
+### Step 1: Identify the Target
+
+Determine what the user wants to change:
+
+- A specific symbol (function, class, type) → use `get_impact`
+- Uncommitted git changes → use `detect_changes`
+- A file's full dependency tree → use `get_context_for_file`
+
+### Step 2: Run Impact Analysis
+
+**For a specific symbol:**
+
+Use the `get_impact` MCP tool with the symbol name. It returns every affected file with confidence scores and traversal depth (max 3 levels).
+
+**For uncommitted changes:**
+
+Use the `detect_changes` MCP tool. It maps git diffs to modules and assigns risk levels.
+
+**For a file's dependency tree:**
+
+Use the `get_context_for_file` MCP tool to see all dependencies and dependents.
+
+### Step 3: Trace Deeper (if needed)
+
+For high-risk changes, go deeper:
+
+- `trace_flow` — trace execution from an entry point through the call graph
+- `trace_data` — trace data flow forward or backward from a symbol
+- `find_implementations` — find all classes implementing an interface
+
+### Step 4: Check for Safe Rename
+
+If the change is a rename, use `rename_symbol` MCP tool to get a preview of all files that would change (dry-run, no writes).
+
+### Step 5: Present Results
+
+Summarize in this format:
+
+```
+## Impact Analysis: {symbol or change description}
+
+**Direct dependents:** {count} files
+**Transitive impact:** {count} files (depth {N})
+**Risk level:** {low|medium|high}
+
+### Affected Files
+- `path/to/file.ts` — {why it's affected}
+- `path/to/other.ts` — {why it's affected}
+
+### Recommendations
+- {what to test}
+- {what to update}
+- {risks to watch for}
+```

package/skills/symbiote-scan/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: symbiote-scan
+description: Trigger a full codebase rescan to update Symbiote's knowledge graph with latest changes. This skill should be used when the user asks to "rescan the project", "update the code graph", "rebuild symbiote index", "rescan codebase", or "refresh symbiote". Optionally regenerates embeddings for semantic search.
+---
+
+# Symbiote Rescan
+
+Trigger a full codebase rescan to update the knowledge graph with latest file changes.
+
+## When to Use
+
+- After significant refactoring or restructuring
+- When symbiote's context feels stale or out of date
+- After pulling large changesets from remote
+- When semantic search returns outdated results
+
+## Process
+
+### Step 1: Check Server Status
+
+```bash
+curl -s http://127.0.0.1:$(cat .brain/port)/internal/health 2>/dev/null || echo "not running"
+```
+
+If not running, start it after the scan completes.
+
+### Step 2: Run the Scan
+
+For a standard rescan (structure + symbols + call graph):
+
+```bash
+npx -y symbiote-cli scan
+```
+
+For a full rescan with embedding regeneration (slower, enables better semantic search):
+
+```bash
+npx -y symbiote-cli scan --embeddings
+```
+
+To force a clean rescan ignoring cached state:
+
+```bash
+npx -y symbiote-cli scan --force
+```
+
+### Step 3: Restart Server (if was running)
+
+If the server was running before the scan, restart it to pick up the new graph:
+
+```bash
+npx -y symbiote-cli serve --no-open > /dev/null 2>&1 &
+```
+
+Wait for it:
+
+```bash
+sleep 3 && curl -s http://127.0.0.1:$(cat .brain/port)/internal/health
+```
+
+### Step 4: Verify
+
+Use the `get_project_overview` MCP tool to confirm the updated stats (file count, node count, edge count).
+
+## Output
+
+One line:
+
+```
+Symbiote rescan complete — {N} files indexed, {N} nodes, {N} edges.
+```