dasa-sradha-kit 5.0.0

package/.agent/scripts/arch_mapper.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+Dasa Mpu: The Cartographer (arch_mapper.py)
+Parses structural and dependency files (package.json, go.mod, requirements.txt)
+and outputs a highly compressed TOON map of the backend architecture.
+Saves Mpu from spending tokens reading massive dependency files line-by-line.
+"""
+
+import os
+import sys
+import json
+
+def parse_package_json():
+    """Extract dependencies and scripts from package.json."""
+    if not os.path.exists("package.json"):
+        return None
+        
+    try:
+        with open("package.json", "r") as f:
+            data = json.load(f)
+            
+        deps = list(data.get("dependencies", {}).keys())
+        scripts = list(data.get("scripts", {}).keys())
+        
+        return {
+            "type": "Node/JS",
+            "name": data.get("name", "Unknown"),
+            "core_deps": deps[:15], # Only take top 15 to save tokens
+            "total_deps": len(deps),
+            "scripts": scripts
+        }
+    except Exception:
+        return None
+
+def parse_go_mod():
+    """Extract module info from go.mod."""
+    if not os.path.exists("go.mod"):
+        return None
+        
+    try:
+        with open("go.mod", "r") as f:
+            lines = f.readlines()
+            
+        mod_name = "Unknown"
+        deps = []
+        for line in lines:
+            line = line.strip()
+            if line.startswith("module "):
+                mod_name = line.split()[1]
+            elif line and not line.startswith("go ") and not line.startswith("require") and not line.startswith(")"):
+                # Rough extraction of dependency names
+                parts = line.split()
+                if len(parts) > 0 and "." in parts[0]:
+                    deps.append(parts[0])
+                    
+        return {
+            "type": "Go Module",
+            "name": mod_name,
+            "core_deps": deps[:15],
+            "total_deps": len(deps)
+        }
+    except Exception:
+        return None
+
+def main():
+    print("🛡️  [Dasa Mpu] Initializing Architectural Cartographer...")
+    
+    arch_data = {}
+    
+    node_data = parse_package_json()
+    if node_data:
+         arch_data["Node"] = node_data
+         
+    go_data = parse_go_mod()
+    if go_data:
+         arch_data["Go"] = go_data
+         
+    if not arch_data:
+        print("🟡 [Mpu Cartographer] No recognized architecture definitions found. Pass.")
+        sys.exit(0)
+        
+    # Generate the highly compressed TOON map
+    toon_map = "# Architectural Map\n"
+    for ecosystem, data in arch_data.items():
+        toon_map += f"\n## {ecosystem}: {data.get('name')}\n"
+        toon_map += f"- **Total Dependencies:** {data.get('total_deps')}\n"
+        toon_map += f"- **Core Tools:** {', '.join(data.get('core_deps', []))}\n"
+        if "scripts" in data:
+            toon_map += f"- **Available Scripts:** {', '.join(data.get('scripts', []))}\n"
+            
+    os.makedirs(".artifacts", exist_ok=True)
+    out_path = ".artifacts/architecture_map.toon"
+    
+    with open(out_path, "w") as f:
+        f.write(toon_map)
+        
+    print(f"🟢 [Mpu Cartographer] Architecture successfully compressed into {out_path}.")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/compact_memory.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""
+Dasa Patih: Temporal Knowledge Graph Compactor (compact_memory.py)
+Imitates the 5-sector cognitive engine from `OpenMemory`.
+Compresses sprawling chat histories into specific TOON memory sectors.
+"""
+
+import os
+import sys
+import json
+import datetime
+
+def init_memory_vault():
+    return {
+        "episodic": [],     # Events (e.g., "User asked for a login page")
+        "semantic": [],     # Facts (e.g., "The API is hosted on port 8080")
+        "procedural": [],   # Skills (e.g., "How to deploy to Railway")
+        "emotional": [],    # Preferences (e.g., "User hates Tailwind")
+        "reflective": []    # Insights (e.g., "We should use Postgres instead of MySQL next time")
+    }
+
+def add_memory(vault, sector, content, context_id="system"):
+    """Adds a memory to the designated sector with temporal metadata."""
+    if sector not in vault:
+        print(f"Error: Unknown memory sector '{sector}'")
+        return
+        
+    memory_node = {
+        "content": content,
+        "valid_from": datetime.datetime.now().isoformat(),
+        "context": context_id
+    }
+    
+    vault[sector].append(memory_node)
+    return memory_node
+
+def main():
+    vault_path = ".artifacts/dasa_memory.toon"
+    os.makedirs(".artifacts", exist_ok=True)
+    
+    # Load existing vault or create new
+    if os.path.exists(vault_path):
+        with open(vault_path, "r") as f:
+            try:
+                vault = json.load(f)
+            except json.JSONDecodeError:
+                vault = init_memory_vault()
+    else:
+        vault = init_memory_vault()
+        
+    if len(sys.argv) < 3:
+        print("Usage: python3 compact_memory.py <sector> <memory_content>")
+        print("Sectors: episodic, semantic, procedural, emotional, reflective")
+        sys.exit(1)
+        
+    sector = sys.argv[1]
+    content = " ".join(sys.argv[2:])
+    
+    print(f"🧠 [Dasa Patih] Integrating memory into {sector.upper()} sector...")
+    add_memory(vault, sector, content)
+    
+    with open(vault_path, "w") as f:
+        json.dump(vault, f, indent=2)
+        
+    print(f"✅ Memory firmly consolidated in {vault_path}. Temporal Graph updated.")
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/complexity_scorer.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+Dasa Rsi: The Oracle's Lens (complexity_scorer.py)
+Performs static analysis on source code files to calculate cyclomatic complexity.
+Outputs only the specific 'hotspot' functions and line numbers, preventing Rsi 
+from having to read the entire file line-by-line.
+"""
+
+import sys
+import os
+import re
+
+def compute_complexity(code_chunk):
+    """
+    Very naive cyclomatic complexity estimator wrapper.
+    Counts branching keywords as a rough heuristics.
+    """
+    keywords = [
+        r'\bif\b', r'\belse\b', r'\bfor\b', r'\bwhile\b', 
+        r'\bswitch\b', r'\bcase\b', r'\bcatch\b', r'\b\?\b', r'&&', r'\|\|'
+    ]
+    complexity = 1
+    for kw in keywords:
+        complexity += len(re.findall(kw, code_chunk))
+    return complexity
+
+def analyze_file(filepath):
+    """Roughly chunks a file into blocks and scores them."""
+    if not os.path.exists(filepath):
+        return None
+        
+    with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+        lines = f.readlines()
+        
+    hotspots = []
+    chunk_size = 20 # Lines
+    
+    for i in range(0, len(lines), chunk_size):
+        chunk = "".join(lines[i:i+chunk_size])
+        score = compute_complexity(chunk)
+        
+        # Arbitrary threshold to define a "hotspot" (high branching logic)
+        if score >= 10:
+            hotspots.append({
+                "line_start": i + 1,
+                "line_end": min(i + chunk_size, len(lines)),
+                "score": score,
+                "preview": lines[i].strip()
+            })
+            
+    return hotspots
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3 complexity_scorer.py <file_path>")
+        sys.exit(1)
+        
+    target_file = sys.argv[1]
+    print(f"🛡️  [Dasa Rsi] Analyzing structural complexity of {target_file}...")
+    
+    hotspots = analyze_file(target_file)
+    
+    if hotspots is None:
+        print(f"🔴 [Rsi Lens] File {target_file} not found.")
+        sys.exit(1)
+        
+    if not hotspots:
+        print(f"🟢 [Rsi Lens] No significant structural hotspots detected in {os.path.basename(target_file)}.")
+        sys.exit(0)
+        
+    # Sort by highest complexity
+    hotspots.sort(key=lambda x: x["score"], reverse=True)
+    
+    print("\n🔍 HIGH COMPLEXITY HOTSPOTS DETECTED:")
+    for h in hotspots[:5]: # Only show top 5 worst offenders
+        print(f"  - Lines {h['line_start']}-{h['line_end']} | Complexity Score: {h['score']} | Context: `{h['preview'][:40]}...`")
+        
+    print("\n[Rsi Lens] Recommend running `view_file` exclusively on these line ranges.")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/context_mapper.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Dasa Patih: Zero-Dependency Context Mapper (context_mapper.py)
+Replicates the focused vector mapping of `amdb` and `osgrep` but runs 100% natively.
+Extracts class and function signatures from Python/JS/TS/Go/Rust codebases
+to build highly compressed `.artifacts/context.toon` snippets for the LLM.
+"""
+
+import sys
+import os
+import re
+import ast
+from pathlib import Path
+
+def parse_python(filepath: Path):
+    signatures = []
+    try:
+        content = filepath.read_text(encoding="utf-8")
+        tree = ast.parse(content)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
+                signatures.append(f"def {node.name}(...)")
+            elif isinstance(node, ast.ClassDef):
+                signatures.append(f"class {node.name}")
+    except Exception:
+        pass
+    return signatures
+
+def parse_regex(filepath: Path, class_pattern, func_pattern):
+    signatures = []
+    try:
+        content = filepath.read_text(encoding="utf-8")
+        lines = content.splitlines()
+        for line in lines:
+            if re.search(class_pattern, line):
+                signatures.append(line.strip().rstrip('{'))
+            elif re.search(func_pattern, line):
+                signatures.append(line.strip().rstrip('{'))
+    except Exception:
+        pass
+    return signatures
+
+def parse_file(filepath: Path):
+    ext = filepath.suffix
+    if ext == ".py":
+        return parse_python(filepath)
+    elif ext in [".js", ".ts", ".jsx", ".tsx"]:
+        return parse_regex(filepath, r"^\s*(export\s+)?class\s+\w+", r"^\s*(export\s+)?(async\s+)?function\s+\w+|^\s*(export\s+)?const\s+\w+\s*=\s*\(.*\)\s*=>")
+    elif ext == ".go":
+        return parse_regex(filepath, r"^\s*type\s+\w+\s+struct", r"^\s*func\s+")
+    elif ext == ".rs":
+        return parse_regex(filepath, r"^\s*(pub\s+)?(struct|enum|trait)\s+\w+", r"^\s*(pub\s+)?(async\s+)?fn\s+\w+")
+    return []
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: context_mapper.py <directory>")
+        sys.exit(1)
+
+    target_dir = Path(sys.argv[1])
+    if not target_dir.exists() or not target_dir.is_dir():
+        print(f"Directory {target_dir} not found.")
+        sys.exit(1)
+        
+    print(f"🗺️ Dasa Patih: Mapping codebase context for {target_dir}...")
+    
+    context_lines = [f"# Codebase Context: {target_dir.name}\n"]
+    
+    for root, dirs, files in os.walk(target_dir):
+        # Exclude typical noise
+        dirs[:] = [d for d in dirs if d not in [".git", "node_modules", "target", "dist", ".gemini", ".artifacts"]]
+        for file in files:
+            ext = Path(file).suffix
+            if ext in [".py", ".js", ".ts", ".jsx", ".tsx", ".go", ".rs"]:
+                filepath = Path(root) / file
+                sigs = parse_file(filepath)
+                if sigs:
+                    rel_path = filepath.relative_to(target_dir)
+                    context_lines.append(f"\n## {rel_path}")
+                    for sig in sigs:
+                        context_lines.append(f"- {sig}")
+
+    artifacts_dir = target_dir / ".artifacts"
+    artifacts_dir.mkdir(exist_ok=True)
+    out_file = artifacts_dir / "context.toon"
+    
+    out_file.write_text("\n".join(context_lines), encoding="utf-8")
+    print(f"✅ Context successfully compressed into {out_file}")
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/design_engine.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+Dasa Mpu / Dasa Nala: The Design Engine (design_engine.py)
+Assimilates logic from `ui-ux-pro-max` and `design-rules-ai`.
+Prevents AI hallucination by programmatically generating a strict `MASTER.md` 
+design system with hardcoded spacing, radiuses, and industry-specific palettes.
+"""
+
+import os
+import sys
+import json
+
+# Statically enforce design-rules-ai constraints
+ANTI_AI_CONSTRAINTS = [
+    "NEVER use generic placeholder names like 'Acme Corp' or 'John Doe'. Use realistic data.",
+    "NEVER generate raw SVG code. You MUST use standard libraries like Lucide or Heroicons.",
+    "NEVER use random spacing like 7px or 13px. You MUST adhere to the [4, 8, 12, 16, 24, 32, 48, 64] scale.",
+    "NEVER use random border-radiuses. 4px for inputs, 8px for cards, 12px for modals, 9999px for pills.",
+    "NEVER use rainbow colors. Limit to 1 primary, 1 secondary, and neutral grays."
+]
+
+# Basic industry reasoning matrix (inspired by ui-ux-pro-max)
+INDUSTRY_MATRIX = {
+    "saas": {
+        "style": "Glassmorphism / Minimal",
+        "colors": {"primary": "#0F172A", "secondary": "#3B82F6", "accent": "#10B981"},
+        "fonts": "Inter / Roboto Mono",
+        "radius": "8px cards, 4px inputs"
+    },
+    "fintech": {
+        "style": "High-Contrast / Trust-focused",
+        "colors": {"primary": "#000000", "secondary": "#111827", "accent": "#059669"},
+        "fonts": "Plus Jakarta Sans",
+        "radius": "4px universal"
+    },
+    "healthcare": {
+        "style": "Clean / Accessible (WCAG AA)",
+        "colors": {"primary": "#FFFFFF", "secondary": "#0284C7", "accent": "#14B8A6"},
+        "fonts": "Open Sans",
+        "radius": "12px soft"
+    },
+    "ecommerce": {
+        "style": "Hero-Centric / Conversion Focused",
+        "colors": {"primary": "#18181B", "secondary": "#F43F5E", "accent": "#F59E0B"},
+        "fonts": "Outfit / Playfair Display",
+        "radius": "0px sharp or 9999px pills"
+    }
+}
+
+def generate_design_system(industry):
+    """Generate a highly constrained MASTER.md design TOON."""
+    target = industry.lower()
+    
+    # Default to SaaS if unknown
+    if target not in INDUSTRY_MATRIX:
+        target = "saas"
+        
+    specs = INDUSTRY_MATRIX[target]
+    
+    toon = f"""# MASTER DESIGN SYSTEM: {industry.upper()}
+
+> **CRITICAL**: This document overrides all LLM design instincts. Do not hallucinate styles outside of this spec.
+
+## 1. Visual Identity
+- **Design Style:** {specs['style']}
+- **Primary Font:** {specs['fonts']}
+- **Border Radius Rule:** {specs['radius']}
+
+## 2. Color Palette (Strict Limit)
+- **Primary:** `{specs['colors']['primary']}`
+- **Secondary:** `{specs['colors']['secondary']}`
+- **Accent/CTA:** `{specs['colors']['accent']}`
+
+## 3. The 'Anti-AI' Constraints (MANDATORY)
+"""
+    for rule in ANTI_AI_CONSTRAINTS:
+        toon += f"- {rule}\n"
+        
+    toon += "\n## 4. Spacing Scale (Strict)\n"
+    toon += "You are ONLY allowed to use these sizing steps (rem/px):\n"
+    toon += "`[0.25rem/4px, 0.5rem/8px, 0.75rem/12px, 1rem/16px, 1.5rem/24px, 2rem/32px, 3rem/48px, 4rem/64px]`\n"
+
+    return toon
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3 design_engine.py <industry_type>")
+        print("Options: saas, fintech, healthcare, ecommerce")
+        sys.exit(1)
+        
+    industry = sys.argv[1]
+    
+    print(f"🛡️  [Dasa Mpu] Booting Design Engine for industry: {industry}...")
+    
+    toon_content = generate_design_system(industry)
+    
+    os.makedirs(".design-memory", exist_ok=True)
+    out_path = ".design-memory/MASTER.md"
+    
+    with open(out_path, "w") as f:
+        f.write(toon_content)
+        
+    print(f"🟢 [Mpu Architect] Strict Design System generated at {out_path}.")
+    print("Dasa Nala is now bound by these cognitive constraints.")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/design_memory_sync.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""
+Dasa Nala: The Vision Bridge (design_memory_sync.py)
+Natively integrates with the `memvid/design-memory` architecture.
+Reads the highly semantic markdown files generated by design-memory OCR 
+and compiles them into a single, token-compressed TOON block for Dasa Nala.
+Prevents "vision blowout" by substituting 40 PNG mockups with pure semantic text.
+"""
+
+import os
+import sys
+
+def check_design_memory():
+    """Verify that the user actually has a populated .design-memory folder."""
+    base_path = ".design-memory"
+    if not os.path.exists(base_path):
+        return False
+        
+    # It needs to have at least one of the core files
+    core_files = ["style.md", "layout.md", "components.md", "reference.md"]
+    return any(os.path.exists(os.path.join(base_path, f)) for f in core_files)
+
+def read_and_compress(filepath, max_lines=150):
+    """Read a markdown file and truncate if it's insanely long to protect context."""
+    if not os.path.exists(filepath):
+        return ""
+        
+    try:
+        with open(filepath, "r", encoding='utf-8') as f:
+            lines = f.readlines()
+            
+        if len(lines) > max_lines:
+             # Take front matter and trailing summary, drop the middle
+             head = "".join(lines[:max_lines//2])
+             tail = "".join(lines[-(max_lines//2):])
+             return head + "\n\n... [CONTENT COMPRESSED TO SAVE TOKENS] ...\n\n" + tail
+        return "".join(lines)
+    except Exception as e:
+        return f"Error reading {filepath}: {e}"
+
+def main():
+    print("🛡️  [Dasa Nala] Analyzing `.design-memory/` Vision Bridge...")
+    
+    if not check_design_memory():
+        print("🟡 [Nala Vision Bridge] No `.design-memory/` output detected. Skipping Vision Bridge.")
+        sys.exit(0)
+        
+    print("⚡ [Nala Vision Bridge] `memvid/design-memory` artifacts detected. Compressing UI semantics...")
+    
+    # We prioritize the files that actually tell the AI how to build the UI
+    files_to_sync = {
+        "Global Styles": ".design-memory/style.md",
+        "Layout Spec": ".design-memory/layout.md",
+        "Component Recipes": ".design-memory/components.md"
+    }
+    
+    bridge_output = "# Vision Bridge: Compiled Design Memory\n\n"
+    bridge_output += "> Automatically generated from `memvid/design-memory`. This replaces the need to analyze raw PNGs.\n\n"
+    
+    for section_name, path in files_to_sync.items():
+        if os.path.exists(path):
+            content = read_and_compress(path)
+            bridge_output += f"## {section_name}\n\n{content}\n\n---\n\n"
+            
+    # Also grab UI Skills if they exist
+    skills_dir = ".design-memory/skills"
+    if os.path.isdir(skills_dir):
+        bridge_output += "## UI Implementation Skills\n\n"
+        for root, _, files in os.walk(skills_dir):
+            for file in files:
+                if file.endswith(".md"):
+                     skill_path = os.path.join(root, file)
+                     skill_content = read_and_compress(skill_path, max_lines=50)
+                     bridge_output += f"### {file}\n{skill_content}\n\n"
+                     
+    os.makedirs(".artifacts", exist_ok=True)
+    out_path = ".artifacts/vision_bridge.toon"
+    
+    with open(out_path, "w", encoding='utf-8') as f:
+        f.write(bridge_output)
+        
+    print(f"🟢 [Nala Vision Bridge] Successfully compressed UI Mockups into semantic text.")
+    print(f"Context saved to {out_path}.")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/lint_fixer.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""
+Dasa Nala: Auto-Formatter (lint_fixer.py)
+Detects installed linting/formatting tools and automatically fixes fixable syntax.
+Prevents the AI from wasting LLM tokens manually inserting missing semicolons or spaces.
+"""
+
+import os
+import sys
+import subprocess
+
+def detect_and_run_formatters():
+    """Detect formatters in the project and run their auto-fix commands."""
+    fixed_something = False
+    
+    # 1. Javascript / Typescript (Prettier/ESLint)
+    if os.path.exists("package.json"):
+        with open("package.json", "r") as f:
+            content = f.read()
+            
+        if '"prettier"' in content or '"prettier:' in content:
+            print("⚡ [Nala Formatter] Prettier detected. Running `npx prettier --write .`")
+            try:
+                subprocess.run(["npx", "prettier", "--write", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                fixed_something = True
+            except Exception:
+                pass
+                
+        if '"eslint"' in content:
+            print("⚡ [Nala Formatter] ESLint detected. Running `npx eslint --fix .`")
+            try:
+                subprocess.run(["npx", "eslint", "--fix", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                fixed_something = True
+            except Exception:
+                pass
+
+    # 2. Python (Ruff / Black)
+    if os.path.exists("pyproject.toml") or os.path.exists("requirements.txt"):
+        try:
+            # Check if ruff is available
+            subprocess.run(["ruff", "--version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+            print("⚡ [Nala Formatter] Ruff detected. Running `ruff check --fix .` and `ruff format .`")
+            subprocess.run(["ruff", "check", "--fix", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            subprocess.run(["ruff", "format", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            fixed_something = True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+             try:
+                 subprocess.run(["black", "--version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+                 print("⚡ [Nala Formatter] Black detected. Running `black .`")
+                 subprocess.run(["black", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                 fixed_something = True
+             except (subprocess.CalledProcessError, FileNotFoundError):
+                 pass
+
+    # 3. Go (gofmt)
+    if os.path.exists("go.mod"):
+        print("⚡ [Nala Formatter] Go module detected. Running `gofmt -w .`")
+        try:
+             subprocess.run(["gofmt", "-w", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+             fixed_something = True
+        except Exception:
+             pass
+
+    return fixed_something
+
+def main():
+    print("🛡️  [Dasa Nala] Initializing Auto-Formatter...")
+    
+    ran_formatters = detect_and_run_formatters()
+    
+    if ran_formatters:
+        print("🟢 [Nala Formatter] Code styling automatically fixed where possible. AI tokens saved.")
+    else:
+        print("🟡 [Nala Formatter] No supported formatters detected in project root. Skipping.")
+        
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()