lobesync 0.1.0__tar.gz

lobesync-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chetan Panchal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lobesync-0.1.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: lobesync
+Version: 0.1.0
+Summary: Personal AI assistant for tasks, notes, memories, and checklists
+License: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=0.89.0
+Requires-Dist: langgraph>=1.1.6
+Requires-Dist: sqlmodel>=0.0.38
+Requires-Dist: rich>=14.3.3
+Requires-Dist: python-dotenv>=1.2.2
+Dynamic: license-file
+
+# Lobesync
+
+A personal AI assistant for your terminal. Manage tasks, notes, memories, and checklists through natural conversation — powered by Claude and built on LangGraph.
+
+```
+Lobesync — Personal AI Assistant
+Type /help for commands · exit to quit
+
+You: Create a checklist "Launch" and add tasks for writing tests and updating docs
+Lobesync: Done! Created checklist "Launch" (ID: 1) with two tasks — "Write tests" (ID: 2)
+          and "Update docs" (ID: 3), both set to pending.
+
+You: Mark write tests as in progress
+Lobesync: Updated "Write tests" to in progress. ✓
+```
+
+## Features
+
+- **Natural language interface** — just talk to it, no commands to memorize
+- **Tasks** with deadlines, statuses, and checklist grouping
+- **Checklists** with items and pending-task guards
+- **Notes** for storing anything
+- **Memories** — the agent proactively remembers personal facts about you across sessions
+- **Session management** — multiple conversations, each with its own history and incremental summary
+- **Streaming responses** with live Markdown rendering
+- **Cost-efficient** — single LLM call per turn (planner + executor + completion)
+- **Local SQLite** by default — your data stays on your machine
+
+## Architecture
+
+Lobesync uses a [LangGraph](https://github.com/langchain-ai/langgraph) graph with four nodes:
+
+```
+user input
+    │
+    ▼
+┌─────────┐   direct response (streamed)   ┌────────────┐
+│ Planner │ ──────────────────────────────▶ │ Commitment │ ──▶ END
+└─────────┘                                 └────────────┘
+    │ tool calls needed                            ▲
+    ▼                                              │
+┌──────────┐                              ┌────────────────┐
+│ Executor │ ────────────────────────────▶ │   Completion   │
+└──────────┘                              └────────────────┘
+```
+
+- **Planner** — single LLM call (Haiku). Streams a direct response for chat, or calls `make_plan` for data operations. Receives user memories in system prompt (cached) + session summary + last 5 messages.
+- **Executor** — runs the plan. Atomic groups use one session (all-or-nothing). Independent steps run in separate sessions.
+- **Completion** — generates the final natural language response with tool results as context.
+- **Commitment** — saves user message, assistant message, and tool calls to DB. Regenerates session summary every 5 messages.
+
+## Installation
+
+### Using pipx (recommended for CLI tools)
+
+```bash
+pipx install lobesync
+```
+
+### Using pip
+
+```bash
+pip install lobesync
+```
+
+### From source
+
+```bash
+git clone https://github.com/panchalchetan618/lobesync
+cd lobesync
+pip install -e .
+```
+
+## Setup
+
+Run `lobesync` for the first time and the setup wizard will guide you through:
+
+1. Entering your [Anthropic API key](https://console.anthropic.com/)
+2. Choosing a local SQLite database (recommended) or providing your own database URL
+
+Config is saved to `~/.lobesync/config.json`. Local database is stored at `~/.lobesync/lobesync.db`.
+
+## Usage
+
+```bash
+lobesync
+```
+
+### CLI Commands
+
+| Command | Description |
+|---|---|
+| `/sessions` | List all chat sessions |
+| `/session new` | Start a new session |
+| `/session new <name>` | Start a new named session |
+| `/session <id>` | Switch to an existing session |
+| `/help` | Show all commands |
+| `exit` | Quit |
+
+### Example interactions
+
+```
+You: Add a task to review PRs by Friday
+You: What are my pending tasks?
+You: Create a note about the deployment process
+You: I prefer concise responses
+You: Mark the PR review task as done
+You: Start a new checklist for the Q2 release
+```
+
+The agent remembers personal facts across sessions — tell it your preferences, goals, or anything relevant and it will factor them in automatically.
+
+## Configuration
+
+| Variable | Description |
+|---|---|
+| `ANTHROPIC_API_KEY` | Your Anthropic API key |
+| `DATABASE_URL` | SQLAlchemy database URL (default: local SQLite) |
+
+Set via the setup wizard or in `~/.lobesync/config.json`:
+
+```json
+{
+  "ANTHROPIC_API_KEY": "sk-ant-...",
+  "DATABASE_URL": "sqlite:////home/you/.lobesync/lobesync.db"
+}
+```
+
+You can also use a `.env` file in the working directory or environment variables as fallback.
+
+## Models used
+
+| Node | Model | Reason |
+|---|---|---|
+| Planner | `claude-haiku-4-5` | Fast, cheap, handles planning and direct chat |
+| Completion | `claude-haiku-4-5` | Generates final response from tool results |
+| Summarizer | `claude-haiku-4-5` | Compresses old conversation history |
+
+## Tech stack
+
+- [Anthropic Python SDK](https://github.com/anthropics/anthropic-sdk-python)
+- [LangGraph](https://github.com/langchain-ai/langgraph)
+- [SQLModel](https://sqlmodel.tiangolo.com/)
+- [Rich](https://github.com/Textualize/rich)
+
+## Contributing
+
+Pull requests are welcome. For major changes, open an issue first.
+
+## License
+
+MIT

lobesync-0.1.0/README.md

@@ -0,0 +1,152 @@
+# Lobesync
+
+A personal AI assistant for your terminal. Manage tasks, notes, memories, and checklists through natural conversation — powered by Claude and built on LangGraph.
+
+```
+Lobesync — Personal AI Assistant
+Type /help for commands · exit to quit
+
+You: Create a checklist "Launch" and add tasks for writing tests and updating docs
+Lobesync: Done! Created checklist "Launch" (ID: 1) with two tasks — "Write tests" (ID: 2)
+          and "Update docs" (ID: 3), both set to pending.
+
+You: Mark write tests as in progress
+Lobesync: Updated "Write tests" to in progress. ✓
+```
+
+## Features
+
+- **Natural language interface** — just talk to it, no commands to memorize
+- **Tasks** with deadlines, statuses, and checklist grouping
+- **Checklists** with items and pending-task guards
+- **Notes** for storing anything
+- **Memories** — the agent proactively remembers personal facts about you across sessions
+- **Session management** — multiple conversations, each with its own history and incremental summary
+- **Streaming responses** with live Markdown rendering
+- **Cost-efficient** — single LLM call per turn (planner + executor + completion)
+- **Local SQLite** by default — your data stays on your machine
+
+## Architecture
+
+Lobesync uses a [LangGraph](https://github.com/langchain-ai/langgraph) graph with four nodes:
+
+```
+user input
+    │
+    ▼
+┌─────────┐   direct response (streamed)   ┌────────────┐
+│ Planner │ ──────────────────────────────▶ │ Commitment │ ──▶ END
+└─────────┘                                 └────────────┘
+    │ tool calls needed                            ▲
+    ▼                                              │
+┌──────────┐                              ┌────────────────┐
+│ Executor │ ────────────────────────────▶ │   Completion   │
+└──────────┘                              └────────────────┘
+```
+
+- **Planner** — single LLM call (Haiku). Streams a direct response for chat, or calls `make_plan` for data operations. Receives user memories in system prompt (cached) + session summary + last 5 messages.
+- **Executor** — runs the plan. Atomic groups use one session (all-or-nothing). Independent steps run in separate sessions.
+- **Completion** — generates the final natural language response with tool results as context.
+- **Commitment** — saves user message, assistant message, and tool calls to DB. Regenerates session summary every 5 messages.
+
+## Installation
+
+### Using pipx (recommended for CLI tools)
+
+```bash
+pipx install lobesync
+```
+
+### Using pip
+
+```bash
+pip install lobesync
+```
+
+### From source
+
+```bash
+git clone https://github.com/panchalchetan618/lobesync
+cd lobesync
+pip install -e .
+```
+
+## Setup
+
+Run `lobesync` for the first time and the setup wizard will guide you through:
+
+1. Entering your [Anthropic API key](https://console.anthropic.com/)
+2. Choosing a local SQLite database (recommended) or providing your own database URL
+
+Config is saved to `~/.lobesync/config.json`. Local database is stored at `~/.lobesync/lobesync.db`.
+
+## Usage
+
+```bash
+lobesync
+```
+
+### CLI Commands
+
+| Command | Description |
+|---|---|
+| `/sessions` | List all chat sessions |
+| `/session new` | Start a new session |
+| `/session new <name>` | Start a new named session |
+| `/session <id>` | Switch to an existing session |
+| `/help` | Show all commands |
+| `exit` | Quit |
+
+### Example interactions
+
+```
+You: Add a task to review PRs by Friday
+You: What are my pending tasks?
+You: Create a note about the deployment process
+You: I prefer concise responses
+You: Mark the PR review task as done
+You: Start a new checklist for the Q2 release
+```
+
+The agent remembers personal facts across sessions — tell it your preferences, goals, or anything relevant and it will factor them in automatically.
+
+## Configuration
+
+| Variable | Description |
+|---|---|
+| `ANTHROPIC_API_KEY` | Your Anthropic API key |
+| `DATABASE_URL` | SQLAlchemy database URL (default: local SQLite) |
+
+Set via the setup wizard or in `~/.lobesync/config.json`:
+
+```json
+{
+  "ANTHROPIC_API_KEY": "sk-ant-...",
+  "DATABASE_URL": "sqlite:////home/you/.lobesync/lobesync.db"
+}
+```
+
+You can also use a `.env` file in the working directory or environment variables as fallback.
+
+## Models used
+
+| Node | Model | Reason |
+|---|---|---|
+| Planner | `claude-haiku-4-5` | Fast, cheap, handles planning and direct chat |
+| Completion | `claude-haiku-4-5` | Generates final response from tool results |
+| Summarizer | `claude-haiku-4-5` | Compresses old conversation history |
+
+## Tech stack
+
+- [Anthropic Python SDK](https://github.com/anthropics/anthropic-sdk-python)
+- [LangGraph](https://github.com/langchain-ai/langgraph)
+- [SQLModel](https://sqlmodel.tiangolo.com/)
+- [Rich](https://github.com/Textualize/rich)
+
+## Contributing
+
+Pull requests are welcome. For major changes, open an issue first.
+
+## License
+
+MIT

lobesync-0.1.0/lobesync/agent/graph.py

@@ -0,0 +1,40 @@
+from langgraph.graph import StateGraph, START, END
+
+from lobesync.agent.state import AgentState
+from lobesync.agent.nodes.planner import planner_node
+from lobesync.agent.nodes.executor import executor_node
+from lobesync.agent.nodes.completion import completion_node
+from lobesync.agent.nodes.commitment import commitment_node
+
+
+def _route_after_planner(state: AgentState) -> str:
+    if state.get("final_response"):
+        return "commitment"
+    plan = state.get("plan") or {}
+    has_work = bool(plan.get("atomic_groups")) or bool(plan.get("non_atomic"))
+    return "executor" if has_work else "completion"
+
+
+def build_graph():
+    graph = StateGraph(AgentState)
+
+    graph.add_node("planner", planner_node)
+    graph.add_node("executor", executor_node)
+    graph.add_node("completion", completion_node)
+    graph.add_node("commitment", commitment_node)
+
+    graph.add_edge(START, "planner")
+    graph.add_conditional_edges(
+        "planner",
+        _route_after_planner,
+        {
+            "executor": "executor",
+            "completion": "completion",
+            "commitment": "commitment",
+        },
+    )
+    graph.add_edge("executor", "completion")
+    graph.add_edge("completion", "commitment")
+    graph.add_edge("commitment", END)
+
+    return graph.compile()

lobesync-0.1.0/lobesync/agent/nodes/commitment.py

@@ -0,0 +1,112 @@
+import anthropic
+import json
+import logging
+from datetime import datetime
+from sqlmodel import Session
+
+from lobesync.config import config
+from lobesync.db.database import engine
+from lobesync.db.models import MessageRole
+from lobesync.db.repos.chat_repo import (
+    create_message,
+    create_tool_call,
+    get_messages_by_session,
+    update_chat_session_summary,
+    get_chat_session_by_id,
+)
+from lobesync.agent.state import AgentState
+
+logger = logging.getLogger(__name__)
+
+_SUMMARY_EVERY = 5
+_KEEP_LAST = 5
+
+
+def _generate_summary(existing_summary: str | None, messages_to_compress: list) -> str:
+    formatted = "\n".join([
+        f"{msg.role.value.upper()}: {msg.content}"
+        for msg in messages_to_compress
+    ])
+
+    if existing_summary:
+        prompt = f"Previous summary:\n{existing_summary}\n\nNew exchanges to incorporate:\n{formatted}\n\nUpdate the summary concisely."
+    else:
+        prompt = f"Summarize this conversation concisely:\n{formatted}"
+
+    client = anthropic.Anthropic(api_key=config.ANTHROPIC_API_KEY)
+    response = client.messages.create(
+        model="claude-haiku-4-5-20251001",
+        max_tokens=512,
+        messages=[{"role": "user", "content": prompt}],
+    )
+    return response.content[0].text
+
+
+def _update_session_name(session: Session, chat_session_id: int, first_user_message: str):
+    from lobesync.db.models import ChatSession
+    chat_session = session.get(ChatSession, chat_session_id)
+    if chat_session and chat_session.name == "Lobesync":
+        chat_session.name = first_user_message[:40].strip()
+        session.add(chat_session)
+
+
+def commitment_node(state: AgentState) -> dict:
+    """
+    Persists the conversation turn, tool calls, and manages incremental summary.
+    Always runs last — owns all DB writes for the turn.
+    """
+    chat_session_id = state["chat_session_id"]
+    user_query = state["user_query"]
+    final_response = state["final_response"]
+    input_tokens = state.get("input_tokens", 0)
+    output_tokens = state.get("output_tokens", 0)
+    model_name = state.get("model_name")
+    execution_results = state.get("execution_results") or []
+
+    with Session(engine) as session:
+        create_message(session, chat_session_id, user_query, MessageRole.USER)
+        assistant_msg = create_message(
+            session,
+            chat_session_id,
+            final_response,
+            MessageRole.AGENT,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            model_name=model_name,
+        )
+        session.flush()
+
+        # Save tool calls linked to the assistant message
+        if execution_results and assistant_msg:
+            def _safe_json(obj) -> str:
+                return json.dumps(obj, default=lambda o: o.isoformat() if isinstance(o, datetime) else str(o))
+
+            for r in execution_results:
+                payload = _safe_json(r.get("args", {}))
+                response = _safe_json(r["result"]) if r.get("result") is not None else (r.get("error") or "")
+                create_tool_call(
+                    session,
+                    message_id=assistant_msg.id,
+                    tool_name=r["tool"],
+                    payload=payload,
+                    response=response,
+                )
+
+        all_messages = get_messages_by_session(session, chat_session_id) or []
+        total = len(all_messages)
+
+        if total <= 2:
+            _update_session_name(session, chat_session_id, user_query)
+
+        if total > _KEEP_LAST and total % _SUMMARY_EVERY == 0:
+            messages_to_compress = all_messages[:-_KEEP_LAST]
+            chat_session = get_chat_session_by_id(session, chat_session_id)
+            existing_summary = chat_session.summary if chat_session else None
+            logger.info(f"Regenerating summary ({len(messages_to_compress)} messages to compress)")
+            new_summary = _generate_summary(existing_summary, messages_to_compress)
+            update_chat_session_summary(session, chat_session_id, new_summary)
+
+        session.commit()
+
+    logger.info(f"Commitment: saved turn for session {chat_session_id} ({total} total messages)")
+    return {}

lobesync-0.1.0/lobesync/agent/nodes/completion.py

@@ -0,0 +1,104 @@
+import anthropic
+import logging
+from sqlmodel import Session
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.live import Live
+
+from lobesync.config import config
+from lobesync.db.database import engine
+from lobesync.db.models import MessageRole
+from lobesync.db.repos.chat_repo import get_messages_by_session
+from lobesync.agent.state import AgentState
+
+console = Console()
+
+
+logger = logging.getLogger(__name__)
+
+COMPLETION_SYSTEM_PROMPT = """You are Lobesync, a personal AI assistant. You help the user manage tasks, notes, memories, and checklists.
+
+When tool results are provided in the user message, summarize what was done naturally and concisely.
+Always mention the ID of any created or retrieved item (e.g. "Task created with ID 3") so the user can reference it later.
+If an operation failed, acknowledge it clearly and suggest what the user can do.
+If no tools were called, just respond naturally as a helpful assistant."""
+
+_COMPLETION_SYSTEM = [
+    {
+        "type": "text",
+        "text": COMPLETION_SYSTEM_PROMPT,
+        "cache_control": {"type": "ephemeral"},
+    }
+]
+
+_COMPLETION_MODEL = "claude-haiku-4-5-20251001"
+
+
+def _build_history(messages) -> list[dict]:
+    history = []
+    for msg in messages:
+        role = "user" if msg.role == MessageRole.USER else "assistant"
+        history.append({"role": role, "content": msg.content})
+    return history
+
+
+def _format_results(execution_results: list[dict]) -> str:
+    if not execution_results:
+        return ""
+    lines = []
+    for r in execution_results:
+        if r["error"]:
+            lines.append(f"- {r['tool']}: FAILED — {r['error']}")
+        else:
+            lines.append(f"- {r['tool']}: SUCCESS — {r['result']}")
+    return "\n".join(lines)
+
+
+def completion_node(state: AgentState) -> dict:
+    """
+    Generates the final natural language response.
+    Loads conversation history, injects tool results, calls Claude, saves messages to DB.
+    """
+    chat_session_id = state["chat_session_id"]
+    user_query = state["user_query"]
+    execution_results = state.get("execution_results") or []
+
+    with Session(engine) as session:
+        prior_messages = get_messages_by_session(session, chat_session_id) or []
+        history = _build_history(prior_messages)
+
+        user_content = user_query
+        results_text = _format_results(execution_results)
+        if results_text:
+            user_content = f"{user_query}\n\n[Tool results:\n{results_text}]"
+
+        history.append({"role": "user", "content": user_content})
+
+        client = anthropic.Anthropic(api_key=config.ANTHROPIC_API_KEY)
+
+        accumulated = ""
+        console.print("\n[bold blue]Lobesync:[/bold blue]")
+        with client.messages.stream(
+            model=_COMPLETION_MODEL,
+            max_tokens=1024,
+            system=_COMPLETION_SYSTEM,
+            messages=history,
+        ) as stream:
+            with Live(Markdown(accumulated), console=console, refresh_per_second=15) as live:
+                for text in stream.text_stream:
+                    accumulated += text
+                    live.update(Markdown(accumulated))
+            final_message = stream.get_final_message()
+        console.print()
+
+        final_response = final_message.content[0].text
+        input_tokens = final_message.usage.input_tokens
+        output_tokens = final_message.usage.output_tokens
+
+    logger.info(f"Completion: {input_tokens} in / {output_tokens} out tokens")
+    return {
+        "final_response": final_response,
+        "input_tokens": input_tokens,
+        "output_tokens": output_tokens,
+        "model_name": _COMPLETION_MODEL,
+    }