mukulcore 0.1.0__tar.gz

mukulcore-0.1.0/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 mukulcore
+
+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, TO USE, THE SOFTWARE OR OTHER
+DEALINGS IN THE SOFTWARE.

mukulcore-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: mukulcore
+Version: 0.1.0
+Summary: A small utility package
+Author: mukulcore
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mukulcore
+
+A small utility package with logging, retry, JSON, file, and config helpers.

mukulcore-0.1.0/README.md

@@ -0,0 +1,3 @@
+# mukulcore
+
+A small utility package with logging, retry, JSON, file, and config helpers.

mukulcore-0.1.0/mukulcore/__init__.py

@@ -0,0 +1,7 @@
+"""
+MukulCore
+
+A Python toolkit for AI Engineers.
+"""
+
+from .version import __version__

mukulcore-0.1.0/mukulcore/agents/__init__.py

@@ -0,0 +1 @@
+"""Agents package."""

mukulcore-0.1.0/mukulcore/agents/base_agent.py

@@ -0,0 +1,14 @@
+"""Base agent abstraction."""
+
+from typing import Any
+
+
+class BaseAgent:
+    """Simple base class for agents."""
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def run(self, task: str, **kwargs: Any) -> str:
+        """Execute a task and return a string result."""
+        return f"{self.name}: {task}"

mukulcore-0.1.0/mukulcore/agents/critic.py

@@ -0,0 +1,10 @@
+"""Critic agent."""
+
+from .base_agent import BaseAgent
+
+
+class CriticAgent(BaseAgent):
+    """Agent for critique tasks."""
+
+    def __init__(self) -> None:
+        super().__init__("critic")

mukulcore-0.1.0/mukulcore/agents/planner.py

@@ -0,0 +1,10 @@
+"""Planner agent."""
+
+from .base_agent import BaseAgent
+
+
+class PlannerAgent(BaseAgent):
+    """Agent for planning tasks."""
+
+    def __init__(self) -> None:
+        super().__init__("planner")

mukulcore-0.1.0/mukulcore/agents/researcher.py

@@ -0,0 +1,10 @@
+"""Researcher agent."""
+
+from .base_agent import BaseAgent
+
+
+class ResearcherAgent(BaseAgent):
+    """Agent for research tasks."""
+
+    def __init__(self) -> None:
+        super().__init__("researcher")

mukulcore-0.1.0/mukulcore/agents/writer.py

@@ -0,0 +1,10 @@
+"""Writer agent."""
+
+from .base_agent import BaseAgent
+
+
+class WriterAgent(BaseAgent):
+    """Agent for writing tasks."""
+
+    def __init__(self) -> None:
+        super().__init__("writer")

mukulcore-0.1.0/mukulcore/ai/__init__.py

@@ -0,0 +1 @@
+"""AI package."""

mukulcore-0.1.0/mukulcore/ai/embeddings.py

@@ -0,0 +1,8 @@
+"""Embedding helpers."""
+
+from typing import List
+
+
+def embed_text(text: str) -> List[float]:
+    """Return a simple placeholder embedding."""
+    return [float(len(text)), float(sum(ord(ch) for ch in text) % 100)]

mukulcore-0.1.0/mukulcore/ai/llm.py

@@ -0,0 +1,11 @@
+"""Simple LLM abstraction interface."""
+
+from typing import Any
+
+
+class BaseLLM:
+    """Base class for LLM integrations."""
+
+    def generate(self, prompt: str, **kwargs: Any) -> str:
+        """Generate a response from a prompt."""
+        return prompt

mukulcore-0.1.0/mukulcore/ai/markdown.py

@@ -0,0 +1,6 @@
+"""Markdown helpers."""
+
+
+def to_markdown(text: str) -> str:
+    """Wrap text as a markdown paragraph."""
+    return f"{text}\n"

mukulcore-0.1.0/mukulcore/ai/memory.py

@@ -0,0 +1,16 @@
+"""Simple memory store."""
+
+from typing import Any, Dict
+
+
+class MemoryStore:
+    """Store key/value pairs in memory."""
+
+    def __init__(self) -> None:
+        self._store: Dict[str, Any] = {}
+
+    def set(self, key: str, value: Any) -> None:
+        self._store[key] = value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._store.get(key, default)

mukulcore-0.1.0/mukulcore/ai/parser.py

@@ -0,0 +1,10 @@
+"""Output parsing helpers."""
+
+from typing import Any
+
+
+def parse_json(text: str) -> Any:
+    """Parse JSON from a string."""
+    import json
+
+    return json.loads(text)

mukulcore-0.1.0/mukulcore/ai/prompts.py

@@ -0,0 +1,8 @@
+"""Prompt management utilities."""
+
+from pathlib import Path
+
+
+def load_prompt(path: str | Path) -> str:
+    """Load a prompt from disk."""
+    return Path(path).read_text(encoding="utf-8")

mukulcore-0.1.0/mukulcore/ai/templates.py

@@ -0,0 +1,6 @@
+"""Template helpers."""
+
+
+def render(template: str, **values: str) -> str:
+    """Render a basic template string."""
+    return template.format(**values)

mukulcore-0.1.0/mukulcore/ai/tokenizer.py

@@ -0,0 +1,6 @@
+"""Tokenization helpers."""
+
+
+def tokenize(text: str) -> list[str]:
+    """Split text into tokens."""
+    return text.split()

mukulcore-0.1.0/mukulcore/api/__init__.py

@@ -0,0 +1 @@
+"""API package."""

mukulcore-0.1.0/mukulcore/api/auth.py

@@ -0,0 +1,6 @@
+"""Authentication helpers."""
+
+
+def get_auth_header(token: str) -> dict[str, str]:
+    """Return a bearer token header."""
+    return {"Authorization": f"Bearer {token}"}

mukulcore-0.1.0/mukulcore/api/client.py

@@ -0,0 +1,8 @@
+"""API client placeholder."""
+
+
+class APIClient:
+    """Minimal API client stub."""
+
+    def __init__(self, base_url: str = "") -> None:
+        self.base_url = base_url

mukulcore-0.1.0/mukulcore/api/requests.py

@@ -0,0 +1,11 @@
+"""API request models."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class APIRequest:
+    """Simple request payload."""
+
+    method: str = "GET"
+    url: str = ""

mukulcore-0.1.0/mukulcore/api/responses.py

@@ -0,0 +1,11 @@
+"""API response models."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class APIResponse:
+    """Simple response payload."""
+
+    status_code: int = 200
+    body: str = ""

mukulcore-0.1.0/mukulcore/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI package."""

mukulcore-0.1.0/mukulcore/cli/doctor.py

@@ -0,0 +1,6 @@
+"""CLI doctor command."""
+
+
+def doctor() -> str:
+    """Return a health-check message."""
+    return "Everything looks healthy"

mukulcore-0.1.0/mukulcore/cli/init.py

@@ -0,0 +1,6 @@
+"""Initialize the package from the CLI."""
+
+
+def init_project() -> str:
+    """Return a setup message."""
+    return "Project initialized"

mukulcore-0.1.0/mukulcore/cli/main.py

@@ -0,0 +1,6 @@
+"""CLI entry point."""
+
+
+def main() -> None:
+    """Print a welcome message."""
+    print("mukulcore CLI")

mukulcore-0.1.0/mukulcore/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration package."""

mukulcore-0.1.0/mukulcore/config/constants.py

@@ -0,0 +1,4 @@
+"""Common constants."""
+
+DEFAULT_TIMEOUT = 30
+DEFAULT_RETRIES = 3

mukulcore-0.1.0/mukulcore/config/env.py

@@ -0,0 +1,8 @@
+"""Environment helpers."""
+
+import os
+
+
+def get_env(name: str, default: str | None = None) -> str | None:
+    """Return an environment variable value."""
+    return os.getenv(name, default)

mukulcore-0.1.0/mukulcore/config/settings.py

@@ -0,0 +1,17 @@
+"""Pydantic-based settings helpers."""
+
+from typing import Optional
+
+try:
+    from pydantic import BaseModel
+except ImportError:  # pragma: no cover
+    class BaseModel:  # type: ignore
+        pass
+
+
+class Settings(BaseModel):
+    """Simple application settings container."""
+
+    app_name: str = "mukulcore"
+    debug: bool = False
+    api_key: Optional[str] = None

mukulcore-0.1.0/mukulcore/database/__init__.py

@@ -0,0 +1 @@
+"""Database package."""

mukulcore-0.1.0/mukulcore/database/mongodb.py

@@ -0,0 +1,6 @@
+"""MongoDB helpers."""
+
+
+def get_connection_string(host: str, db: str) -> str:
+    """Create a simple MongoDB connection string."""
+    return f"mongodb://{host}/{db}"

mukulcore-0.1.0/mukulcore/database/postgres.py

@@ -0,0 +1,6 @@
+"""PostgreSQL helpers."""
+
+
+def get_connection_string(host: str, db: str, user: str, password: str) -> str:
+    """Create a simple PostgreSQL connection string."""
+    return f"postgresql://{user}:{password}@{host}/{db}"

mukulcore-0.1.0/mukulcore/database/sqlite.py

@@ -0,0 +1,9 @@
+"""SQLite helpers."""
+
+import sqlite3
+from pathlib import Path
+
+
+def connect(path: str | Path) -> sqlite3.Connection:
+    """Connect to a SQLite database."""
+    return sqlite3.connect(str(path))

mukulcore-0.1.0/mukulcore/database/vectorstore.py

@@ -0,0 +1,8 @@
+"""Vector store helpers."""
+
+from typing import List, Tuple
+
+
+def create_index(items: List[Tuple[str, List[float]]]) -> List[Tuple[str, List[float]]]:
+    """Return the provided items as a simple index."""
+    return items

mukulcore-0.1.0/mukulcore/decorators/__init__.py

@@ -0,0 +1 @@
+"""Decorators package."""

mukulcore-0.1.0/mukulcore/decorators/cache.py

@@ -0,0 +1,20 @@
+"""Caching decorator."""
+
+from functools import wraps
+from typing import Any, Callable, Dict, TypeVar
+
+T = TypeVar("T")
+
+
+def cache(func: Callable[..., T]) -> Callable[..., T]:
+    """Cache the result of a function for repeated calls."""
+    cache_store: Dict[tuple, Any] = {}
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> T:
+        key = (args, tuple(sorted(kwargs.items())))
+        if key not in cache_store:
+            cache_store[key] = func(*args, **kwargs)
+        return cache_store[key]
+
+    return wrapper

mukulcore-0.1.0/mukulcore/decorators/retry.py

@@ -0,0 +1,29 @@
+"""Retry helpers."""
+
+import time
+from functools import wraps
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def retry(max_attempts: int = 3, delay: float = 0.1):
+    """Retry a function a few times on failure."""
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> T:
+            last_error = None
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as exc:  # pragma: no cover - simple helper
+                    last_error = exc
+                    if attempt == max_attempts:
+                        raise
+                    time.sleep(delay)
+            raise last_error
+
+        return wrapper
+
+    return decorator

mukulcore-0.1.0/mukulcore/decorators/singleton.py

@@ -0,0 +1,19 @@
+"""Singleton decorator."""
+
+from functools import wraps
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def singleton(cls: type[T]) -> type[T]:
+    """Ensure a class only has one instance."""
+    instances = {}
+
+    @wraps(cls)
+    def wrapper(*args, **kwargs) -> T:
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return wrapper

mukulcore-0.1.0/mukulcore/decorators/timer.py

@@ -0,0 +1,22 @@
+"""Timer decorator."""
+
+import time
+from functools import wraps
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def timer(func: Callable[..., T]) -> Callable[..., T]:
+    """Measure the execution time of a function."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> T:
+        start = time.perf_counter()
+        try:
+            return func(*args, **kwargs)
+        finally:
+            elapsed = time.perf_counter() - start
+            print(f"{func.__name__} took {elapsed:.4f}s")
+
+    return wrapper

mukulcore-0.1.0/mukulcore/decorators/validate.py

@@ -0,0 +1,16 @@
+"""Validation decorator."""
+
+from functools import wraps
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def validate(func: Callable[..., T]) -> Callable[..., T]:
+    """Placeholder validator decorator."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> T:
+        return func(*args, **kwargs)
+
+    return wrapper

mukulcore-0.1.0/mukulcore/exceptions/__init__.py

@@ -0,0 +1,8 @@
+"""Exceptions package."""
+
+from .ai import AIError
+from .api import APIError
+from .graph import GraphError
+from .validation import ValidationError
+
+__all__ = ["AIError", "APIError", "GraphError", "ValidationError"]

mukulcore-0.1.0/mukulcore/exceptions/ai.py

@@ -0,0 +1,5 @@
+"""AI-related exceptions."""
+
+
+class AIError(Exception):
+    """Raised for AI-related failures."""

mukulcore-0.1.0/mukulcore/exceptions/api.py

@@ -0,0 +1,5 @@
+"""API-related exceptions."""
+
+
+class APIError(Exception):
+    """Raised for API-related failures."""

mukulcore-0.1.0/mukulcore/exceptions/graph.py

@@ -0,0 +1,5 @@
+"""Graph-related exceptions."""
+
+
+class GraphError(Exception):
+    """Raised for workflow graph failures."""

mukulcore-0.1.0/mukulcore/exceptions/validation.py

@@ -0,0 +1,5 @@
+"""Validation-related exceptions."""
+
+
+class ValidationError(Exception):
+    """Raised for validation failures."""

mukulcore-0.1.0/mukulcore/graph/__init__.py

@@ -0,0 +1 @@
+"""Graph package."""

mukulcore-0.1.0/mukulcore/graph/checkpoint.py

@@ -0,0 +1,8 @@
+"""Checkpoint helpers."""
+
+from pathlib import Path
+
+
+def save_checkpoint(path: str | Path, data: str) -> None:
+    """Save a checkpoint string to disk."""
+    Path(path).write_text(data, encoding="utf-8")

mukulcore-0.1.0/mukulcore/graph/edges.py

@@ -0,0 +1,6 @@
+"""Graph edges."""
+
+from typing import Callable
+
+
+Edge = Callable[[dict], dict]

mukulcore-0.1.0/mukulcore/graph/nodes.py

@@ -0,0 +1,8 @@
+"""Graph nodes."""
+
+from .state import GraphState
+
+
+def simple_node(state: GraphState) -> GraphState:
+    """Return the state unchanged."""
+    return state

mukulcore-0.1.0/mukulcore/graph/state.py

@@ -0,0 +1,11 @@
+"""Workflow state definitions."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict
+
+
+@dataclass
+class GraphState:
+    """Simple state container for graph workflows."""
+
+    data: Dict[str, Any] = field(default_factory=dict)

mukulcore-0.1.0/mukulcore/graph/workflow.py

@@ -0,0 +1,8 @@
+"""Workflow orchestration helpers."""
+
+from .state import GraphState
+
+
+def run_workflow(initial_state: GraphState) -> GraphState:
+    """Run a simple workflow."""
+    return initial_state

mukulcore-0.1.0/mukulcore/logging/__init__.py

@@ -0,0 +1,5 @@
+"""Logging package."""
+
+from .logger import get_logger
+
+__all__ = ["get_logger"]

mukulcore-0.1.0/mukulcore/logging/file_logger.py

@@ -0,0 +1,15 @@
+"""File-based logging helper."""
+
+import logging
+from pathlib import Path
+
+
+def create_file_logger(name: str, path: str | Path) -> logging.Logger:
+    """Create a logger that writes to a file."""
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    handler = logging.FileHandler(path)
+    handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+    logger.addHandler(handler)
+    logger.propagate = False
+    return logger

mukulcore-0.1.0/mukulcore/logging/formatter.py

@@ -0,0 +1,10 @@
+"""Custom formatter helpers."""
+
+import logging
+
+
+class JsonFormatter(logging.Formatter):
+    """Minimal JSON-like formatter for log records."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        return f'{{"level": "{record.levelname}", "message": "{record.getMessage()}"}}'

mukulcore-0.1.0/mukulcore/logging/logger.py

@@ -0,0 +1,15 @@
+"""Logging helpers."""
+
+import logging
+
+
+def get_logger(name: str = "mukulcore") -> logging.Logger:
+    """Create or retrieve a logger instance."""
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(levelname)s:%(name)s:%(message)s"))
+        logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+    return logger

mukulcore-0.1.0/mukulcore/models/__init__.py

@@ -0,0 +1 @@
+"""Data models package."""

mukulcore-0.1.0/mukulcore/models/base.py

@@ -0,0 +1,10 @@
+"""Base model definitions."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class BaseModel:
+    """Minimal base model."""
+
+    id: str | None = None

mukulcore-0.1.0/mukulcore/models/requests.py

@@ -0,0 +1,10 @@
+"""Request model definitions."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class RequestModel:
+    """Simple request container."""
+
+    prompt: str = ""

mukulcore-0.1.0/mukulcore/models/responses.py

@@ -0,0 +1,10 @@
+"""Response model definitions."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ResponseModel:
+    """Simple response container."""
+
+    output: str = ""

mukulcore-0.1.0/mukulcore/tools/__init__.py

@@ -0,0 +1 @@
+"""Tools package."""

mukulcore-0.1.0/mukulcore/tools/calculator.py

@@ -0,0 +1,6 @@
+"""Calculator tool placeholder."""
+
+
+def add(a: float, b: float) -> float:
+    """Add two numbers."""
+    return a + b

mukulcore-0.1.0/mukulcore/tools/csv_tool.py

@@ -0,0 +1,10 @@
+"""CSV helper placeholder."""
+
+import csv
+from pathlib import Path
+
+
+def read_csv(path: str | Path) -> list[dict[str, str]]:
+    """Read a CSV file into a list of rows."""
+    with Path(path).open(newline="", encoding="utf-8") as handle:
+        return list(csv.DictReader(handle))

mukulcore-0.1.0/mukulcore/tools/filesystem.py

@@ -0,0 +1,8 @@
+"""Filesystem tool placeholder."""
+
+from pathlib import Path
+
+
+def read_text(path: str | Path) -> str:
+    """Read text from a file."""
+    return Path(path).read_text(encoding="utf-8")

mukulcore-0.1.0/mukulcore/tools/github.py

@@ -0,0 +1,6 @@
+"""GitHub tool placeholder."""
+
+
+def repo_info(owner: str, repo: str) -> dict[str, str]:
+    """Return placeholder repository metadata."""
+    return {"owner": owner, "repo": repo}

mukulcore-0.1.0/mukulcore/tools/pdf.py

@@ -0,0 +1,6 @@
+"""PDF helper placeholder."""
+
+
+def extract_text(path: str) -> str:
+    """Return a placeholder extraction result."""
+    return f"pdf:{path}"

mukulcore-0.1.0/mukulcore/tools/search.py

@@ -0,0 +1,6 @@
+"""Search tool placeholder."""
+
+
+def search(query: str) -> list[str]:
+    """Return a placeholder search result."""
+    return [query]

mukulcore-0.1.0/mukulcore/tools/web.py

@@ -0,0 +1,6 @@
+"""Web tool placeholder."""
+
+
+def fetch(url: str) -> str:
+    """Return a placeholder response for a URL."""
+    return f"fetched {url}"

mukulcore-0.1.0/mukulcore/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for mukulcore."""
+
+from ..version import __version__
+
+__all__ = ["__version__"]

mukulcore-0.1.0/mukulcore/utils/file_utils.py

@@ -0,0 +1,10 @@
+"""File system utility helpers."""
+
+from pathlib import Path
+
+
+def ensure_parent_dir(path: str | Path) -> Path:
+    """Create the parent directory for a file path if needed."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path

mukulcore-0.1.0/mukulcore/utils/json_utils.py

@@ -0,0 +1,17 @@
+"""JSON utility helpers."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def load_json(path: str | Path) -> Any:
+    """Load JSON data from a file."""
+    with Path(path).open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def dump_json(path: str | Path, data: Any) -> None:
+    """Write JSON data to a file."""
+    with Path(path).open("w", encoding="utf-8") as handle:
+        json.dump(data, handle, indent=2)

mukulcore-0.1.0/mukulcore/version.py

@@ -0,0 +1,3 @@
+"""Package version information."""
+
+__version__ = "0.1.0"

mukulcore-0.1.0/mukulcore.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: mukulcore
+Version: 0.1.0
+Summary: A small utility package
+Author: mukulcore
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mukulcore
+
+A small utility package with logging, retry, JSON, file, and config helpers.

mukulcore-0.1.0/mukulcore.egg-info/SOURCES.txt

@@ -0,0 +1,85 @@
+LICENSE
+README.md
+pyproject.toml
+mukulcore/__init__.py
+mukulcore/version.py
+mukulcore.egg-info/PKG-INFO
+mukulcore.egg-info/SOURCES.txt
+mukulcore.egg-info/dependency_links.txt
+mukulcore.egg-info/top_level.txt
+mukulcore/agents/__init__.py
+mukulcore/agents/base_agent.py
+mukulcore/agents/critic.py
+mukulcore/agents/planner.py
+mukulcore/agents/researcher.py
+mukulcore/agents/writer.py
+mukulcore/ai/__init__.py
+mukulcore/ai/embeddings.py
+mukulcore/ai/llm.py
+mukulcore/ai/markdown.py
+mukulcore/ai/memory.py
+mukulcore/ai/parser.py
+mukulcore/ai/prompts.py
+mukulcore/ai/templates.py
+mukulcore/ai/tokenizer.py
+mukulcore/api/__init__.py
+mukulcore/api/auth.py
+mukulcore/api/client.py
+mukulcore/api/requests.py
+mukulcore/api/responses.py
+mukulcore/cli/__init__.py
+mukulcore/cli/doctor.py
+mukulcore/cli/init.py
+mukulcore/cli/main.py
+mukulcore/config/__init__.py
+mukulcore/config/constants.py
+mukulcore/config/env.py
+mukulcore/config/settings.py
+mukulcore/database/__init__.py
+mukulcore/database/mongodb.py
+mukulcore/database/postgres.py
+mukulcore/database/sqlite.py
+mukulcore/database/vectorstore.py
+mukulcore/decorators/__init__.py
+mukulcore/decorators/cache.py
+mukulcore/decorators/retry.py
+mukulcore/decorators/singleton.py
+mukulcore/decorators/timer.py
+mukulcore/decorators/validate.py
+mukulcore/exceptions/__init__.py
+mukulcore/exceptions/ai.py
+mukulcore/exceptions/api.py
+mukulcore/exceptions/graph.py
+mukulcore/exceptions/validation.py
+mukulcore/graph/__init__.py
+mukulcore/graph/checkpoint.py
+mukulcore/graph/edges.py
+mukulcore/graph/nodes.py
+mukulcore/graph/state.py
+mukulcore/graph/workflow.py
+mukulcore/logging/__init__.py
+mukulcore/logging/file_logger.py
+mukulcore/logging/formatter.py
+mukulcore/logging/logger.py
+mukulcore/models/__init__.py
+mukulcore/models/base.py
+mukulcore/models/requests.py
+mukulcore/models/responses.py
+mukulcore/tools/__init__.py
+mukulcore/tools/calculator.py
+mukulcore/tools/csv_tool.py
+mukulcore/tools/filesystem.py
+mukulcore/tools/github.py
+mukulcore/tools/pdf.py
+mukulcore/tools/search.py
+mukulcore/tools/web.py
+mukulcore/utils/__init__.py
+mukulcore/utils/file_utils.py
+mukulcore/utils/json_utils.py
+tests/test_agents.py
+tests/test_graph.py
+tests/test_json.py
+tests/test_json_utils.py
+tests/test_logger.py
+tests/test_retry.py
+tests/test_tools.py

mukulcore-0.1.0/mukulcore.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mukulcore-0.1.0/mukulcore.egg-info/top_level.txt

@@ -0,0 +1 @@
+mukulcore

mukulcore-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mukulcore"
+version = "0.1.0"
+description = "A small utility package"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{ name = "mukulcore" }]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

mukulcore-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mukulcore-0.1.0/tests/test_agents.py

@@ -0,0 +1,6 @@
+from mukulcore.agents.researcher import ResearcherAgent
+
+
+def test_agent_runs():
+    agent = ResearcherAgent()
+    assert agent.run("collect data") == "researcher: collect data"

mukulcore-0.1.0/tests/test_graph.py

@@ -0,0 +1,7 @@
+from mukulcore.graph.state import GraphState
+from mukulcore.graph.workflow import run_workflow
+
+
+def test_run_workflow_returns_initial_state():
+    state = GraphState(data={"step": 1})
+    assert run_workflow(state) == state

mukulcore-0.1.0/tests/test_json.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+from mukulcore.utils.json_utils import dump_json, load_json
+
+
+def test_json_round_trip(tmp_path: Path):
+    path = tmp_path / "data.json"
+    payload = {"hello": "world"}
+
+    dump_json(path, payload)
+    assert load_json(path) == payload

mukulcore-0.1.0/tests/test_json_utils.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+from mukulcore.utils.json_utils import dump_json, load_json
+
+
+def test_json_round_trip(tmp_path: Path):
+    path = tmp_path / "data.json"
+    payload = {"hello": "world"}
+
+    dump_json(path, payload)
+    assert load_json(path) == payload

mukulcore-0.1.0/tests/test_logger.py

@@ -0,0 +1,6 @@
+from mukulcore.logger import get_logger
+
+
+def test_get_logger_returns_logger():
+    logger = get_logger("test")
+    assert logger.name == "test"

mukulcore-0.1.0/tests/test_retry.py

@@ -0,0 +1,17 @@
+from mukulcore.decorators.retry import retry
+
+
+@retry(max_attempts=2, delay=0.0)
+def flaky_function():
+    if flaky_function.calls == 0:
+        flaky_function.calls += 1
+        raise ValueError("fail")
+    flaky_function.calls += 1
+    return "ok"
+
+
+flaky_function.calls = 0
+
+
+def test_retry_succeeds_after_retry():
+    assert flaky_function() == "ok"

mukulcore-0.1.0/tests/test_tools.py

@@ -0,0 +1,5 @@
+from mukulcore.tools.calculator import add
+
+
+def test_addition():
+    assert add(2, 3) == 5