ali-tool 0.1.0__tar.gz

ali_tool-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.3
+Name: ali-tool
+Version: 0.1.0
+Summary: Action Language Interpreter - One command for every tool
+Author: Fredrik Angelsen
+Author-email: Fredrik Angelsen <fredrikangelsen@gmail.com>
+Requires-Dist: pyyaml>=6.0.2
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# ALI - Action Language Interpreter
+
+[![PyPI version](https://badge.fury.io/py/ali-tool.svg)](https://pypi.org/project/ali-tool/)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Compose complex tmux commands from regular phrases. Pure command aggregator - outputs commands, never executes them.
+
+## Quickstart
+
+```bash
+# Install
+uv tool install ali-tool  # Recommended
+# OR
+pip install ali-tool
+
+# Initialize tmux integration
+ali --init tmux
+# Then reload tmux: tmux source ~/.tmux.conf
+
+# Use
+ali GO .2              # → tmux select-pane -t .2
+ali SPLIT pop          # → tmux display-popup -w 80% -h 80% -d "$PWD" -E 'bash'
+ali EDIT file.txt pop  # → tmux display-popup ... 'micro file.txt'
+ali WIDTH 012          # → Distribute panes evenly
+ali ECHO ed?           # → Popup editor, pipe output to send-keys
+```
+
+Press `C-b a` in tmux to open ALI prompt after initialization.
+
+## Architecture
+
+ALI is a pure command aggregator - it only outputs commands, never executes them.
+
+```
+Input → Parser → Router → Resolver → Output
+         ↓         ↓         ↓
+      Grammar  Commands  Templates
+```
+
+### Core Components
+
+- **Parser** - Tokenizes input using plugin grammars
+- **Router** - Matches patterns to find commands  
+- **Resolver** - Expands templates with conditionals and services
+- **Registry** - Manages plugins and their services
+
+### Template Engine
+
+```yaml
+# Conditionals
+exec: "{?target:tmux select-pane -t {target} && }command"
+
+# Array lookups  
+exec: "{direction[left:-h -b,right:-h,up:-v -b,down:-v,pop:display-popup]}"
+
+# Service composition
+exec: "{split} 'micro {file}'"  # Uses split service from tmux
+```
+
+## Plugin Development
+
+Plugins are YAML-only data files that define grammar, commands, and services.
+
+```yaml
+# plugin.yaml
+name: example
+version: 1.0
+description: Example plugin
+# Grammar
+grammar:
+  item: {type: string}
+  direction: {values: [left, right, up, down, pop]}
+# Commands  
+commands:
+  - match: {verb: ACTION, item: present}
+    exec: "{split} '{item}'"
+# Services
+services:
+  process: "tool --process"
+# Selectors
+selectors:
+  item?:
+    type: stream
+    exec: "selector"
+```
+
+See the [plugin documentation](https://github.com/angelsen/ali/tree/master/src/ali/plugins) for more patterns.
+
+## Examples
+
+### Navigation
+```bash
+ali GO .2          # Go to pane 2
+ali GO :3          # Go to window 3
+ali GO ?           # Visual pane selector
+```
+
+### Splits & Layout
+```bash
+ali SPLIT          # Split right (default)
+ali SPLIT left     # Split left
+ali SPLIT pop      # Open popup shell
+ali WIDTH 012      # Distribute panes evenly
+```
+
+### Editing
+```bash
+ali EDIT file.txt       # Edit in right split
+ali EDIT file.txt pop   # Edit in popup
+ali VIEW file.txt       # Read-only view
+```
+
+### Stream Operations
+```bash
+ali ECHO ed?       # Edit in popup, pipe to send-keys
+ali COPY br?       # Browse in popup, copy to clipboard
+```
+
+## Development
+
+```bash
+# Clone and install dev version
+git clone https://github.com/angelsen/ali.git
+cd ali
+uv tool install -e .
+
+# Test a command
+ali GO .2
+```
+
+## License
+
+MIT - see [LICENSE](LICENSE)

ali_tool-0.1.0/README.md

@@ -0,0 +1,134 @@
+# ALI - Action Language Interpreter
+
+[![PyPI version](https://badge.fury.io/py/ali-tool.svg)](https://pypi.org/project/ali-tool/)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Compose complex tmux commands from regular phrases. Pure command aggregator - outputs commands, never executes them.
+
+## Quickstart
+
+```bash
+# Install
+uv tool install ali-tool  # Recommended
+# OR
+pip install ali-tool
+
+# Initialize tmux integration
+ali --init tmux
+# Then reload tmux: tmux source ~/.tmux.conf
+
+# Use
+ali GO .2              # → tmux select-pane -t .2
+ali SPLIT pop          # → tmux display-popup -w 80% -h 80% -d "$PWD" -E 'bash'
+ali EDIT file.txt pop  # → tmux display-popup ... 'micro file.txt'
+ali WIDTH 012          # → Distribute panes evenly
+ali ECHO ed?           # → Popup editor, pipe output to send-keys
+```
+
+Press `C-b a` in tmux to open ALI prompt after initialization.
+
+## Architecture
+
+ALI is a pure command aggregator - it only outputs commands, never executes them.
+
+```
+Input → Parser → Router → Resolver → Output
+         ↓         ↓         ↓
+      Grammar  Commands  Templates
+```
+
+### Core Components
+
+- **Parser** - Tokenizes input using plugin grammars
+- **Router** - Matches patterns to find commands  
+- **Resolver** - Expands templates with conditionals and services
+- **Registry** - Manages plugins and their services
+
+### Template Engine
+
+```yaml
+# Conditionals
+exec: "{?target:tmux select-pane -t {target} && }command"
+
+# Array lookups  
+exec: "{direction[left:-h -b,right:-h,up:-v -b,down:-v,pop:display-popup]}"
+
+# Service composition
+exec: "{split} 'micro {file}'"  # Uses split service from tmux
+```
+
+## Plugin Development
+
+Plugins are YAML-only data files that define grammar, commands, and services.
+
+```yaml
+# plugin.yaml
+name: example
+version: 1.0
+description: Example plugin
+# Grammar
+grammar:
+  item: {type: string}
+  direction: {values: [left, right, up, down, pop]}
+# Commands  
+commands:
+  - match: {verb: ACTION, item: present}
+    exec: "{split} '{item}'"
+# Services
+services:
+  process: "tool --process"
+# Selectors
+selectors:
+  item?:
+    type: stream
+    exec: "selector"
+```
+
+See the [plugin documentation](https://github.com/angelsen/ali/tree/master/src/ali/plugins) for more patterns.
+
+## Examples
+
+### Navigation
+```bash
+ali GO .2          # Go to pane 2
+ali GO :3          # Go to window 3
+ali GO ?           # Visual pane selector
+```
+
+### Splits & Layout
+```bash
+ali SPLIT          # Split right (default)
+ali SPLIT left     # Split left
+ali SPLIT pop      # Open popup shell
+ali WIDTH 012      # Distribute panes evenly
+```
+
+### Editing
+```bash
+ali EDIT file.txt       # Edit in right split
+ali EDIT file.txt pop   # Edit in popup
+ali VIEW file.txt       # Read-only view
+```
+
+### Stream Operations
+```bash
+ali ECHO ed?       # Edit in popup, pipe to send-keys
+ali COPY br?       # Browse in popup, copy to clipboard
+```
+
+## Development
+
+```bash
+# Clone and install dev version
+git clone https://github.com/angelsen/ali.git
+cd ali
+uv tool install -e .
+
+# Test a command
+ali GO .2
+```
+
+## License
+
+MIT - see [LICENSE](LICENSE)

ali_tool-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "ali-tool"
+version = "0.1.0"
+description = "Action Language Interpreter - One command for every tool"
+readme = "README.md"
+authors = [{ name = "Fredrik Angelsen", email = "fredrikangelsen@gmail.com" }]
+requires-python = ">=3.12"
+dependencies = ["pyyaml>=6.0.2"]
+
+[project.scripts]
+ali = "ali_tool.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.8.8,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.basedpyright]
+typeCheckingMode = "standard"

ali_tool-0.1.0/src/ali_tool/__init__.py

@@ -0,0 +1,3 @@
+"""ALI - Action Language Interpreter."""
+
+__version__ = "0.1.0"

ali_tool-0.1.0/src/ali_tool/cli.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""ALI CLI - Main entry point."""
+
+import sys
+import os
+import argparse
+from pathlib import Path
+
+from .core import ServiceRegistry, Router
+from .core.logging import ALILogger
+from .scripts import execute_script
+
+EXIT_SUCCESS = 0
+EXIT_ERROR = 1
+EXIT_COMMAND_NOT_FOUND = 127
+
+ALI_VERSION = "2.0.0"
+
+
+def find_plugins_dir() -> Path:
+    """Find plugins directory in package or user config."""
+    package_dir = Path(__file__).parent / "plugins"
+    if package_dir.exists():
+        return package_dir
+
+    user_plugins = Path.home() / ".config" / "ali" / "plugins"
+    if user_plugins.exists():
+        return user_plugins
+
+    return package_dir
+
+
+def main():
+    """Main CLI entry point."""
+    if "--plugin-script" in sys.argv:
+        exit_code = execute_script(sys.argv)
+        sys.exit(exit_code)
+
+    parser = argparse.ArgumentParser(
+        description="ALI - Action Language Interpreter",
+        epilog="Examples:\n"
+        "  ali GO .2             # Go to pane 2\n"
+        "  ali SPLIT pop         # Open popup shell\n"
+        "  ali EDIT file.txt pop # Edit in popup\n"
+        "  ali WIDTH 012         # Distribute panes evenly\n"
+        "  ali ECHO ed?          # Edit and pipe output\n",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"ALI {ALI_VERSION}",
+        help="Show version and exit",
+    )
+
+    parser.add_argument(
+        "--list-verbs",
+        action="store_true",
+        help="List all available verbs",
+    )
+
+    parser.add_argument(
+        "--list-services",
+        action="store_true",
+        help="List all available services",
+    )
+
+    parser.add_argument(
+        "--list-grammar",
+        action="store_true",
+        help="List grammar definitions for all plugins",
+    )
+
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Enable verbose logging to stderr",
+    )
+
+    parser.add_argument(
+        "--quiet",
+        "-q",
+        action="store_true",
+        help="Disable all logging",
+    )
+
+    parser.add_argument(
+        "--plugins-dir",
+        type=Path,
+        help="Directory containing plugin definitions",
+    )
+
+    parser.add_argument(
+        "--init",
+        metavar="PLUGIN",
+        help="Initialize plugin integration (e.g., --init tmux)",
+    )
+
+    parser.add_argument(
+        "command",
+        nargs="*",
+        help="ALI command to execute",
+    )
+
+    args = parser.parse_args()
+
+    log_level = os.environ.get("ALI_LOG_LEVEL", "")
+    if args.quiet:
+        logger = None
+    elif args.verbose or log_level.upper() in ["DEBUG", "VERBOSE"]:
+        logger = ALILogger(verbose=True)
+    else:
+        logger = ALILogger(verbose=False)
+
+    registry = ServiceRegistry(logger=logger)
+    plugins_dir = args.plugins_dir or find_plugins_dir()
+
+    if not plugins_dir.exists():
+        print(f"Error: Plugins directory not found: {plugins_dir}", file=sys.stderr)
+        sys.exit(EXIT_ERROR)
+
+    registry.load_plugins(plugins_dir)
+
+    if logger:
+        logger.registry = registry
+
+    if args.init:
+        found = False
+        for plugin in registry.plugins:
+            if plugin.name == args.init:
+                found = True
+                exit_code = plugin.init()
+                sys.exit(exit_code if exit_code == 0 else EXIT_ERROR)
+        if not found:
+            print(f"Error: Plugin '{args.init}' not found", file=sys.stderr)
+            print(
+                f"Available plugins: {', '.join(p.name for p in registry.plugins)}",
+                file=sys.stderr,
+            )
+            sys.exit(EXIT_ERROR)
+
+    if args.list_services:
+        print("Available services:", file=sys.stderr)
+        for service, providers in sorted(registry.providers.items()):
+            provider_names = [p.name for p in providers]
+            print(
+                f"  {service:20} provided by: {', '.join(provider_names)}",
+                file=sys.stderr,
+            )
+        sys.exit(EXIT_SUCCESS)
+
+    if args.list_grammar:
+        print("Grammar definitions by plugin:", file=sys.stderr)
+        for plugin in registry.plugins:
+            if plugin.grammar:
+                print(f"\n{plugin.name}:", file=sys.stderr)
+                for field, grammar in plugin.grammar.items():
+                    if "pattern" in grammar:
+                        pattern = grammar["pattern"]
+                        if len(pattern) > 40:
+                            pattern = pattern[:40] + "..."
+                        print(f"  {field:15} pattern: {pattern}", file=sys.stderr)
+                    elif "values" in grammar:
+                        values_str = ", ".join(grammar["values"][:3])
+                        if len(grammar["values"]) > 3:
+                            values_str += "..."
+                        print(f"  {field:15} values: [{values_str}]", file=sys.stderr)
+                    elif "type" in grammar:
+                        print(f"  {field:15} type: {grammar['type']}", file=sys.stderr)
+        sys.exit(EXIT_SUCCESS)
+
+    if args.list_verbs:
+        if registry.verb_index:
+            print("Available verbs:", file=sys.stderr)
+            for verb, plugin_list in sorted(registry.verb_index.items()):
+                if plugin_list:
+                    plugin_names = ", ".join(p.name for p in plugin_list)
+                    print(f"  {verb:12} ({plugin_names})", file=sys.stderr)
+        else:
+            print("No verbs available (no plugins loaded)", file=sys.stderr)
+        sys.exit(EXIT_SUCCESS)
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(EXIT_ERROR)
+
+    command_str = " ".join(args.command)
+
+    router = Router(registry)
+    result = router.execute(command_str)
+
+    if logger:
+        tokens = router.last_tokens if hasattr(router, "last_tokens") else None
+        state = router.last_state if hasattr(router, "last_state") else None
+        success = not (result.startswith("Error:") or result.startswith("Unknown"))
+        logger.log_command(
+            command_str,
+            tokens=tokens,
+            state=state,
+            result=result if success else None,
+            error=result if not success else None,
+            success=success,
+        )
+
+    if result.startswith("Error:") or result.startswith("Unknown"):
+        print(result, file=sys.stderr)
+        exit_code = (
+            EXIT_COMMAND_NOT_FOUND if result.startswith("Unknown") else EXIT_ERROR
+        )
+        sys.exit(exit_code)
+
+    print(result)
+    sys.exit(EXIT_SUCCESS)
+
+
+if __name__ == "__main__":
+    main()

ali_tool-0.1.0/src/ali_tool/core/__init__.py

@@ -0,0 +1,13 @@
+"""ALI Core - Service-oriented plugin architecture."""
+
+from .plugin import Plugin
+from .registry import ServiceRegistry
+from .resolver import resolve_command
+from .router import Router
+
+__all__ = [
+    "Plugin",
+    "ServiceRegistry",
+    "resolve_command",
+    "Router",
+]

ali_tool-0.1.0/src/ali_tool/core/logging.py

@@ -0,0 +1,130 @@
+"""Centralized logging for ALI - plugin-driven environment capture."""
+
+import logging
+import json
+from pathlib import Path
+from datetime import datetime
+import os
+import uuid
+
+
+class ALILogger:
+    """Structured logging for pattern analysis."""
+
+    def __init__(self, verbose: bool = False, registry=None):
+        self.session_id = self._generate_session_id()
+        self.log_dir = Path.home() / ".local/share/ali/logs"
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+        self.registry = registry
+
+        self._setup_python_logging(verbose)
+
+    def _generate_session_id(self) -> str:
+        """Generate unique session ID with timestamp and UUID."""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        unique = str(uuid.uuid4())[:8]
+        return f"{timestamp}_{unique}"
+
+    def _setup_python_logging(self, verbose: bool):
+        """Configure Python logging handlers and formatters."""
+        self.logger = logging.getLogger("ali")
+        self.logger.setLevel(logging.DEBUG)
+
+        file_handler = logging.FileHandler(
+            self.log_dir / f"debug_{self.session_id}.log"
+        )
+        file_handler.setLevel(logging.DEBUG)
+        file_formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        file_handler.setFormatter(file_formatter)
+        self.logger.addHandler(file_handler)
+
+        if verbose:
+            import sys
+
+            console_handler = logging.StreamHandler(sys.stderr)
+            console_handler.setLevel(logging.DEBUG)
+            console_formatter = logging.Formatter("%(levelname)s: %(message)s")
+            console_handler.setFormatter(console_formatter)
+            self.logger.addHandler(console_handler)
+
+    def _collect_plugin_env(self) -> dict:
+        """Collect environment variables defined by plugins."""
+        env = {}
+
+        if not self.registry:
+            return env
+
+        for plugin in self.registry.plugins:
+            metadata = plugin.config.get("metadata", {})
+            env_config = metadata.get("environment", {})
+
+            for var_list in ["requires", "optional", "captures"]:
+                for var in env_config.get(var_list, []):
+                    if var in os.environ:
+                        env[var] = os.environ[var]
+
+        return env
+
+    def log_command(
+        self,
+        command_str: str,
+        tokens: list | None = None,
+        state: dict | None = None,
+        result: str | None = None,
+        error: str | None = None,
+        success: bool = True,
+    ):
+        """Log command execution with context and results.
+
+        Args:
+            command_str: Raw command string
+            tokens: Parsed command tokens
+            state: Command state after parsing
+            result: Command result if successful
+            error: Error message if failed
+            success: Whether command executed successfully
+        """
+        event = {
+            "timestamp": datetime.now().isoformat(),
+            "session_id": self.session_id,
+            "command_raw": command_str,
+            "tokens": tokens,
+            "state": state,
+            "result": result,
+            "error": error,
+            "success": success,
+            "env": self._collect_plugin_env(),
+        }
+
+        with open(self.log_dir / "commands.jsonl", "a") as f:
+            f.write(json.dumps(event) + "\n")
+
+        if success:
+            self.logger.debug(f"Command: {command_str} -> {result}")
+        else:
+            self.logger.error(f"Command failed: {command_str} -> {error}")
+
+    def log_plugin_load(
+        self, plugin_name: str, success: bool, error: str | None = None
+    ):
+        """Log plugin loading success or failure.
+
+        Args:
+            plugin_name: Name of the plugin
+            success: Whether plugin loaded successfully
+            error: Error message if loading failed
+        """
+        if success:
+            self.logger.debug(f"Loaded plugin: {plugin_name}")
+        else:
+            self.logger.warning(f"Failed to load plugin {plugin_name}: {error}")
+
+    def debug(self, message: str):
+        """Log debug message."""
+        self.logger.debug(message)
+
+    def error(self, message: str):
+        """Log error message."""
+        self.logger.error(message)