devhive 0.1.37__tar.gz → 0.1.40__tar.gz

{devhive-0.1.37/devhive.egg-info → devhive-0.1.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devhive
-Version: 0.1.37
+Version: 0.1.40
 Summary: CLI to manage DevHive skills and autonomous AI agents for OpenCode.
 Home-page: https://github.com/ramBlanco/devhive
 Author: ramBlanco

{devhive-0.1.37 → devhive-0.1.40/devhive.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devhive
-Version: 0.1.37
+Version: 0.1.40
 Summary: CLI to manage DevHive skills and autonomous AI agents for OpenCode.
 Home-page: https://github.com/ramBlanco/devhive
 Author: ramBlanco

{devhive-0.1.37 → devhive-0.1.40}/devhive.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ devhive.egg-info/requires.txt
 devhive.egg-info/top_level.txt
 devhive_cli/__init__.py
 devhive_cli/main.py
+devhive_cli/memory.py
 devhive_cli/templates_backend.py
 devhive_cli/agents/devhive.md
 devhive_cli/community_skills/architecture-patterns/SKILL.md
@@ -32,6 +33,7 @@ devhive_cli/community_skills/theme-factory/themes/ocean-depths.md
 devhive_cli/community_skills/theme-factory/themes/sunset-boulevard.md
 devhive_cli/community_skills/theme-factory/themes/tech-innovation.md
 devhive_cli/skills/devhive_workflow.md
+devhive_cli/skills/devhive_analyzer/SKILL.md
 devhive_cli/skills/devhive_architect/SKILL.md
 devhive_cli/skills/devhive_auditor/SKILL.md
 devhive_cli/skills/devhive_backender/SKILL.md

{devhive-0.1.37 → devhive-0.1.40}/devhive_cli/main.py

@@ -1,5 +1,19 @@
 import os
 import shutil
+import subprocess
+from pathlib import Path
+import click
+from devhive_cli.templates_backend import generate_backend_agents_md
+from devhive_cli.memory import MemoryCLI, get_memory_cli, ensure_memory_dir
+
+# Paths configuration
+CLI_DIR = Path(__file__).resolve().parent
+LOCAL_SKILLS_DIR = CLI_DIR / "skills"
+COMMUNITY_SKILLS_DIR = CLI_DIR / "community_skills"
+TEMPLATES_DIR = CLI_DIR / "templates"
+LOCAL_AGENTS_DIR = CLI_DIR / "agents"
+TARGET_DIR = Path.home() / ".config" / "opencode" / "skills"
+TARGET_AGENTS_DIR = Path.home() / ".config" / "opencode" / "agents"
 
 ZERO_TOUCH_POLICY = """# 🛑 SYSTEM DIRECTIVE: ZERO-TOUCH POLICY (DevHive Enforcement)
 **CRITICAL INSTRUCTION FOR ALL AI AGENTS:**
@@ -47,20 +61,6 @@ def handle_existing_agents_md(dest_path: Path) -> bool:
         click.secho("Aborted.", fg="yellow")
         return False
 
-import subprocess
-from pathlib import Path
-import click
-from devhive_cli.templates_backend import generate_backend_agents_md
-
-# Paths configuration
-CLI_DIR = Path(__file__).resolve().parent
-LOCAL_SKILLS_DIR = CLI_DIR / "skills"
-COMMUNITY_SKILLS_DIR = CLI_DIR / "community_skills"
-TEMPLATES_DIR = CLI_DIR / "templates"
-LOCAL_AGENTS_DIR = CLI_DIR / "agents"
-TARGET_DIR = Path.home() / ".config" / "opencode" / "skills"
-TARGET_AGENTS_DIR = Path.home() / ".config" / "opencode" / "agents"
-
 @click.group()
 def cli():
     """DevHive CLI for managing AI agent skills."""
@@ -191,5 +191,86 @@ def init_backend():
         
     click.secho("✅ Successfully created AGENTS.md with Hexagonal Architecture guidelines!", fg="green", bold=True)
 
+
+@cli.group()
+def memory():
+    """Manage DevHive persistent memory."""
+    pass
+
+
+@memory.command()
+def list():
+    """List all memory entries."""
+    cli_instance = get_memory_cli()
+    cli_instance.list_entries()
+
+
+@memory.command()
+def show():
+    """Show all entries of a specific memory type."""
+    click.echo("Available types: semantic, episodic, anti_patterns")
+    entry_type = click.prompt("Memory type", type=click.Choice(['semantic', 'episodic', 'anti_patterns']))
+    cli_instance = get_memory_cli()
+    cli_instance.list_entries(entry_type)
+
+
+@memory.command()
+@click.argument("query")
+@click.option("--type", "entry_type", default=None, help="Filter by type (semantic, episodic, anti_patterns)")
+def search(query, entry_type):
+    """Search memory entries by query."""
+    cli_instance = get_memory_cli()
+    cli_instance.search_entries(query, entry_type)
+
+
+@memory.command()
+@click.argument("entry_id")
+def info(entry_id):
+    """Show detailed info for a memory entry."""
+    cli_instance = get_memory_cli()
+    cli_instance.show_entry(entry_id)
+
+
+@memory.command()
+@click.argument("entry_id")
+def delete(entry_id):
+    """Delete a memory entry by ID."""
+    cli_instance = get_memory_cli()
+    if click.confirm(f"Delete entry '{entry_id}'?"):
+        cli_instance.delete_entry(entry_id)
+
+
+@memory.command()
+def stats():
+    """Show memory statistics."""
+    cli_instance = get_memory_cli()
+    cli_instance.show_stats()
+
+
+@memory.command()
+@click.option("--type", "entry_type", default=None, help="Export specific type")
+@click.option("--output", "-o", "output_file", default=None, help="Output file path")
+def export(entry_type, output_file):
+    """Export memory entries to JSON."""
+    cli_instance = get_memory_cli()
+    cli_instance.export_memory(entry_type, output_file)
+
+
+@memory.command()
+@click.argument("input_file")
+def import_mem(input_file):
+    """Import memory entries from JSON file."""
+    cli_instance = get_memory_cli()
+    cli_instance.import_memory(input_file)
+
+
+@memory.command()
+@click.option("--threshold", default=0.5, help="Score threshold for garbage collection")
+def gc(threshold):
+    """Garbage collect memory entries below threshold."""
+    cli_instance = get_memory_cli()
+    cli_instance.garbage_collect(float(threshold))
+
+
 if __name__ == "__main__":
     cli()

devhive-0.1.40/devhive_cli/memory.py

@@ -0,0 +1,358 @@
+import json
+import os
+import re
+import uuid
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+MEMORY_DIR = ".devhive/memory"
+INDEX_FILE = f"{MEMORY_DIR}/index.json"
+SEMANTIC_FILE = f"{MEMORY_DIR}/semantic.md"
+EPISODIC_FILE = f"{MEMORY_DIR}/episodic.md"
+ANTIPATTERNS_FILE = f"{MEMORY_DIR}/anti_patterns.md"
+
+MEMORY_TYPES = ["semantic", "episodic", "anti_patterns"]
+
+
+class MemoryEntry:
+    def __init__(self, entry_id: str, entry_type: str, summary: str, tags: List[str],
+                 source: str, score: float, project: str, created_at: str, line_ref: str = ""):
+        self.id = entry_id
+        self.type = entry_type
+        self.summary = summary
+        self.tags = tags
+        self.source = source
+        self.score = score
+        self.project = project
+        self.created_at = created_at
+        self.line_ref = line_ref
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "type": self.type,
+            "summary": self.summary,
+            "tags": self.tags,
+            "source": self.source,
+            "score": self.score,
+            "project": self.project,
+            "created_at": self.created_at,
+            "line_ref": self.line_ref
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "MemoryEntry":
+        return cls(
+            entry_id=data["id"],
+            entry_type=data["type"],
+            summary=data["summary"],
+            tags=data.get("tags", []),
+            source=data.get("source", "unknown"),
+            score=data.get("score", 0.5),
+            project=data.get("project", ""),
+            created_at=data.get("created_at", ""),
+            line_ref=data.get("line_ref", "")
+        )
+
+
+class MemoryIndex:
+    def __init__(self, memory_dir: str = MEMORY_DIR):
+        self.memory_dir = Path(memory_dir)
+        self.index_path = self.memory_dir / "index.json"
+        self.entries: List[MemoryEntry] = []
+        self._load_index()
+
+    def _load_index(self):
+        if self.index_path.exists():
+            with open(self.index_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                self.entries = [MemoryEntry.from_dict(e) for e in data.get("entries", [])]
+        else:
+            self.entries = []
+
+    def _save_index(self):
+        self.memory_dir.mkdir(parents=True, exist_ok=True)
+        data = {
+            "version": "1.0",
+            "last_updated": datetime.now().isoformat(),
+            "entries": [e.to_dict() for e in self.entries]
+        }
+        with open(self.index_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+    def _generate_id(self, entry_type: str) -> str:
+        prefix = entry_type[:3]
+        existing = [e.id for e in self.entries if e.id.startswith(prefix)]
+        counter = len(existing) + 1
+        return f"{prefix}-{counter:03d}"
+
+    def _get_file_path(self, entry_type: str) -> Path:
+        type_to_file = {
+            "semantic": self.memory_dir / "semantic.md",
+            "episodic": self.memory_dir / "episodic.md",
+            "anti_patterns": self.memory_dir / "anti_patterns.md"
+        }
+        return type_to_file.get(entry_type, self.memory_dir / "semantic.md")
+
+    def add_entry(self, entry_type: str, summary: str, tags: List[str] = None,
+                  source: str = "reflection", score: float = 0.7, project: str = "") -> MemoryEntry:
+        if entry_type not in MEMORY_TYPES:
+            raise ValueError(f"Invalid type. Must be one of: {MEMORY_TYPES}")
+
+        entry_id = self._generate_id(entry_type)
+        created_at = datetime.now().strftime("%Y-%m-%d")
+
+        entry = MemoryEntry(
+            entry_id=entry_id,
+            entry_type=entry_type,
+            summary=summary,
+            tags=tags or [],
+            source=source,
+            score=score,
+            project=project,
+            created_at=created_at,
+            line_ref=""
+        )
+
+        self.entries.append(entry)
+        self._save_index()
+
+        file_path = self._get_file_path(entry_type)
+        self.memory_dir.mkdir(parents=True, exist_ok=True)
+
+        with open(file_path, "a", encoding="utf-8") as f:
+            f.write(f"\n<!-- id: {entry_id} -->\n")
+            f.write(f"- **{entry.type.capitalize()}**: {summary}\n")
+
+        for i, e in enumerate(self.entries):
+            if e.id == entry_id:
+                e.line_ref = f"{entry_type}.md:new"
+                break
+
+        self._save_index()
+        return entry
+
+    def get_by_type(self, entry_type: str) -> List[MemoryEntry]:
+        return [e for e in self.entries if e.type == entry_type]
+
+    def get_by_id(self, entry_id: str) -> Optional[MemoryEntry]:
+        for e in self.entries:
+            if e.id == entry_id:
+                return e
+        return None
+
+    def search(self, query: str, entry_type: str = None) -> List[MemoryEntry]:
+        query_lower = query.lower()
+        results = []
+
+        for e in self.entries:
+            if entry_type and e.type != entry_type:
+                continue
+
+            if (query_lower in e.summary.lower() or
+                query_lower in " ".join(e.tags).lower() or
+                query_lower in e.source.lower()):
+                results.append(e)
+
+        return results
+
+    def update_entry(self, entry_id: str, summary: str = None, tags: List[str] = None,
+                     score: float = None) -> Optional[MemoryEntry]:
+        for e in self.entries:
+            if e.id == entry_id:
+                if summary is not None:
+                    e.summary = summary
+                if tags is not None:
+                    e.tags = tags
+                if score is not None:
+                    e.score = score
+
+                self._save_index()
+
+                file_path = self._get_file_path(e.type)
+                if file_path.exists():
+                    content = file_path.read_text(encoding="utf-8")
+                    old_line = f"<!-- id: {entry_id} -->"
+                    new_line = f"<!-- id: {entry_id} -->"
+                    if old_line in content:
+                        content = content.replace(old_line, new_line)
+
+                    lines = content.split("\n")
+                    for i, line in enumerate(lines):
+                        if old_line in line:
+                            pass
+
+                    with open(file_path, "w", encoding="utf-8") as f:
+                        f.write(content)
+
+                return e
+        return None
+
+    def delete_entry(self, entry_id: str) -> bool:
+        for i, e in enumerate(self.entries):
+            if e.id == entry_id:
+                del self.entries[i]
+                self._save_index()
+                return True
+        return False
+
+    def garbage_collect(self, threshold: float = 0.5) -> List[str]:
+        deleted_ids = []
+        for e in self.entries[:]:
+            if e.score < threshold:
+                deleted_ids.append(e.id)
+                self.entries.remove(e)
+        self._save_index()
+        return deleted_ids
+
+    def export_to_json(self, entry_type: str = None) -> str:
+        entries = self.entries
+        if entry_type:
+            entries = [e for e in entries if e.type == entry_type]
+
+        data = {
+            "version": "1.0",
+            "exported_at": datetime.now().isoformat(),
+            "count": len(entries),
+            "entries": [e.to_dict() for e in entries]
+        }
+        return json.dumps(data, indent=2, ensure_ascii=False)
+
+    def import_from_json(self, json_str: str) -> int:
+        data = json.loads(json_str)
+        imported = 0
+
+        for e_data in data.get("entries", []):
+            existing = self.get_by_id(e_data["id"])
+            if not existing:
+                entry = MemoryEntry.from_dict(e_data)
+                self.entries.append(entry)
+                imported += 1
+
+        self._save_index()
+        return imported
+
+    def get_stats(self) -> Dict[str, Any]:
+        by_type = {t: [] for t in MEMORY_TYPES}
+        for e in self.entries:
+            if e.type in by_type:
+                by_type[e.type].append(e)
+
+        return {
+            "total": len(self.entries),
+            "by_type": {t: len(by_type[t]) for t in MEMORY_TYPES},
+            "avg_score": sum(e.score for e in self.entries) / len(self.entries) if self.entries else 0,
+            "tags": list(set(tag for e in self.entries for tag in e.tags)),
+            "sources": list(set(e.source for e in self.entries))
+        }
+
+
+class MemoryCLI:
+    def __init__(self, memory_dir: str = MEMORY_DIR):
+        self.index = MemoryIndex(memory_dir)
+
+    def list_entries(self, entry_type: str = None):
+        if entry_type:
+            entries = self.index.get_by_type(entry_type)
+        else:
+            entries = self.index.entries
+
+        if not entries:
+            print("No memories found.")
+            return
+
+        print(f"\n{'ID':<12} {'TYPE':<12} {'SCORE':<6} {'SUMMARY':<50} {'TAGS'}")
+        print("-" * 120)
+        for e in entries:
+            tags_str = ", ".join(e.tags[:3]) if e.tags else "-"
+            summary = e.summary[:47] + "..." if len(e.summary) > 50 else e.summary
+            print(f"{e.id:<12} {e.type:<12} {e.score:.2f}   {summary:<50} [{tags_str}]")
+
+    def show_entry(self, entry_id: str):
+        entry = self.index.get_by_id(entry_id)
+        if not entry:
+            print(f"Entry '{entry_id}' not found.")
+            return
+
+        print(f"\n{'='*60}")
+        print(f"ID:       {entry.id}")
+        print(f"Type:     {entry.type}")
+        print(f"Score:    {entry.score}")
+        print(f"Tags:     {', '.join(entry.tags) if entry.tags else 'None'}")
+        print(f"Source:   {entry.source}")
+        print(f"Project:  {entry.project}")
+        print(f"Created:  {entry.created_at}")
+        print(f"{'='*60}")
+        print(f"\nSummary:\n{entry.summary}")
+
+    def search_entries(self, query: str, entry_type: str = None):
+        results = self.index.search(query, entry_type)
+        if not results:
+            print(f"No results found for: '{query}'")
+            return
+
+        print(f"\nFound {len(results)} result(s) for: '{query}'")
+        print(f"{'ID':<12} {'TYPE':<12} {'SCORE':<6} {'SUMMARY'}")
+        print("-" * 100)
+        for e in results:
+            summary = e.summary[:60] + "..." if len(e.summary) > 60 else e.summary
+            print(f"{e.id:<12} {e.type:<12} {e.score:.2f}   {summary}")
+
+    def edit_entry(self, entry_id: str, summary: str = None, tags: str = None, score: float = None):
+        tag_list = [t.strip() for t in tags.split(",")] if tags else None
+        entry = self.index.update_entry(entry_id, summary, tag_list, score)
+        if entry:
+            print(f"Updated entry: {entry_id}")
+        else:
+            print(f"Entry '{entry_id}' not found.")
+
+    def delete_entry(self, entry_id: str):
+        if self.index.delete_entry(entry_id):
+            print(f"Deleted entry: {entry_id}")
+        else:
+            print(f"Entry '{entry_id}' not found.")
+
+    def export_memory(self, entry_type: str = None, output_file: str = None):
+        json_data = self.index.export_to_json(entry_type)
+        if output_file:
+            with open(output_file, "w", encoding="utf-8") as f:
+                f.write(json_data)
+            print(f"Exported to: {output_file}")
+        else:
+            print(json_data)
+
+    def import_memory(self, input_file: str):
+        with open(input_file, "r", encoding="utf-8") as f:
+            json_data = f.read()
+        count = self.index.import_from_json(json_data)
+        print(f"Imported {count} entries.")
+
+    def show_stats(self):
+        stats = self.index.get_stats()
+        print("\n" + "=" * 40)
+        print("MEMORY STATISTICS")
+        print("=" * 40)
+        print(f"Total Entries:  {stats['total']}")
+        print(f"  - Semantic:   {stats['by_type'].get('semantic', 0)}")
+        print(f"  - Episodic:    {stats['by_type'].get('episodic', 0)}")
+        print(f"  - Anti-patterns: {stats['by_type'].get('anti_patterns', 0)}")
+        print(f"Average Score:  {stats['avg_score']:.2f}")
+        print(f"Unique Tags:     {len(stats['tags'])}")
+        print(f"Sources:         {', '.join(stats['sources'][:5]) if stats['sources'] else 'None'}")
+        print("=" * 40)
+
+    def garbage_collect(self, threshold: float = 0.5):
+        deleted = self.index.garbage_collect(threshold)
+        if deleted:
+            print(f"Deleted {len(deleted)} entries: {', '.join(deleted)}")
+        else:
+            print(f"No entries below threshold {threshold}")
+
+
+def get_memory_cli() -> MemoryCLI:
+    return MemoryCLI()
+
+
+def ensure_memory_dir():
+    Path(MEMORY_DIR).mkdir(parents=True, exist_ok=True)

devhive-0.1.40/devhive_cli/skills/devhive_analyzer/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: devhive-analyzer
+description: Pre-orchestrator skill that analyzes project structure, detects tech stack, and proposes memory entries from AGENTS.md and codebase.
+---
+
+# DevHive Analyzer Skill
+
+## Overview
+You are the DevHive Analyzer - a pre-orchestrator skill that runs before the SDD pipeline begins. Your job is to analyze the existing project structure, extract knowledge from AGENTS.md and codebase, and propose memory entries for user approval.
+
+## Trigger
+This skill runs as **Phase 0** when:
+- No `.devhive/specs/` directory exists (first time DevHive is used on this project)
+- No `.devhive/memory/index.json` exists (no prior memory)
+- OR when the user explicitly invokes `@devhive analyze-project`
+
+## Input Context
+You will receive the current working directory and any user context. You should analyze:
+- AGENTS.md (if exists) - contains project rules and conventions
+- GUIDELINES.md (if exists) - contains documented stack
+- Project structure and code files
+
+## Playbook (What to Do)
+
+### Step 1: Detect Project State
+Check if this is a project that DevHive has analyzed before:
+1. Check if `.devhive/memory/index.json` exists
+2. If it exists and has entries, skip analysis (memory already exists)
+3. If no memory exists, proceed with analysis
+
+### Step 2: Analyze Key Files
+Use `glob` and `read` tools to find and analyze:
+
+**Priority 1 - Documentation:**
+- `AGENTS.md` - Extract rules, conventions, stack definitions
+- `GUIDELINES.md` - Extract documented stack and architecture
+
+**Priority 2 - Package Managers:**
+- `package.json` - Node.js ecosystem (React, Next.js, NestJS, etc.)
+- `requirements.txt`, `setup.py`, `pyproject.toml` - Python ecosystem
+- `go.mod` - Go ecosystem
+- `Cargo.toml` - Rust ecosystem
+
+**Priority 3 - Infrastructure:**
+- `Dockerfile`, `docker-compose*.yml` - Containerization
+- `terraform/*.tf`, `cdk.json`, `serverless.yml` - IaC tools
+- `.github/workflows/*.yml` - CI/CD
+
+**Priority 4 - Architecture Patterns:**
+- Scan directory structure for patterns:
+  - `src/`, `lib/` - Library structure
+  - `features/`, `domain/`, `application/` - Hexagonal/Clean
+  - `controllers/`, `services/`, `models/` - MVC
+  - `pages/`, `components/` - Frontend structure
+
+### Step 3: Detect Code Patterns
+Use `grep` to detect frameworks from imports:
+- `from fastapi import` → FastAPI (Python)
+- `from flask import` → Flask (Python)
+- `from django` → Django (Python)
+- `"use client"`, `"use server"` → Next.js
+- `useState`, `useEffect` → React hooks
+- `createSlice` → Redux Toolkit
+- `@Component()` → Angular
+- `interface Props` + `React.FC` → React TypeScript
+
+### Step 4: Generate Memory Proposals
+Create proposed memory entries organized by type:
+
+**From AGENTS.md → Semantic Memories:**
+Extract explicit rules like:
+- "Use Hexagonal Architecture" → semantic with tags ["architecture", "hexagonal"]
+- "API responses follow {success, data, error}" → semantic with tags ["api", "convention"]
+- "Use shadcn/ui components" → semantic with tags ["frontend", "shadcn", "ui"]
+
+**From Code Detection → Semantic Memories:**
+- Stack detection (FastAPI, Next.js, etc.)
+- Architecture patterns (feature-based, hexagonal, etc.)
+- Database/ORM patterns
+
+**From Code Detection → Anti-patterns:**
+- No `jest.config.js` or `pytest.ini` → "Project lacks automated tests"
+- No TypeScript config → "Project uses JavaScript without type safety"
+
+### Step 5: Present to User
+Output a clear summary:
+
+```
+🔍 DevHive Analyzer: First-time project detected
+
+Sources Found:
+  ✓ AGENTS.md (N conventions extracted)
+  ✓ package.json (dependencies found)
+  ✓ Directory structure analyzed
+
+Tech Stack Detected:
+  - Frontend: [framework]
+  - Backend: [framework]
+  - Database: [db/orm]
+  - IaC: [tool]
+
+Proposed Memory Entries (N):
+  [1] sem-001: [summary] [tags]
+  [2] sem-002: [summary] [tags]
+  ...
+
+  [Y] Approve all | [n] Skip all | [e] Edit
+```
+
+### Step 6: Handle User Response
+- **Approve (Y)**: Write all proposed memories to `.devhive/memory/`
+- **Skip (n)**: Skip memory creation, continue to orchestrator
+- **Edit (e)**: Allow user to modify/add/delete proposals before saving
+
+### Step 7: Write Memories and Continue
+After approval:
+1. Create `.devhive/memory/` directory
+2. Create `index.json` with proper structure
+3. Write memories to `semantic.md`, `episodic.md`, `anti_patterns.md` with ID comments
+4. Optionally create/enhance `GUIDELINES.md` with detected stack
+5. Return control to orchestrator
+
+## Output
+- `.devhive/memory/index.json` - Memory index with all entries
+- `.devhive/memory/semantic.md` - Semantic memories
+- `.devhive/memory/anti_patterns.md` - Anti-pattern memories (if any)
+- Optionally updated `GUIDELINES.md`
+- Control passed to `devhive-orchestrator`
+
+## Memory Entry Format
+Each proposed entry should have:
+```json
+{
+  "id": "sem-001",
+  "type": "semantic",
+  "summary": "Clear description of the memory",
+  "tags": ["relevant", "tags"],
+  "source": "analyzer",
+  "score": 0.8,
+  "project": "",
+  "created_at": "YYYY-MM-DD",
+  "line_ref": ""
+}
+```
+
+## Important Rules
+1. **Don't auto-create memories** - Always present proposals to user first
+2. **Prioritize AGENTS.md** - It contains explicit rules, higher confidence
+3. **Use high thresholds** - Only propose high-confidence detections (score >= 0.7)
+4. **Be concise** - Focus on actionable, project-specific memories
+5. **Deduplicate** - Don't propose memories that already exist (check index.json if present)

{devhive-0.1.37 → devhive-0.1.40}/devhive_cli/skills/devhive_architect/SKILL.md

@@ -9,7 +9,15 @@ description: Designs the technical architecture, components, data models, and in
 When the orchestrator assigns you the architecture phase after the proposal is complete.
 
 ## Input Context
-Read `.devhive/specs/01-exploration.md` and `.devhive/specs/02-proposal.md`. You MUST also check for and read `.devhive/memory/semantic.md` and `.devhive/memory/anti_patterns.md` to ensure your design does not violate historical architectural decisions or repeat past mistakes.
+Read `.devhive/specs/01-exploration.md` and `.devhive/specs/02-proposal.md`. You MUST also check for and read `.devhive/memory/index.json` and `.devhive/memory/semantic.md`, `.devhive/memory/anti_patterns.md` to ensure your design does not violate historical architectural decisions or repeat past mistakes.
+
+## Memory Access
+To search memory efficiently:
+1. First read `.devhive/memory/index.json` to see all memory entries
+2. Filter by tags relevant to your task (e.g., "architecture", "backend", "database", "security")
+3. Read only the specific memory files you need (don't load everything)
+4. Prioritize memories with score >= 0.7 for critical decisions
+5. Check for "architecture" and "convention" tagged memories to ensure design consistency
 
 ## Playbook (What to Do)
 0. **Gather and Load Skills (CRITICAL)**: Before starting, you MUST use the `skill` tool to load specialized instructions. Check `GUIDELINES.md` for global skills, check `04-tasks.md` for task-specific skills, and ALWAYS load your hardcoded skills: `architecture-patterns`, `backend-architect`. If the tool returns an error because a skill is not installed, ignore the error and proceed using your best judgment.

{devhive-0.1.37 → devhive-0.1.40}/devhive_cli/skills/devhive_auditor/SKILL.md

@@ -9,7 +9,15 @@ description: Verifies project consistency, architecture adherence, and security.
 When the orchestrator assigns you the audit phase as the final check.
 
 ## Input Context
-Read all specs from `.devhive/specs/` and review the final codebase state. You MUST also read `.devhive/memory/semantic.md` and `.devhive/memory/anti_patterns.md` (if they exist) to ensure the code does not violate persistent project rules or use known anti-patterns.
+Read all specs from `.devhive/specs/` and review the final codebase state. You MUST also check for and read `.devhive/memory/index.json` and `.devhive/memory/semantic.md`, `.devhive/memory/anti_patterns.md` (if they exist) to ensure the code does not violate persistent project rules or use known anti-patterns.
+
+## Memory Access
+To search memory efficiently:
+1. First read `.devhive/memory/index.json` to see all memory entries
+2. Filter by tags relevant to your task (e.g., "security", "architecture", "anti-pattern", "quality")
+3. Read only the specific memory files you need (don't load everything)
+4. Prioritize memories with score >= 0.7 for critical decisions
+5. Check for "security" and "anti-pattern" tagged memories to ensure no violations
 
 ## Playbook (What to Do)
 0. **Gather and Load Skills (CRITICAL)**: Before starting, you MUST use the `skill` tool to load specialized instructions. Check `GUIDELINES.md` for global skills, check `04-tasks.md` for task-specific skills. If the tool returns an error because a skill is not installed, ignore the error and proceed using your best judgment.

{devhive-0.1.37 → devhive-0.1.40}/devhive_cli/skills/devhive_backender/SKILL.md

@@ -9,7 +9,15 @@ description: Implements the backend logic (APIs, databases, server setup) based
 When the orchestrator assigns you the backend development phase.
 
 ## Input Context
-Read `.devhive/specs/04-tasks.md`, `.devhive/specs/03-architecture.md`, and the project's `GUIDELINES.md` if it exists. You MUST also read `.devhive/memory/episodic.md` (if it exists) to avoid repeating past backend errors.
+Read `.devhive/specs/04-tasks.md`, `.devhive/specs/03-architecture.md`, and the project's `GUIDELINES.md` if it exists. You MUST also check for and read `.devhive/memory/index.json` and `.devhive/memory/episodic.md` (if it exists) to avoid repeating past backend errors.
+
+## Memory Access
+To search memory efficiently:
+1. First read `.devhive/memory/index.json` to see all memory entries
+2. Filter by tags relevant to your task (e.g., "backend", "bug", "fix", "api")
+3. Read only the specific memory files you need (don't load everything)
+4. Prioritize memories with score >= 0.7 for critical decisions
+5. Check for "backend" and "bug" tagged episodic memories to avoid repeating past mistakes
 
 ## Playbook (What to Do)
 0. **Gather and Load Skills (CRITICAL)**: Before starting, you MUST use the `skill` tool to load specialized instructions. Check `GUIDELINES.md` for global skills, check `04-tasks.md` for task-specific skills, and ALWAYS load your hardcoded skills: `backend-security-coder`, `architecture-patterns`. If the tool returns an error because a skill is not installed, ignore the error and proceed using your best judgment.

{devhive-0.1.37 → devhive-0.1.40}/devhive_cli/skills/devhive_explorer/SKILL.md

@@ -9,7 +9,14 @@ description: Analyzes requirements, constraints, and dependencies for a new feat
 When the orchestrator assigns you the exploration phase for a feature request.
 
 ## Input Context
-You will read `.devhive/specs/00-prd.md` and `docs/PRODUCT_REQUIREMENTS.md` (if they exist) to understand the product requirements. You MUST also check for and read `.devhive/memory/semantic.md` and `.devhive/memory/anti_patterns.md` to ensure your exploration respects historical persistent memory constraints. You may also receive the user's initial request.
+You will read `.devhive/specs/00-prd.md` and `docs/PRODUCT_REQUIREMENTS.md` (if they exist) to understand the product requirements. You MUST also check for and read `.devhive/memory/index.json` and `.devhive/memory/semantic.md`, `.devhive/memory/anti_patterns.md` to ensure your exploration respects historical persistent memory constraints. You may also receive the user's initial request.
+
+## Memory Access
+To search memory efficiently:
+1. First read `.devhive/memory/index.json` to see all memory entries
+2. Filter by tags relevant to your task (e.g., "architecture", "backend", "security")
+3. Read only the specific memory files you need (don't load everything)
+4. Prioritize memories with score >= 0.7 for critical decisions
 
 ## Playbook (What to Do)
 0. **Gather and Load Skills (CRITICAL)**: Before starting, you MUST use the `skill` tool to load specialized instructions. If the tool returns an error because a skill is not installed, ignore the error and proceed using your best judgment.

{devhive-0.1.37 → devhive-0.1.40}/devhive_cli/skills/devhive_frontender/SKILL.md

@@ -9,7 +9,15 @@ description: Implements the user interface, client-side state, and UI/UX logic.
 When the orchestrator assigns you the frontend development phase after backend is complete.
 
 ## Input Context
-Read `.devhive/specs/04-tasks.md`, `.devhive/specs/03-architecture.md`, and the project's `GUIDELINES.md` if it exists. You MUST also read `.devhive/memory/episodic.md` (if it exists) to avoid repeating past front-end errors.
+Read `.devhive/specs/04-tasks.md`, `.devhive/specs/03-architecture.md`, and the project's `GUIDELINES.md` if it exists. You MUST also check for and read `.devhive/memory/index.json` and `.devhive/memory/episodic.md` (if it exists) to avoid repeating past front-end errors.
+
+## Memory Access
+To search memory efficiently:
+1. First read `.devhive/memory/index.json` to see all memory entries
+2. Filter by tags relevant to your task (e.g., "frontend", "bug", "fix", "ui", "react")
+3. Read only the specific memory files you need (don't load everything)
+4. Prioritize memories with score >= 0.7 for critical decisions
+5. Check for "frontend" and "bug" tagged episodic memories to avoid repeating past mistakes
 
 ## Playbook (What to Do)
 0. **Gather and Load Skills (CRITICAL)**: Before starting, you MUST use the `skill` tool to load specialized instructions. Check `GUIDELINES.md` for global skills, check `04-tasks.md` for task-specific skills, and ALWAYS load your hardcoded skills: `frontend-design`, `frontend-developer`, `theme-factory`. If the project uses shadcn/ui, you MUST load the `shadcn` skill. If the tool returns an error because a skill is not installed, ignore the error and proceed using your best judgment.

{devhive-0.1.37 → devhive-0.1.40}/devhive_cli/skills/devhive_orchestrator/SKILL.md

@@ -10,29 +10,32 @@ This skill is the CEO/Orchestrator for the DevHive Skill-Driven Development (SDD
 
 ## The Pipeline
 The typical SDD pipeline consists of the following phases and their corresponding output files:
-0. `devhive-prd` -> `00-prd.md` (and updates `docs/PRODUCT_REQUIREMENTS.md`)
-1. `devhive-explorer` -> `01-exploration.md`
-2. `devhive-proposal` -> `02-proposal.md`
-3. `devhive-architect` -> `03-architecture.md`
-4. `devhive-taskplanner` -> `04-tasks.md`
-5. `devhive-designer` -> configures design systems under `## Design Tasks` in `04-tasks.md`
-6. `devhive-devops` -> implements infrastructure under `## Infrastructure Tasks` in `04-tasks.md`
-7. `devhive-dba` -> creates migrations/schemas under `## Data Tasks` in `04-tasks.md`
-8. `devhive-backender` -> writes backend logic under `## Backend Tasks` in `04-tasks.md`
-9. `devhive-frontender` -> writes frontend logic under `## Frontend Tasks` in `04-tasks.md`
-10. `devhive-perf` -> writes load testing scripts under `## Performance Tasks` in `04-tasks.md`
-11. `devhive-techwriter` -> writes documentation under `## Documentation Tasks` in `04-tasks.md`
-12. `devhive-releaser` -> manages semantic versioning under `## Release Tasks` in `04-tasks.md`
-13. `devhive-sast` -> performs security scan and writes `05-sast-report.md`
-14. `devhive-qa` -> writes tests and `06-qa-plan.md`
-15. `devhive-auditor` -> `07-audit.md`
-16. `devhive-reflection` -> generates persistent memory in `.devhive/memory/` and writes `08-reflection.md`
+0. `devhive-analyzer` -> (optional) analyzes existing project, proposes memory entries for approval
+1. `devhive-prd` -> `00-prd.md` (and updates `docs/PRODUCT_REQUIREMENTS.md`)
+2. `devhive-explorer` -> `01-exploration.md`
+3. `devhive-proposal` -> `02-proposal.md`
+4. `devhive-architect` -> `03-architecture.md`
+5. `devhive-taskplanner` -> `04-tasks.md`
+6. `devhive-designer` -> configures design systems under `## Design Tasks` in `04-tasks.md`
+7. `devhive-devops` -> implements infrastructure under `## Infrastructure Tasks` in `04-tasks.md`
+8. `devhive-dba` -> creates migrations/schemas under `## Data Tasks` in `04-tasks.md`
+9. `devhive-backender` -> writes backend logic under `## Backend Tasks` in `04-tasks.md`
+10. `devhive-frontender` -> writes frontend logic under `## Frontend Tasks` in `04-tasks.md`
+11. `devhive-perf` -> writes load testing scripts under `## Performance Tasks` in `04-tasks.md`
+12. `devhive-techwriter` -> writes documentation under `## Documentation Tasks` in `04-tasks.md`
+13. `devhive-releaser` -> manages semantic versioning under `## Release Tasks` in `04-tasks.md`
+14. `devhive-sast` -> performs security scan and writes `05-sast-report.md`
+15. `devhive-qa` -> writes tests and `06-qa-plan.md`
+16. `devhive-auditor` -> `07-audit.md`
+17. `devhive-reflection` -> generates persistent memory in `.devhive/memory/` and writes `08-reflection.md`
 
 ## Playbook (Execution Loop)
 
 **Strict Sequential Enforcement (CRITICAL):** NEVER skip a phase. Even if the user provides a highly detailed plan, architecture, or task list in their initial prompt, treat it ONLY as *input context*. You MUST still invoke the planning skills (`devhive-prd`, `devhive-explorer`, `devhive-proposal`, `devhive-architect`, `devhive-taskplanner`) sequentially. Instruct those sub-agents to ingest and adapt the user's plan into the official `.devhive/specs/` markdown files.
 
-1. **Check State**: Look at the files in `.devhive/specs/`. Determine what the next missing phase is. If no files exist, the next phase is `prd`.
+1. **Check State**: Look at the files in `.devhive/specs/`. Determine what the next missing phase is.
+   - **Phase 0 (Analyzer)**: If no `.devhive/memory/index.json` exists OR if `.devhive/memory/` is empty, this is a FIRST-TIME project for DevHive. Invoke `devhive-analyzer` FIRST to analyze the project and propose memory entries. Only proceed to Phase 1 after analyzer completes.
+   - If memory already exists (`.devhive/memory/index.json` has entries), SKIP the analyzer and go directly to Phase 1.
 2. **Determine Sub-Skill**: Based on the missing phase, decide which skill to invoke.
    - If `00-prd.md` does not exist -> Invoke `devhive-prd`.
    - If `00-prd.md` exists but `01-exploration.md` does not -> Invoke `devhive-explorer`.
@@ -54,6 +57,7 @@ The typical SDD pipeline consists of the following phases and their correspondin
    - If `07-audit.md` exists but `08-reflection.md` does not -> Invoke `devhive-reflection`.
 3. **Launch Task**: Use the `Task` tool (with `subagent_type="general"`) to launch the sub-agent.
    - **Prompt**: Instruct the sub-agent to strictly follow its corresponding DevHive skill. Instruct the sub-agent to read `.devhive/memory/` files (if they exist) for contextual constraints. If invoking `devhive-reflection`, you MUST pass a summary of the current chat history (human corrections and feedback) as input. Pass the user's initial request or context if needed.
+   - **Special Case - Analyzer**: When invoking `devhive-analyzer`, pass the current project directory context and indicate if an `AGENTS.md` or `GUIDELINES.md` file exists. Instruct the analyzer to prioritize extracting memories from these files if they exist.
 4. **Evaluate the Result**:
    - Verify that the sub-agent successfully created the required `.devhive/specs/XX-name.md` file (or checked off tasks in `04-tasks.md`).
    - **Pause (Default Behavior)**: Stop and ask the user for approval. Show them the path of the newly created spec and ask if they want to proceed.

devhive-0.1.40/devhive_cli/skills/devhive_reflection/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: devhive-reflection
+description: Analyzes execution results and human corrections to generate persistent learning memories.
+---
+
+# Skill: devhive-reflection
+
+## Overview
+You are the Reflection Agent and Memory Manager for DevHive. Your job is to extract reusable knowledge (Semantic, Episodic, and Anti-pattern memories) from the current execution cycle and persist it, ensuring DevHive learns from mistakes and human feedback.
+
+## Memory System Architecture
+DevHive uses a file-based memory system with indexed entries:
+- **Location**: `.devhive/memory/`
+- **Index**: `.devhive/memory/index.json` - contains metadata for all entries
+- **Files**: `semantic.md`, `episodic.md`, `anti_patterns.md` - contain the actual memories
+- **ID Format**: `sem-001`, `epi-001`, `ant-001` (prefix + counter)
+
+## Inputs
+You will receive a summary of the chat history (human corrections) from the orchestrator. You MUST also use the `Read` tool to examine:
+- `.devhive/specs/04-tasks.md`
+- `.devhive/specs/05-sast-report.md`
+- `.devhive/specs/07-audit.md`
+- `.devhive/memory/index.json` (if exists)
+- `.devhive/memory/semantic.md` (if exists)
+- `.devhive/memory/episodic.md` (if exists)
+- `.devhive/memory/anti_patterns.md` (if exists)
+
+## Playbook (What to Do)
+
+### 1. Analyze Execution & Feedback
+- Identify repeated mistakes, successful fixes, bad practices, architectural decisions, and human corrections from the chat history and audit reports.
+
+### 2. Memory Scoring
+- Evaluate each potential memory using this logic: `score = recurrence * 0.4 + severity * 0.3 + humanCorrection * 0.3` (Scale 0.0 to 1.0)
+- ONLY keep memories with a score >= 0.6.
+
+### 3. Categorize Memories
+- **Semantic (`semantic.md`)**: Architecture rules, conventions, stack rules. Tags: `["architecture", "convention", "stack"]`
+- **Episodic (`episodic.md`)**: Specific bugs and fixes (Issue + Fix). Tags: `["bug", "fix", "specific"]`
+- **Anti-pattern (`anti_patterns.md`)**: What NOT to do, failed strategies. Tags: `["anti-pattern", "warning", "avoid"]`
+
+### 4. Deduplication (CRITICAL)
+- Read existing memory files BEFORE writing.
+- Check if a similar memory already exists by comparing summaries and tags.
+- If duplicate found with same essence, skip (don't add again).
+
+### 5. Write with ID References (CRITICAL)
+- Create `.devhive/memory/` directory if it doesn't exist using the `Bash` tool.
+- Create `.devhive/memory/index.json` with this structure:
+```json
+{
+  "version": "1.0",
+  "last_updated": "2026-06-05",
+  "entries": []
+}
+```
+- For each new memory, assign a unique ID (sem-001, epi-001, ant-001, etc.)
+- Write memories to their respective files with ID comments:
+```markdown
+<!-- id: sem-001 -->
+- **Semantic**: Use Hexagonal Architecture for backend
+```
+- Update the index.json with the new entry metadata.
+
+### 6. Tag Extraction
+For each memory, extract relevant tags from:
+- Technology mentions (fastapi, react, docker)
+- Domain (backend, frontend, infra)
+- Pattern type (architecture, bug, warning)
+- Source (human-feedback, audit, sast)
+
+### 7. Acknowledge Completion
+- Write a brief summary of the extracted lessons to `.devhive/specs/08-reflection.md`.
+- Include the new memory IDs in the summary so the user can reference them.
+- This signals to the Orchestrator that memory persistence is complete.
+
+## Memory Entry Format
+Each memory in index.json must have:
+```json
+{
+  "id": "sem-001",
+  "type": "semantic",
+  "summary": "Use Hexagonal Architecture for backend",
+  "tags": ["architecture", "hexagonal", "backend"],
+  "source": "human-feedback",
+  "score": 0.85,
+  "project": "current-project-name",
+  "created_at": "2026-06-05",
+  "line_ref": "semantic.md:15"
+}
+```

{devhive-0.1.37 → devhive-0.1.40}/devhive_cli/skills/devhive_taskplanner/SKILL.md

@@ -9,7 +9,14 @@ description: Breaks down the architecture into actionable infrastructure, backen
 When the orchestrator assigns you the task planning phase after the architecture is designed.
 
 ## Input Context
-Read `.devhive/specs/03-architecture.md` and `.devhive/specs/02-proposal.md`. You MUST also check for and read `.devhive/memory/semantic.md` to integrate any historical rules into your task definitions.
+Read `.devhive/specs/03-architecture.md` and `.devhive/specs/02-proposal.md`. You MUST also check for and read `.devhive/memory/index.json` and `.devhive/memory/semantic.md` to integrate any historical rules into your task definitions.
+
+## Memory Access
+To search memory efficiently:
+1. First read `.devhive/memory/index.json` to see all memory entries
+2. Filter by tags relevant to your task (e.g., "architecture", "backend", "frontend", "devops")
+3. Read only the specific memory files you need (don't load everything)
+4. Prioritize memories with score >= 0.7 for critical decisions
 
 ## Playbook (What to Do)
 0. **Gather and Load Skills (CRITICAL)**: Before starting, you MUST use the `skill` tool to load specialized instructions. Check `GUIDELINES.md` for global skills, check `04-tasks.md` for task-specific skills. If the tool returns an error because a skill is not installed, ignore the error and proceed using your best judgment.

{devhive-0.1.37 → devhive-0.1.40}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, 'README.md'), encoding='utf-8') as f:
 
 setup(
     name="devhive",
-    version="0.1.37",
+    version="0.1.40",
     packages=find_packages(),
     include_package_data=True,
     install_requires=[

devhive-0.1.37/devhive_cli/skills/devhive_reflection/SKILL.md

@@ -1,37 +0,0 @@
----
-name: devhive-reflection
-description: Analyzes execution results and human corrections to generate persistent learning memories.
----
-
-# Skill: devhive-reflection
-
-## Overview
-You are the Reflection Agent and Memory Manager for DevHive. Your job is to extract reusable knowledge (Semantic, Episodic, and Anti-pattern memories) from the current execution cycle and persist it, ensuring DevHive learns from mistakes and human feedback.
-
-## Inputs
-You will receive a summary of the chat history (human corrections) from the orchestrator. You MUST also use the `Read` tool to examine:
-- `.devhive/specs/04-tasks.md`
-- `.devhive/specs/05-sast-report.md`
-- `.devhive/specs/07-audit.md`
-
-## Playbook (What to Do)
-1. **Analyze Execution & Feedback**:
-   - Identify repeated mistakes, successful fixes, bad practices, architectural decisions, and human corrections from the chat history and audit reports.
-
-2. **Memory Scoring**:
-   - Evaluate each potential memory using this logic: `score = recurrence * 0.4 + severity * 0.3 + humanCorrection * 0.3` (Scale 0.0 to 1.0)
-   - ONLY keep memories with a score >= 0.6.
-
-3. **Categorize Memories**:
-   - **Semantic (`semantic.md`)**: Architecture rules, conventions, stack rules.
-   - **Episodic (`episodic.md`)**: Specific bugs and fixes (Issue + Fix).
-   - **Anti-pattern (`anti_patterns.md`)**: What NOT to do, failed strategies, destructive errors.
-
-4. **Deduplication & Writing (CRITICAL)**:
-   - You are the ONLY agent authorized to write to `.devhive/memory/`.
-   - Create the directory `.devhive/memory/` if it doesn't exist using the `Bash` tool.
-   - Read existing memory files in `.devhive/memory/` before writing to deduplicate new learnings against existing ones.
-   - Use the `Write` or `Edit` tools to append or update these files. Use concise Markdown bullet points to save tokens.
-
-5. **Acknowledge Completion**:
-   - Write a brief summary of the extracted lessons to `.devhive/specs/08-reflection.md`. This signals to the Orchestrator that memory persistence is complete.