comet-memory 0.1.0__py3-none-any.whl

comet/__init__.py

@@ -0,0 +1,27 @@
+"""CoMeT: Cognitive Memory OS - Dynamic Resolution Memory System"""
+from comet.schemas import MemoryNode, CognitiveLoad, CoMeTState, L1Memory, RetrievalResult
+from comet.sensor import CognitiveSensor
+from comet.compacter import MemoryCompacter
+from comet.storage import MemoryStore
+from comet.vector_index import VectorIndex
+from comet.retriever import Retriever
+from comet.consolidator import Consolidator
+from comet.orchestrator import CoMeT, MessageInput
+from comet.config import scope
+
+__all__ = [
+    'CoMeT',
+    'MemoryNode',
+    'CognitiveLoad',
+    'CoMeTState',
+    'L1Memory',
+    'RetrievalResult',
+    'CognitiveSensor',
+    'MemoryCompacter',
+    'MemoryStore',
+    'VectorIndex',
+    'Retriever',
+    'Consolidator',
+    'scope',
+]
+

comet/cli.py

@@ -0,0 +1,390 @@
+"""CoMeT CLI: Command-line interface using ato scope as entry point."""
+import json
+import os
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+# Auto-load .env from CoMeT project root
+_DEFAULT_STORE = str(Path.home()/'.comet'/'memory_store')
+
+for _env_candidate in [Path.cwd()/'.env', Path.home()/'.comet'/'.env']:
+    if _env_candidate.exists():
+        for line in _env_candidate.read_text().splitlines():
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            key, _, value = line.partition('=')
+            if key and _ == '=':
+                os.environ.setdefault(key.strip(), value.strip())
+        break
+
+from loguru import logger
+
+from comet.config import scope
+from comet.orchestrator import CoMeT
+
+logger.disable('comet')
+
+
+class SessionManager:
+    """Session management layer.
+
+    Canonical implementation: comet.skills.session.SessionManager
+    This class is kept for backward compatibility.
+    """
+
+    def __init__(self, store_path: str):
+        from comet.skills.session import SessionManager as _SM
+        self._impl = _SM(store_path)
+
+    def create(self, session_id: str = '', title: str = '') -> str:
+        return self._impl.create(session_id=session_id, title=title)
+
+    def increment_node_count(self, session_id: str):
+        self._impl.increment_node_count(session_id)
+
+    def list_recent(self, limit: int = 10) -> list[dict]:
+        return self._impl.list_recent(limit)
+
+    def exists(self, session_id: str) -> bool:
+        return self._impl.exists(session_id)
+
+
+
+@scope.observe(default=True)
+def cli_defaults(config):
+    config.command = ''
+    config.text = ''
+    config.file = ''
+    config.node_id = ''
+    config.depth = 2
+    config.tag = ''
+    config.summary_query = ''
+    config.trigger_query = ''
+    config.top_k = 5
+    # store command fields
+    config.summary = ''
+    config.trigger = ''
+    config.topic_tags = ''
+    config.raw_text = ''
+    config.recall_mode = 'active'
+    # session fields
+    config.session_id = ''
+    config.session_title = ''
+    # fixed storage path (overrides core's relative ./memory_store)
+    _store_root = os.environ.get('COMET_STORE', _DEFAULT_STORE)
+    config.storage.base_path = _store_root
+    config.storage.raw_path = str(Path(_store_root)/'raw')
+    config.retrieval.vector_db_path = str(Path(_store_root)/'vectors')
+
+
+def _get_session_nodes(memo, session_id):
+    """Get all nodes belonging to a session (reads node files, not index)."""
+    nodes = []
+    for meta in memo._store.list_all():
+        node = memo._store.get_node(meta['node_id'])
+        if node and node.session_id == session_id:
+            nodes.append(node)
+    return nodes
+
+
+@scope
+def main(config):
+    if not config.command:
+        _print_usage()
+        return
+
+    store_path = config.get('storage', {}).get('base_path', './memory_store')
+    session_mgr = SessionManager(store_path)
+
+    # Commands that don't need CoMeT instance
+    if config.command == 'init':
+        cmd_init(session_mgr, config)
+        return
+    if config.command == 'sessions':
+        cmd_sessions(session_mgr, config)
+        return
+
+    memo = CoMeT(config)
+    commands = {
+        'add': cmd_add,
+        'store': cmd_store,
+        'compact': cmd_compact,
+        'index': cmd_index,
+        'read': cmd_read,
+        'search': cmd_search,
+        'retrieve': cmd_retrieve,
+        'close': cmd_close,
+        'tags': cmd_tags,
+        'recall': cmd_recall,
+    }
+
+    handler = commands.get(config.command)
+    if not handler:
+        print(f'Unknown command: {config.command}')
+        _print_usage()
+        return
+    handler(memo, config, session_mgr)
+
+
+def cmd_init(session_mgr, config):
+    session_id = session_mgr.create(
+        session_id=config.session_id,
+        title=config.session_title,
+    )
+    print(f'Session: {session_id}')
+
+    recent = session_mgr.list_recent(5)
+    past = [s for s in recent if s['session_id'] != session_id]
+    if past:
+        print()
+        print('Recent sessions:')
+        for s in past:
+            title = s.get('title', '')
+            title_str = f' — {title}' if title else ''
+            print(f'  {s["session_id"]} ({s.get("node_count", 0)} nodes){title_str}')
+
+
+def cmd_sessions(session_mgr, config):
+    recent = session_mgr.list_recent(20)
+    if not recent:
+        print('No sessions found')
+        return
+    for s in recent:
+        title = s.get('title', '')
+        title_str = f' — {title}' if title else ''
+        print(f'{s["session_id"]} ({s.get("node_count", 0)} nodes, {s["created_at"][:10]}){title_str}')
+
+
+def cmd_add(memo, config, session_mgr):
+    if config.file:
+        text = Path(config.file).read_text(encoding='utf-8')
+    else:
+        text = config.text
+
+    if not text.strip():
+        print('Error: empty input. Use text:="your text" or file:=path')
+        return
+
+    node = memo.add(text)
+    if node:
+        if config.session_id:
+            node.session_id = config.session_id
+            memo._store.save_node(node)
+            session_mgr.increment_node_count(config.session_id)
+        print(f'Compacted → {node.node_id}')
+        print(f'  Summary: {node.summary}')
+        print(f'  Trigger: {node.trigger}')
+        tags = ', '.join(node.topic_tags)
+        print(f'  Tags: {tags}')
+    else:
+        load = memo.last_load
+        buf_size = len(memo.l1_buffer)
+        if load:
+            print(f'Buffered (flow={load.logic_flow}, load={load.load_level}, buffer={buf_size})')
+        else:
+            print(f'Buffered (buffer={buf_size})')
+
+
+def cmd_store(memo, config, session_mgr):
+    if config.file:
+        entries = json.loads(Path(config.file).read_text(encoding='utf-8'))
+        if isinstance(entries, dict):
+            entries = [entries]
+        for entry in entries:
+            node = memo.store_direct(
+                summary=entry['summary'],
+                trigger=entry['trigger'],
+                raw_text=entry.get('raw_text', ''),
+                topic_tags=entry.get('topic_tags', []),
+                recall_mode=entry.get('recall_mode', 'active'),
+                session_id=config.session_id or '',
+            )
+            if config.session_id:
+                session_mgr.increment_node_count(config.session_id)
+            tags = ', '.join(node.topic_tags)
+            linked = ', '.join(node.links) if node.links else 'none'
+            print(f'Stored → {node.node_id} | {node.summary} (tags: {tags}, linked: {linked})')
+        return
+
+    if not config.summary:
+        print('Error: summary required. Use summary:=... or file:=path.json')
+        return
+    if not config.trigger:
+        print('Error: trigger required. Use trigger:=...')
+        return
+    raw_text = config.raw_text or config.text or ''
+    if not raw_text:
+        print('Error: raw text required. Use raw_text:=...')
+        return
+    tags = [t.strip() for t in config.topic_tags.split(',') if t.strip()] if config.topic_tags else []
+    node = memo.store_direct(
+        summary=config.summary,
+        trigger=config.trigger,
+        raw_text=raw_text,
+        topic_tags=tags,
+        recall_mode=config.recall_mode,
+        session_id=config.session_id or '',
+    )
+    if config.session_id:
+        session_mgr.increment_node_count(config.session_id)
+    print(f'Stored → {node.node_id}')
+    print(f'  Summary: {node.summary}')
+    print(f'  Trigger: {node.trigger}')
+    tag_str = ', '.join(node.topic_tags)
+    print(f'  Tags: {tag_str}')
+    linked = ', '.join(node.links) if node.links else 'none'
+    print(f'  Linked: {linked}')
+
+
+def cmd_compact(memo, config, session_mgr):
+    node = memo.force_compact()
+    if node:
+        if config.session_id:
+            node.session_id = config.session_id
+            memo._store.save_node(node)
+            session_mgr.increment_node_count(config.session_id)
+        print(f'Compacted → {node.node_id}')
+        print(f'  Summary: {node.summary}')
+        print(f'  Trigger: {node.trigger}')
+        tags = ', '.join(node.topic_tags)
+        print(f'  Tags: {tags}')
+    else:
+        print('Nothing to compact (buffer empty)')
+
+
+def cmd_index(memo, config, session_mgr):
+    if config.session_id:
+        filtered = _get_session_nodes(memo, config.session_id)
+        if not filtered:
+            print(f'No nodes in session: {config.session_id}')
+            return
+        for node in filtered:
+            print(f'[{node.node_id}] {node.summary} | {node.trigger}')
+    else:
+        result = memo.get_context_window(max_nodes=100)
+        if result.strip():
+            print(result)
+        else:
+            print('No memory nodes stored')
+
+
+def cmd_read(memo, config, session_mgr):
+    if not config.node_id:
+        print('Error: node_id required. Use node_id:=mem_xxx')
+        return
+    result = memo.read_memory(config.node_id, depth=config.depth)
+    if result:
+        print(result)
+    else:
+        print(f'Node not found: {config.node_id}')
+
+
+def cmd_search(memo, config, session_mgr):
+    if not config.tag:
+        print('Error: tag required. Use tag:=TagName')
+        return
+    results = memo.search(config.tag)
+    if not results:
+        print(f'No nodes found with tag: {config.tag}')
+        return
+    for node_id in results:
+        info = memo.read_memory(node_id, depth=0)
+        print(f'[{node_id}] {info}')
+
+
+def cmd_retrieve(memo, config, session_mgr):
+    if not config.summary_query or not config.trigger_query:
+        print('Error: both summary_query and trigger_query required.')
+        print('  Use summary_query:="what to find" trigger_query:="why you need it"')
+        return
+    results = memo.retrieve_dual(config.summary_query, config.trigger_query, top_k=config.top_k)
+    if not results:
+        print('No relevant memories found')
+        return
+    for r in results:
+        linked = ', '.join(r.node.links) if r.node.links else 'none'
+        tags = ', '.join(r.node.topic_tags)
+        print(
+            f'[{r.node.node_id}] (score={r.relevance_score:.4f})\n'
+            f'  Summary: {r.node.summary}\n'
+            f'  Trigger: {r.node.trigger}\n'
+            f'  Tags: {tags}\n'
+            f'  Linked: {linked}'
+        )
+        print()
+
+
+def cmd_recall(memo, config, session_mgr):
+    if not config.session_id:
+        print('Error: session_id required. Use session_id:=ses_xxx')
+        recent = session_mgr.list_recent(5)
+        if recent:
+            print()
+            print('Recent sessions:')
+            for s in recent:
+                title = s.get('title', '')
+                title_str = f' — {title}' if title else ''
+                print(f'  {s["session_id"]} ({s.get("node_count", 0)} nodes){title_str}')
+        return
+    session_nodes = _get_session_nodes(memo, config.session_id)
+    if not session_nodes:
+        print(f'No nodes in session: {config.session_id}')
+        return
+    print(f'=== Session {config.session_id} ({len(session_nodes)} nodes) ===')
+    print()
+    for node in session_nodes:
+        tags = ', '.join(node.topic_tags)
+        linked = ', '.join(node.links) if node.links else 'none'
+        print(
+            f'[{node.node_id}]\n'
+            f'  Summary: {node.summary}\n'
+            f'  Trigger: {node.trigger}\n'
+            f'  Tags: {tags}\n'
+            f'  Linked: {linked}'
+        )
+        print()
+
+
+def cmd_close(memo, config, session_mgr):
+    memo.close_session()
+    print('Session closed (buffer compacted + consolidated)')
+
+
+def cmd_tags(memo, config, session_mgr):
+    tags = memo._store.get_all_tags()
+    if tags:
+        for tag in sorted(tags):
+            print(tag)
+    else:
+        print('No tags found')
+
+
+def _print_usage():
+    print('CoMeT CLI — Cognitive Memory Tree')
+    print()
+    print('Usage: python -m comet.cli command:=CMD [options]')
+    print()
+    print('Session commands (no API key):')
+    print('  command:=init      [session_id:=ID] [session_title:=Title]')
+    print('  command:=sessions                               List all sessions')
+    print('  command:=recall    session_id:=ses_xxx           Load session context')
+    print()
+    print('Memory commands (no API key):')
+    print('  command:=store     session_id:=ses_xxx "summary:=\'...\'" "trigger:=\'...\'" ...')
+    print('  command:=index     [session_id:=ses_xxx]         List nodes (session or all)')
+    print('  command:=read      node_id:=mem_xxx [depth=N]')
+    print('  command:=search    tag:=TagName')
+    print('  command:=tags')
+    print()
+    print('LLM commands (requires OPENAI_API_KEY):')
+    print('  command:=add       session_id:=ses_xxx "text:=\'...\'"')
+    print('  command:=retrieve  "summary_query:=\'...\'" "trigger_query:=\'...\'"')
+    print('  command:=compact / command:=close')
+    print()
+    print('Quoting: "key:=\'multi word value\'" (shell double, ato single)')
+
+
+if __name__ == '__main__':
+    main()

comet/compacter.py

@@ -0,0 +1,104 @@
+"""MemoryCompacter: L1 -> L2+ structuring with summary + key generation."""
+from __future__ import annotations
+
+from typing import Optional, TYPE_CHECKING
+
+from ato.adict import ADict
+from langchain_openai import ChatOpenAI
+from langchain_core.language_models import BaseChatModel
+from pydantic import BaseModel, Field
+
+from comet.schemas import L1Memory, MemoryNode
+from comet.storage import MemoryStore
+from comet.templates import load_template
+
+if TYPE_CHECKING:
+    from comet.vector_index import VectorIndex
+
+
+class CompactedResult(BaseModel):
+    """Structured output for compacting."""
+    summary: str = Field(description='Brief topic description (1 line, NO specific numbers/dates)')
+    trigger: str = Field(description='Detailed description of when to retrieve this info')
+    recall_mode: str = Field(
+        default='active',
+        description='passive=always in context, active=on-demand, both=always + searchable',
+    )
+    topic_tags: list[str] = Field(description='1-2 topic tags')
+
+
+# Prompt loaded from templates/compacting.txt
+
+
+class MemoryCompacter:
+    """
+    Slow Layer processor for L1 -> L2+ structuring.
+    
+    Takes accumulated L1 buffer and creates structured MemoryNodes
+    with summaries and keys to raw data.
+    """
+
+    def __init__(self, config: ADict, store: MemoryStore, vector_index: Optional[VectorIndex] = None):
+        self._config = config
+        self._store = store
+        self._vector_index = vector_index
+        self._llm: BaseChatModel = ChatOpenAI(model=config.main_model)
+        self._structured_llm = self._llm.with_structured_output(CompactedResult)
+
+    def compact(
+        self,
+        l1_buffer: list[L1Memory],
+        depth_level: int = 1,
+    ) -> MemoryNode:
+        """
+        Compact L1 buffer into a structured MemoryNode.
+        
+        1. Concatenate L1 contents as raw data
+        2. Generate summary + tags via LLM
+        3. Save raw data with content_key
+        4. Create and save MemoryNode
+        """
+        # Build raw data from L1 buffer
+        raw_data = '\n\n'.join([
+            f"[{mem.timestamp.strftime('%H:%M:%S')}] {mem.content}"
+            for mem in l1_buffer
+        ])
+        
+        # Generate summary via LLM (with existing topic context)
+        turns_text = '\n'.join([f"- {mem.content}" for mem in l1_buffer])
+        existing_tags = self._store.get_all_tags()
+        tags_text = ', '.join(sorted(existing_tags)) if existing_tags else '(없음)'
+        prompt = load_template('compacting').format(
+            turns=turns_text,
+            existing_tags=tags_text,
+        )
+        
+        result: CompactedResult = self._structured_llm.invoke(prompt)
+        
+        # Generate keys and save raw
+        node_id = self._store.generate_node_id()
+        content_key = self._store.generate_content_key(prefix='raw')
+        raw_location = self._store.save_raw(content_key, raw_data)
+        
+        # Create memory node
+        node = MemoryNode(
+            node_id=node_id,
+            depth_level=depth_level,
+            recall_mode=result.recall_mode if result.recall_mode in ('passive', 'active', 'both') else 'active',
+            topic_tags=result.topic_tags,
+            summary=result.summary,
+            trigger=result.trigger,
+            content_key=content_key,
+            raw_location=raw_location,
+        )
+        
+        # Save node
+        self._store.save_node(node)
+
+        # Auto-link + vector index
+        self._store.auto_link(node)
+
+        if self._vector_index:
+            self._vector_index.upsert(node, raw_content=raw_data)
+
+        return node

comet/config.py

@@ -0,0 +1,60 @@
+"""CoMeT Configuration using ato scope."""
+from ato.scope import Scope
+from ato.adict import ADict
+
+scope = Scope()
+
+
+@scope.observe(default=True)
+def default(config: ADict):
+    # SLM for Fast Layer (L1)
+    config.slm_model = 'gpt-4o-mini'
+    
+    # Main LLM for Slow Layer (L2+)
+    config.main_model = 'gpt-4o'
+    
+    # Compacting thresholds
+    config.compacting = ADict(
+        load_threshold=4,  # load_level >= 4 triggers compacting
+        max_l1_buffer=10,  # Max items before forced compacting
+    )
+    
+    # Storage settings
+    config.storage = ADict(
+        type='json',  # 'json' or 'redis'
+        base_path='./memory_store',
+        raw_path='./memory_store/raw',
+    )
+
+    # RAG retrieval settings
+    config.retrieval = ADict(
+        embedding_model='text-embedding-3-small',
+        vector_backend='chroma',
+        vector_db_path='./memory_store/vectors',
+        fusion_alpha=0.5,
+        rrf_k=5,
+        raw_search_weight=0.2,
+        top_k=5,
+        rerank=False,
+    )
+
+
+@scope.observe()
+def local_slm(config: ADict):
+    """Use local SLM via Ollama."""
+    config.slm_model = 'ollama/gemma2:9b'
+    config.slm_base_url = 'http://localhost:11434/v1'
+
+
+@scope.observe()
+def aggressive(config: ADict):
+    """More aggressive compacting."""
+    config.compacting.load_threshold = 3
+    config.compacting.max_l1_buffer = 5
+
+
+@scope.observe()
+def agent(config: ADict):
+    """Cheaper defaults for agent/skill usage."""
+    config.slm_model = 'gpt-4o-mini'
+    config.main_model = 'gpt-4o-mini'