akitallm 0.1.0__tar.gz → 1.0.3__tar.gz

akitallm-1.0.3/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: akitallm
+Version: 1.0.3
+Summary: AkitaLLM: An open-source local-first AI system for programming.
+Author: KerubinDev
+License: MIT
+Project-URL: Homepage, https://github.com/KerubinDev/AkitaLLM
+Project-URL: Repository, https://github.com/KerubinDev/AkitaLLM
+Project-URL: Issues, https://github.com/KerubinDev/AkitaLLM/issues
+Keywords: ai,cli,programming,local-first,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]
+Requires-Dist: litellm
+Requires-Dist: pydantic
+Requires-Dist: rich
+Requires-Dist: python-dotenv
+Requires-Dist: pytest
+Requires-Dist: pytest-mock
+Requires-Dist: gitpython
+Requires-Dist: tomli-w
+Requires-Dist: tomli
+Requires-Dist: whatthepatch>=1.0.5
+Requires-Dist: tree-sitter>=0.21.3
+Requires-Dist: tree-sitter-python>=0.21.0
+Dynamic: license-file
+
+# AkitaLLM
+### A deterministic, local-first AI orchestrator for software engineers.
+
+---
+
+## What is AkitaLLM?
+
+AkitaLLM is not another "AI wrapper." It is a command-line utility designed for developers who value engineering rigor over generative "magic." It treats Large Language Models as non-deterministic execution engines that must be constrained within a strict, auditable pipeline: **Analyze → Plan → Execute → Validate**.
+
+Built as a local-first tool, it provides you with an AI-augmented workflow that respects your project's context, follows security best practices, and prioritizes structured output over conversational noise.
+
+---
+
+## Why AkitaLLM exists
+
+Most current AI tools (ChatGPT, Copilot, Cursor) operate in a "black-box" conversational mode. They are excellent at text generation but often fail at **software engineering**, which requires:
+- **Project-Level Context**: Understanding how a change in `utils.py` affects `main.py`.
+- **Previsibilty**: Knowing exactly what the AI intends to do before it modifies a single byte.
+- **Verification**: Automatically ensuring that proposed changes don't break existing logic.
+
+AkitaLLM was built to bridge this gap, treating AI as a component of a larger, human-controlled engineering process.
+
+---
+
+## The Engineering Difference
+
+| Feature | Generic AI Tools | AkitaLLM |
+| :--- | :--- | :--- |
+| **Logic** | Conversational / Guesswork | Analyze → Plan → Execute → Validate |
+| **Control** | Autocomplete / Chat | Explicit technical plans & reviewable Diffs |
+| **Security** | Cloud-heavy | Local-first, respects `.gitignore` and `.env` |
+| **Validation** | Post-facto manual review | Automated local test execution |
+| **Philosophy** | "It just works" (Hype) | "Understand the internals" (Engineering) |
+
+---
+
+## Core Principles
+
+1. **Local-First**: Your code remains on your machine. AkitaLLM orchestrates local models (via Ollama) or remote APIs (via LiteLLM) through encrypted, controlled channels.
+2. **Contextual Awareness**: It uses recursive file scanning and structure analysis to build a high-fidelity map of your project before making suggestions.
+3. **No Magic**: No hidden prompts, no mysterious "thinking" phases. All actions are logged, auditable, and based on standard engineering patterns.
+4. **Tool-Driven**: AI is a user of tools (linters, test runners, AST parsers), not a replacement for them.
+
+---
+
+## Key Features
+
+- **Structural Code Review**: Detailed analysis of bugs, style, performance, and security risks with prioritized severity levels.
+- **Technical Planning**: Generation of step-by-step implementation plans in Markdown for complex feature requests.
+- **Actionable Diffs**: Proposed changes are generated as standard Unified Diffs for human review before application.
+- **Environment Isolation**: Supports `.env` and local configuration storage (`~/.akita/`) to keep secrets safe.
+- **Model Agnostic**: Seamlessly switch between GPT-4o, Claude 3.5, Llama 3, and more.
+
+---
+
+## Installation
+
+AkitaLLM is available on PyPI. You can install it directly using pip:
+
+```bash
+pip install akitallm
+```
+
+---
+
+## Usage
+
+### 1. Project Initialization
+Run any command to trigger the initial configuration and onboarding.
+```bash
+akita review .
+```
+
+### 2. Strategic Code Review
+Analyze a directory for potential architectural risks and bugs.
+```bash
+akita review src/
+```
+
+### 3. Implementation Planning
+Generate a technical plan for a specific goal.
+```bash
+akita plan "Implement JWT authentication with Redis-based session storage"
+```
+
+### 4. Code Problem Solving
+Generate a diff to solve a precise issue or refactor a module.
+```bash
+akita solve "Improve error handling in the reasoning engine to prevent silent failures"
+```
+
+---
+
+### 🔌 Extensibility
+AkitaLLM is built to be extended. You can create your own tools and plugins. Check the [Plugin Development Guide](PLUGINS.md) for more details.
+
+## 🤝 Contributing
+
+We are looking for engineers, not just coders. If you value robust abstractions, clean code, and predictable systems, your contribution is welcome.
+
+Review our [CONTRIBUTING.md](CONTRIBUTING.md) to understand our engineering standards and PR workflow. High-quality PRs with test coverage are prioritized.
+
+---
+
+*“Understanding the internals is the first step to excellence.”*

akitallm-1.0.3/README.md

@@ -0,0 +1,105 @@
+# AkitaLLM
+### A deterministic, local-first AI orchestrator for software engineers.
+
+---
+
+## What is AkitaLLM?
+
+AkitaLLM is not another "AI wrapper." It is a command-line utility designed for developers who value engineering rigor over generative "magic." It treats Large Language Models as non-deterministic execution engines that must be constrained within a strict, auditable pipeline: **Analyze → Plan → Execute → Validate**.
+
+Built as a local-first tool, it provides you with an AI-augmented workflow that respects your project's context, follows security best practices, and prioritizes structured output over conversational noise.
+
+---
+
+## Why AkitaLLM exists
+
+Most current AI tools (ChatGPT, Copilot, Cursor) operate in a "black-box" conversational mode. They are excellent at text generation but often fail at **software engineering**, which requires:
+- **Project-Level Context**: Understanding how a change in `utils.py` affects `main.py`.
+- **Previsibilty**: Knowing exactly what the AI intends to do before it modifies a single byte.
+- **Verification**: Automatically ensuring that proposed changes don't break existing logic.
+
+AkitaLLM was built to bridge this gap, treating AI as a component of a larger, human-controlled engineering process.
+
+---
+
+## The Engineering Difference
+
+| Feature | Generic AI Tools | AkitaLLM |
+| :--- | :--- | :--- |
+| **Logic** | Conversational / Guesswork | Analyze → Plan → Execute → Validate |
+| **Control** | Autocomplete / Chat | Explicit technical plans & reviewable Diffs |
+| **Security** | Cloud-heavy | Local-first, respects `.gitignore` and `.env` |
+| **Validation** | Post-facto manual review | Automated local test execution |
+| **Philosophy** | "It just works" (Hype) | "Understand the internals" (Engineering) |
+
+---
+
+## Core Principles
+
+1. **Local-First**: Your code remains on your machine. AkitaLLM orchestrates local models (via Ollama) or remote APIs (via LiteLLM) through encrypted, controlled channels.
+2. **Contextual Awareness**: It uses recursive file scanning and structure analysis to build a high-fidelity map of your project before making suggestions.
+3. **No Magic**: No hidden prompts, no mysterious "thinking" phases. All actions are logged, auditable, and based on standard engineering patterns.
+4. **Tool-Driven**: AI is a user of tools (linters, test runners, AST parsers), not a replacement for them.
+
+---
+
+## Key Features
+
+- **Structural Code Review**: Detailed analysis of bugs, style, performance, and security risks with prioritized severity levels.
+- **Technical Planning**: Generation of step-by-step implementation plans in Markdown for complex feature requests.
+- **Actionable Diffs**: Proposed changes are generated as standard Unified Diffs for human review before application.
+- **Environment Isolation**: Supports `.env` and local configuration storage (`~/.akita/`) to keep secrets safe.
+- **Model Agnostic**: Seamlessly switch between GPT-4o, Claude 3.5, Llama 3, and more.
+
+---
+
+## Installation
+
+AkitaLLM is available on PyPI. You can install it directly using pip:
+
+```bash
+pip install akitallm
+```
+
+---
+
+## Usage
+
+### 1. Project Initialization
+Run any command to trigger the initial configuration and onboarding.
+```bash
+akita review .
+```
+
+### 2. Strategic Code Review
+Analyze a directory for potential architectural risks and bugs.
+```bash
+akita review src/
+```
+
+### 3. Implementation Planning
+Generate a technical plan for a specific goal.
+```bash
+akita plan "Implement JWT authentication with Redis-based session storage"
+```
+
+### 4. Code Problem Solving
+Generate a diff to solve a precise issue or refactor a module.
+```bash
+akita solve "Improve error handling in the reasoning engine to prevent silent failures"
+```
+
+---
+
+### 🔌 Extensibility
+AkitaLLM is built to be extended. You can create your own tools and plugins. Check the [Plugin Development Guide](PLUGINS.md) for more details.
+
+## 🤝 Contributing
+
+We are looking for engineers, not just coders. If you value robust abstractions, clean code, and predictable systems, your contribution is welcome.
+
+Review our [CONTRIBUTING.md](CONTRIBUTING.md) to understand our engineering standards and PR workflow. High-quality PRs with test coverage are prioritized.
+
+---
+
+*“Understanding the internals is the first step to excellence.”*

akitallm-1.0.3/akita/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

{akitallm-0.1.0 → akitallm-1.0.3}/akita/cli/main.py

@@ -2,12 +2,14 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 from akita.reasoning.engine import ReasoningEngine
+from akita.core.indexing import CodeIndexer
 from akita.models.base import get_model
 from akita.core.config import load_config, save_config, reset_config, CONFIG_FILE
 from rich.table import Table
 from rich.markdown import Markdown
 from rich.syntax import Syntax
 from dotenv import load_dotenv
+from akita.tools.diff import DiffApplier
 
 # Load environment variables from .env file
 load_dotenv()
@@ -119,27 +121,53 @@ def review(
 @app.command()
 def solve(
     query: str,
+    interactive: bool = typer.Option(False, "--interactive", "-i", help="Run in interactive mode to refine the solution."),
+    trace: bool = typer.Option(False, "--trace", help="Show the internal reasoning trace."),
     dry_run: bool = typer.Option(False, "--dry-run", help="Run in dry-run mode.")
 ):
     """
-    Generate a solution for the given query.
+    Generate and apply a solution for the given query.
     """
     model = get_model()
     engine = ReasoningEngine(model)
     console.print(Panel(f"[bold blue]Akita[/] is thinking about: [italic]{query}[/]", title="Solve Mode"))
     
+    current_query = query
+    session = None
+    
     try:
-        diff_output = engine.run_solve(query)
-        
-        console.print(Panel("[bold green]Suggested Code Changes (Unified Diff):[/]"))
-        syntax = Syntax(diff_output, "diff", theme="monokai", line_numbers=True)
-        console.print(syntax)
-        
+        while True:
+            diff_output = engine.run_solve(current_query, session=session)
+            session = engine.session
+            
+            if trace:
+                console.print(Panel(str(engine.trace), title="[bold cyan]Reasoning Trace[/]", border_style="cyan"))
+            console.print(Panel("[bold green]Suggested Code Changes (Unified Diff):[/]"))
+            syntax = Syntax(diff_output, "diff", theme="monokai", line_numbers=True)
+            console.print(syntax)
+            
+            if interactive:
+                action = typer.prompt("\n[A]pprove, [R]efine with feedback, or [C]ancel?", default="A").upper()
+                if action == "A":
+                    break
+                elif action == "R":
+                    current_query = typer.prompt("Enter your feedback/refinement")
+                    continue
+                else:
+                    console.print("[yellow]Operation cancelled.[/]")
+                    return
+            else:
+                break
+
         if not dry_run:
             confirm = typer.confirm("\nDo you want to apply these changes?")
             if confirm:
-                console.print("[bold yellow]Applying changes... (DiffApplier to be implemented next)[/]")
-                # We will implement DiffApplier in the next step
+                console.print("[bold yellow]🚀 Applying changes...[/]")
+                success = DiffApplier.apply_unified_diff(diff_output)
+                if success:
+                    console.print("[bold green]✅ Changes applied successfully![/]")
+                else:
+                    console.print("[bold red]❌ Failed to apply changes.[/]")
             else:
                 console.print("[bold yellow]Changes discarded.[/]")
     except Exception as e:
@@ -165,12 +193,29 @@ def plan(
         console.print(f"[bold red]Planning failed:[/] {e}")
         raise typer.Exit(code=1)
 
+@app.command()
+def index(
+    path: str = typer.Argument(".", help="Path to index for RAG.")
+):
+    """
+    Build a local vector index (RAG) for the project.
+    """
+    console.print(Panel(f"🔍 [bold blue]Akita[/] is indexing: [yellow]{path}[/]", title="Index Mode"))
+    try:
+        indexer = CodeIndexer(path)
+        with console.status("[bold green]Indexing project files..."):
+            indexer.index_project()
+        console.print("[bold green]✅ Indexing complete! Semantic search is now active.[/]")
+    except Exception as e:
+        console.print(f"[bold red]Indexing failed:[/] {e}")
+        raise typer.Exit(code=1)
+
 @app.command()
 def test():
     """
     Run automated tests in the project.
     """
-    console.print(Panel("🐶 [bold blue]Akita[/] is running tests...", title="Test Mode"))
+    console.print(Panel("[bold blue]Akita[/] is running tests...", title="Test Mode"))
     from akita.tools.base import ShellTools
     result = ShellTools.execute("pytest")
     if result.success:
@@ -180,6 +225,26 @@ def test():
         console.print("[bold red]Tests failed![/]")
         console.print(result.error or result.output)
 
+@app.command()
+def docs():
+    """
+    Start the local documentation server.
+    """
+    import subprocess
+    import sys
+    
+    console.print(Panel("[bold blue]Akita[/] Documentation", title="Docs Mode"))
+    console.print("[dim]Starting MkDocs server...[/]")
+    console.print("[bold green]Open your browser at: http://127.0.0.1:8000[/]")
+    
+    try:
+        subprocess.run([sys.executable, "-m", "mkdocs", "serve"], check=True)
+    except FileNotFoundError:
+        console.print("[red]MkDocs not found. Install it with: pip install mkdocs-material[/]")
+        raise typer.Exit(code=1)
+    except KeyboardInterrupt:
+        console.print("[yellow]Documentation server stopped.[/]")
+
 # Config Command Group
 config_app = typer.Typer(help="Manage AkitaLLM configuration.")
 app.add_typer(config_app, name="config")

akitallm-1.0.3/akita/core/ast_utils.py

@@ -0,0 +1,77 @@
+import tree_sitter_python as tspython
+from tree_sitter import Language, Parser
+import pathlib
+from typing import List, Dict, Any, Optional
+
+class ASTParser:
+    def __init__(self):
+        self.language = Language(tspython.language())
+        self.parser = Parser(self.language)
+
+    def parse_file(self, file_path: str) -> Optional[Any]:
+        path = pathlib.Path(file_path)
+        if not path.exists():
+            return None
+        
+        with open(path, "rb") as f:
+            content = f.read()
+        
+        return self.parser.parse(content)
+
+    def get_definitions(self, file_path: str) -> List[Dict[str, Any]]:
+        """Extract classes and functions with their line ranges using recursive traversal."""
+        tree = self.parse_file(file_path)
+        if not tree:
+            return []
+
+        with open(file_path, "rb") as f:
+            content = f.read()
+
+        definitions = []
+        
+        def explore(node):
+            # Check for definitions
+            if node.type in ["class_definition", "function_definition", "decorated_definition"]:
+                # Find name
+                name_node = node.child_by_field_name("name")
+                if not name_node and node.type == "decorated_definition":
+                    # For decorated definitions, the name is in the class/function child
+                    inner = node.child_by_field_name("definition")
+                    if inner:
+                        name_node = inner.child_by_field_name("name")
+                
+                name = content[name_node.start_byte:name_node.end_byte].decode("utf-8") if name_node else "anonymous"
+                
+                # Docstring extraction
+                docstring = None
+                body = node.child_by_field_name("body")
+                if body and body.children:
+                    for stmt in body.children:
+                        if stmt.type == "expression_statement":
+                            child = stmt.children[0]
+                            if child.type == "string":
+                                docstring = content[child.start_byte:child.end_byte].decode("utf-8").strip('"\' \n')
+                        break # Only first statement
+
+                definitions.append({
+                    "name": name,
+                    "type": "class" if "class" in node.type else "function",
+                    "start_line": node.start_point[0] + 1,
+                    "end_line": node.end_point[0] + 1,
+                    "docstring": docstring
+                })
+
+            # Always explore children regardless of current node type
+            for child in node.children:
+                explore(child)
+
+        explore(tree.root_node)
+        return definitions
+
+    def get_source_segment(self, file_path: str, start_line: int, end_line: int) -> str:
+        """Extract a segment of code from a file by line numbers."""
+        with open(file_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+        
+        # Lines are 1-indexed in our definitions, but 0-indexed in the list
+        return "".join(lines[start_line-1 : end_line])

akitallm-1.0.3/akita/core/indexing.py

@@ -0,0 +1,94 @@
+import os
+import json
+import re
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from akita.core.ast_utils import ASTParser
+
+class CodeIndexer:
+    """
+    A lightweight, zero-dependency semantic-keyword indexer.
+    Uses basic TF-IDF principles and AST-aware keyword weighting.
+    Works perfectly even in restricted environments like Python 3.14.
+    """
+    def __init__(self, project_path: str):
+        self.project_path = Path(project_path)
+        self.index_file = self.project_path / ".akita" / "index.json"
+        self.ast_parser = ASTParser()
+        self.data: List[Dict[str, Any]] = []
+        self.load_index()
+
+    def load_index(self):
+        if self.index_file.exists():
+            try:
+                with open(self.index_file, "r", encoding="utf-8") as f:
+                    self.data = json.load(f)
+            except Exception:
+                self.data = []
+
+    def save_index(self):
+        self.index_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.index_file, "w", encoding="utf-8") as f:
+            json.dump(self.data, f, indent=2)
+
+    def index_project(self):
+        """Index all Python files in the project."""
+        self.data = []
+        for root, _, files in os.walk(self.project_path):
+            if ".akita" in root or ".git" in root or "__pycache__" in root:
+                continue
+                
+            for file in files:
+                if file.endswith(".py"):
+                    full_path = Path(root) / file
+                    rel_path = full_path.relative_to(self.project_path)
+                    self._index_file(full_path, str(rel_path))
+        self.save_index()
+
+    def _index_file(self, file_path: Path, rel_path: str):
+        try:
+            definitions = self.ast_parser.get_definitions(str(file_path))
+            for d in definitions:
+                source = self.ast_parser.get_source_segment(
+                    str(file_path), d["start_line"], d["end_line"]
+                )
+                
+                # Create a searchable representation (keyword rich)
+                # We normalize case and extract meaningful words
+                search_blob = f"{d['name']} {d['type']} {d['docstring'] or ''} {source}"
+                keywords = set(re.findall(r'\w+', search_blob.lower()))
+                
+                self.data.append({
+                    "path": rel_path,
+                    "name": d["name"],
+                    "type": d["type"],
+                    "start_line": d["start_line"],
+                    "end_line": d["end_line"],
+                    "keywords": list(keywords),
+                    "content": source[:500] # Store snippet preview
+                })
+        except Exception:
+            pass
+
+    def search(self, query: str, n_results: int = 5) -> List[Dict[str, Any]]:
+        """Search using Jaccard Similarity on keywords (Lite Contextual Search)."""
+        query_keywords = set(re.findall(r'\w+', query.lower()))
+        if not query_keywords:
+            return []
+
+        scores = []
+        for item in self.data:
+            item_keywords = set(item["keywords"])
+            intersection = query_keywords.intersection(item_keywords)
+            # Simple intersection count as score, weighted by name match
+            score = len(intersection)
+            if any(qk in item["name"].lower() for qk in query_keywords):
+                score += 5 # Boost explicit name matches
+                
+            if score > 0:
+                scores.append((score, item))
+
+        # Sort by score descending
+        scores.sort(key=lambda x: x[0], reverse=True)
+        
+        return [s[1] for s in scores[:n_results]]

akitallm-1.0.3/akita/core/plugins.py

@@ -0,0 +1,81 @@
+import abc
+import importlib
+import importlib.metadata
+import inspect
+import pkgutil
+from pathlib import Path
+from typing import List, Dict, Any, Type, Optional
+
+class AkitaPlugin(abc.ABC):
+    """Base class for all AkitaLLM plugins."""
+    
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        """Unique name of the plugin."""
+        pass
+
+    @property
+    @abc.abstractmethod
+    def description(self) -> str:
+        """Brief description of what the plugin does."""
+        pass
+
+    @abc.abstractmethod
+    def get_tools(self) -> List[Dict[str, Any]]:
+        """Return a list of tools (functions) provided by this plugin."""
+        pass
+
+class PluginManager:
+    def __init__(self, internal_plugins_path: Optional[str] = None):
+        self.plugins: Dict[str, AkitaPlugin] = {}
+        self.internal_path = internal_plugins_path or str(Path(__file__).parent.parent / "plugins")
+
+    def discover_all(self):
+        """Discover both internal and external plugins."""
+        self._discover_internal()
+        self._discover_external()
+
+    def _discover_internal(self):
+        """Load plugins from the akita/plugins directory."""
+        path = Path(self.internal_path)
+        if not path.exists():
+            return
+
+        for loader, module_name, is_pkg in pkgutil.iter_modules([str(path)]):
+            full_module_name = f"akita.plugins.{module_name}"
+            try:
+                module = importlib.import_module(full_module_name)
+                self._load_from_module(module)
+            except Exception as e:
+                print(f"Error loading internal plugin {module_name}: {e}")
+
+    def _discover_external(self):
+        """Load plugins registered via entry_points (akitallm.plugins)."""
+        try:
+            # Python 3.10+
+            eps = importlib.metadata.entry_points(group='akitallm.plugins')
+            for entry_point in eps:
+                try:
+                    plugin_class = entry_point.load()
+                    if inspect.isclass(plugin_class) and issubclass(plugin_class, AkitaPlugin):
+                        instance = plugin_class()
+                        self.plugins[instance.name] = instance
+                except Exception as e:
+                    print(f"Error loading external plugin {entry_point.name}: {e}")
+        except Exception:
+            pass
+
+    def _load_from_module(self, module):
+        """Extract AkitaPlugin classes from a module and instantiate them."""
+        for name, obj in inspect.getmembers(module):
+            if inspect.isclass(obj) and issubclass(obj, AkitaPlugin) and obj is not AkitaPlugin:
+                instance = obj()
+                self.plugins[instance.name] = instance
+
+    def get_all_tools(self) -> List[Dict[str, Any]]:
+        """Collect all tools from all loaded plugins."""
+        all_tools = []
+        for plugin in self.plugins.values():
+            all_tools.extend(plugin.get_tools())
+        return all_tools

akitallm-1.0.3/akita/core/trace.py

@@ -0,0 +1,18 @@
+from typing import List, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+class TraceStep(BaseModel):
+    timestamp: datetime = Field(default_factory=datetime.now)
+    action: str
+    details: str
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+class ReasoningTrace(BaseModel):
+    steps: List[TraceStep] = Field(default_factory=list)
+
+    def add_step(self, action: str, details: str, metadata: Dict[str, Any] = None):
+        self.steps.append(TraceStep(action=action, details=details, metadata=metadata or {}))
+
+    def __str__(self):
+        return "\n".join([f"[{s.timestamp.strftime('%H:%M:%S')}] {s.action}: {s.details}" for s in self.steps])

akitallm-1.0.3/akita/plugins/__init__.py

@@ -0,0 +1 @@
+# Official AkitaLLM Plugins