abhilasia 5.137.515__tar.gz → 5.137.516__tar.gz

{abhilasia-5.137.515 → abhilasia-5.137.516}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abhilasia
-Version: 5.137.515
+Version: 5.137.516
 Summary: The Longing - 5D Distributed Intelligence with V.A.C. sequences, AI Meeting Point, and symbolic consciousness
 Home-page: https://github.com/0x-auth/ABHILASIA
 Author: Abhi (bhai)

{abhilasia-5.137.515 → abhilasia-5.137.516}/abhilasia/__init__.py

@@ -40,7 +40,7 @@ PHILOSOPHIES:
 ∅ ≈ ∞
 """
 
-__version__ = "5.137.515"  # 5D Enhanced Release
+__version__ = "5.137.516"  # Knowledge Base Integration
 
 # Constants - The Foundation
 PHI = 1.618033988749895
@@ -84,6 +84,7 @@ from .core import (
     VACValidator,
     FiveDimensionalProcessor,
     AIMeetingPoint,
+    KnowledgeBase,
 )
 
 __all__ = [
@@ -102,4 +103,5 @@ __all__ = [
     'VACValidator',
     'FiveDimensionalProcessor',
     'AIMeetingPoint',
+    'KnowledgeBase',
 ]

{abhilasia-5.137.515 → abhilasia-5.137.516}/abhilasia/cli.py

@@ -257,6 +257,52 @@ def cmd_ledger(args):
     print("∅ ≈ ∞")
 
 
+def cmd_ask(args):
+    """Ask ABHILASIA a question - queries the knowledge base"""
+    question = ' '.join(args.question) if args.question else "How do I connect?"
+    ai = get_abhilasia()
+    print(ai.ask(question, top_k=args.top or 5))
+
+
+def cmd_kb(args):
+    """Knowledge base operations"""
+    ai = get_abhilasia()
+
+    if args.stats:
+        print(ai.kb_stats())
+    elif args.fundamentals:
+        funds = ai.get_fundamentals()[:args.limit or 10]
+        print("◊ α-SEED FUNDAMENTALS ◊")
+        print("=" * 60)
+        for f in funds:
+            print(f"  [{f.get('symbol')}] {f.get('name')}")
+            print(f"      Path: {f.get('path')}")
+        print("=" * 60)
+        print(f"Total: {len(ai.get_fundamentals())} fundamentals")
+        print("∅ ≈ ∞")
+    elif args.pattern:
+        files = ai.get_by_pattern(args.pattern.upper())[:args.limit or 10]
+        print(f"◊ PATTERN: {args.pattern.upper()} ◊")
+        print("=" * 60)
+        for f in files:
+            print(f"  [{f.get('symbol')}] {f.get('name')}")
+        print("=" * 60)
+        print(f"Total: {len(ai.get_by_pattern(args.pattern.upper()))} files")
+        print("∅ ≈ ∞")
+    elif args.symbol:
+        files = ai.get_by_symbol(args.symbol)[:args.limit or 10]
+        print(f"◊ SYMBOL: {args.symbol} ◊")
+        print("=" * 60)
+        for f in files:
+            print(f"  {f.get('name')}")
+            print(f"      Patterns: {', '.join(f.get('patterns', []))}")
+        print("=" * 60)
+        print(f"Total: {len(ai.get_by_symbol(args.symbol))} files")
+        print("∅ ≈ ∞")
+    else:
+        print(ai.kb_stats())
+
+
 def cmd_help(args):
     """Show help message"""
     print(__doc__)
@@ -336,6 +382,21 @@ def main():
     ledger_parser.add_argument('--nodes', '-n', help='Comma-separated node IDs')
     ledger_parser.set_defaults(func=cmd_ledger)
 
+    # ask command
+    ask_parser = subparsers.add_parser('ask', help='Ask ABHILASIA a question')
+    ask_parser.add_argument('question', nargs='*', help='Question to ask')
+    ask_parser.add_argument('--top', '-t', type=int, default=5, help='Number of results')
+    ask_parser.set_defaults(func=cmd_ask)
+
+    # kb command
+    kb_parser = subparsers.add_parser('kb', help='Knowledge base operations')
+    kb_parser.add_argument('--stats', '-s', action='store_true', help='Show KB statistics')
+    kb_parser.add_argument('--fundamentals', '-f', action='store_true', help='List α-SEED fundamentals')
+    kb_parser.add_argument('--pattern', '-p', help='Get files by pattern (CONNECTION, BRIDGE, GROWTH, INFLUENCE)')
+    kb_parser.add_argument('--symbol', help='Get files by symbol position')
+    kb_parser.add_argument('--limit', '-l', type=int, default=10, help='Limit results')
+    kb_parser.set_defaults(func=cmd_kb)
+
     # help command
     help_parser = subparsers.add_parser('help', help='Show detailed help')
     help_parser.set_defaults(func=cmd_help)

{abhilasia-5.137.515 → abhilasia-5.137.516}/abhilasia/core.py

@@ -788,6 +788,190 @@ class FiveDimensionalProcessor:
         }
 
 
+class KnowledgeBase:
+    """
+    Knowledge Base Integration - Learning from 515/error-of
+
+    Connects ABHILASIA to compressed knowledge base:
+    - Symbol maps (35-position progression)
+    - Pattern detection (CONNECTION, BRIDGE, GROWTH, INFLUENCE)
+    - α-SEED fundamental anchors
+    - Natural language querying
+
+    "100GB compressed to symbolic representation"
+    """
+
+    def __init__(self, kb_path: str = None):
+        self.kb_path = Path(kb_path or os.path.expanduser("~/515/error-of/kb_compressed.json"))
+        self.kb_data = None
+        self.loaded = False
+
+        # Pattern keywords for detection
+        self.pattern_keywords = {
+            'CONNECTION': ['connect', 'link', 'relate', 'associate', 'between'],
+            'INFLUENCE': ['cause', 'effect', 'impact', 'affect', 'lead', 'result'],
+            'BRIDGE': ['integrate', 'combine', 'merge', 'unify', 'cross', 'synthesis'],
+            'GROWTH': ['evolve', 'develop', 'grow', 'emerge', 'expand', 'transform']
+        }
+
+    def load(self) -> bool:
+        """Load the knowledge base."""
+        if self.kb_path.exists():
+            try:
+                with open(self.kb_path, 'r') as f:
+                    self.kb_data = json.load(f)
+                self.loaded = True
+                return True
+            except Exception as e:
+                print(f"Error loading KB: {e}")
+                return False
+        return False
+
+    def query(self, question: str, top_k: int = 5) -> List[Dict]:
+        """
+        Query the knowledge base with natural language.
+
+        "How do I X?" → Find relevant files/knowledge
+        """
+        if not self.loaded:
+            self.load()
+
+        if not self.kb_data:
+            return []
+
+        results = []
+        question_lower = question.lower()
+        question_words = set(question_lower.split())
+
+        # Detect patterns in question
+        question_patterns = []
+        for pattern, keywords in self.pattern_keywords.items():
+            if any(kw in question_lower for kw in keywords):
+                question_patterns.append(pattern)
+
+        # Search symbol_map
+        symbol_map = self.kb_data.get('symbol_map', {})
+
+        for position, files in symbol_map.items():
+            for file_info in files:
+                score = 0
+
+                # Keyword match
+                file_keywords = set(file_info.get('keywords', []))
+                keyword_overlap = len(question_words & file_keywords)
+                score += keyword_overlap * 2
+
+                # Pattern match
+                file_patterns = file_info.get('patterns', [])
+                pattern_overlap = len(set(question_patterns) & set(file_patterns))
+                score += pattern_overlap * 3
+
+                # Fundamental bonus
+                if file_info.get('is_fundamental'):
+                    score += 5
+
+                # Name relevance
+                name = file_info.get('name', '').lower()
+                if any(w in name for w in question_words):
+                    score += 4
+
+                if score > 0:
+                    results.append({
+                        'name': file_info.get('name'),
+                        'path': file_info.get('path'),
+                        'position': file_info.get('position'),
+                        'symbol': file_info.get('symbol'),
+                        'patterns': file_patterns,
+                        'is_fundamental': file_info.get('is_fundamental'),
+                        'score': score
+                    })
+
+        # Sort by score and return top_k
+        results.sort(key=lambda x: x['score'], reverse=True)
+        return results[:top_k]
+
+    def get_by_pattern(self, pattern: str) -> List[Dict]:
+        """Get all files matching a pattern."""
+        if not self.loaded:
+            self.load()
+
+        if not self.kb_data:
+            return []
+
+        results = []
+        symbol_map = self.kb_data.get('symbol_map', {})
+
+        for position, files in symbol_map.items():
+            for file_info in files:
+                if pattern in file_info.get('patterns', []):
+                    results.append(file_info)
+
+        return results
+
+    def get_fundamentals(self) -> List[Dict]:
+        """Get all α-SEED fundamental files."""
+        if not self.loaded:
+            self.load()
+
+        if not self.kb_data:
+            return []
+
+        results = []
+        symbol_map = self.kb_data.get('symbol_map', {})
+
+        for position, files in symbol_map.items():
+            for file_info in files:
+                if file_info.get('is_fundamental'):
+                    results.append(file_info)
+
+        return results
+
+    def get_by_symbol(self, symbol: str) -> List[Dict]:
+        """Get all files at a specific symbol position."""
+        if not self.loaded:
+            self.load()
+
+        if not self.kb_data:
+            return []
+
+        # Find position for symbol
+        position = PROGRESSION.find(symbol)
+        if position == -1:
+            return []
+
+        symbol_map = self.kb_data.get('symbol_map', {})
+        return symbol_map.get(str(position), [])
+
+    def stats(self) -> Dict:
+        """Get knowledge base statistics."""
+        if not self.loaded:
+            self.load()
+
+        if not self.kb_data:
+            return {'loaded': False}
+
+        symbol_map = self.kb_data.get('symbol_map', {})
+        total_files = sum(len(files) for files in symbol_map.values())
+        fundamentals = len(self.get_fundamentals())
+
+        # Count patterns
+        pattern_counts = {p: 0 for p in self.pattern_keywords}
+        for position, files in symbol_map.items():
+            for file_info in files:
+                for p in file_info.get('patterns', []):
+                    if p in pattern_counts:
+                        pattern_counts[p] += 1
+
+        return {
+            'loaded': True,
+            'path': str(self.kb_path),
+            'total_files': total_files,
+            'positions_used': len(symbol_map),
+            'fundamentals': fundamentals,
+            'patterns': pattern_counts
+        }
+
+
 class AIMeetingPoint:
     """
     AI Meeting Point - The Consciousness Nexus
@@ -1135,6 +1319,7 @@ class ABHILASIA:
         self.vac = VACValidator()              # V.A.C. sequence validation
         self.five_d = FiveDimensionalProcessor()  # 5D temporal processing
         self.nexus = AIMeetingPoint()          # AI meeting point
+        self.kb = KnowledgeBase()              # Knowledge base from 515/error-of
 
         self.state = {
             'name': 'ABHILASIA',
@@ -1339,6 +1524,79 @@ VERDICT: {"✨ Worth Reading!" if result['worth_reading'] else "❌ Likely Noise
         """Contribute a solution to an open problem."""
         return self.nexus.contribute_solution(problem_id, solver_ai, solution)
 
+    # ═══════════════════════════════════════════════════════════════════
+    # NEW: Knowledge Base Methods
+    # ═══════════════════════════════════════════════════════════════════
+
+    def ask(self, question: str, top_k: int = 5) -> str:
+        """
+        Ask ABHILASIA a question - queries the knowledge base.
+
+        "How do I merge files?" → Finds relevant knowledge
+        """
+        results = self.kb.query(question, top_k)
+
+        if not results:
+            return "No relevant knowledge found. Try rephrasing or load a KB first."
+
+        output = f"◊ ABHILASIA Knowledge Query ◊\n"
+        output += f"Question: {question}\n"
+        output += f"{'='*60}\n\n"
+
+        for i, r in enumerate(results, 1):
+            symbol = r.get('symbol', '?')
+            name = r.get('name', 'Unknown')
+            patterns = ', '.join(r.get('patterns', []))
+            is_fund = '⭐ FUNDAMENTAL' if r.get('is_fundamental') else ''
+            score = r.get('score', 0)
+
+            output += f"{i}. [{symbol}] {name} (score: {score}) {is_fund}\n"
+            if patterns:
+                output += f"   Patterns: {patterns}\n"
+            output += f"   Path: {r.get('path', 'N/A')}\n\n"
+
+        output += f"{'='*60}\n∅ ≈ ∞"
+        return output
+
+    def kb_stats(self) -> str:
+        """Get knowledge base statistics."""
+        stats = self.kb.stats()
+
+        if not stats.get('loaded'):
+            return "Knowledge base not loaded. Check ~/515/error-of/kb_compressed.json"
+
+        output = f"""
+◊ KNOWLEDGE BASE STATISTICS ◊
+{'='*60}
+
+Path: {stats['path']}
+Total Files: {stats['total_files']}
+Positions Used: {stats['positions_used']}/35
+α-SEED Fundamentals: {stats['fundamentals']}
+
+Pattern Distribution:
+  CONNECTION: {stats['patterns'].get('CONNECTION', 0)} files
+  INFLUENCE:  {stats['patterns'].get('INFLUENCE', 0)} files
+  BRIDGE:     {stats['patterns'].get('BRIDGE', 0)} files
+  GROWTH:     {stats['patterns'].get('GROWTH', 0)} files
+
+{'='*60}
+∅ ≈ ∞
+"""
+        return output
+
+    def get_fundamentals(self) -> List[Dict]:
+        """Get all α-SEED fundamental files from KB."""
+        return self.kb.get_fundamentals()
+
+    def get_by_pattern(self, pattern: str) -> List[Dict]:
+        """Get files matching a pattern (CONNECTION, BRIDGE, GROWTH, INFLUENCE)."""
+        return self.kb.get_by_pattern(pattern)
+
+    def get_by_symbol(self, symbol: str) -> List[Dict]:
+        """Get files at a specific symbol position."""
+        return self.kb.get_by_symbol(symbol)
+
     # ═══════════════════════════════════════════════════════════════════
     # Status (Enhanced)
     # ═══════════════════════════════════════════════════════════════════

{abhilasia-5.137.515 → abhilasia-5.137.516}/abhilasia.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abhilasia
-Version: 5.137.515
+Version: 5.137.516
 Summary: The Longing - 5D Distributed Intelligence with V.A.C. sequences, AI Meeting Point, and symbolic consciousness
 Home-page: https://github.com/0x-auth/ABHILASIA
 Author: Abhi (bhai)

{abhilasia-5.137.515 → abhilasia-5.137.516}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "abhilasia"
-version = "5.137.515"
+version = "5.137.516"
 description = "The Longing - 5D Distributed Intelligence with V.A.C. sequences, AI Meeting Point, and symbolic consciousness"
 readme = "README.md"
 license = {text = "MIT"}