ali-tool 0.1.0__py3-none-any.whl

ali_tool/__init__.py

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

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/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/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)

ali_tool/core/plugin.py

@@ -0,0 +1,101 @@
+"""Plugin - Loads and holds plugin YAML configuration."""
+
+import sys
+import shutil
+import subprocess
+import yaml
+from pathlib import Path
+
+
+class Plugin:
+    """A plugin loaded from YAML. Just data, no logic."""
+
+    def __init__(self, yaml_path: Path):
+        self.path = yaml_path
+        self.name = yaml_path.parent.name
+
+        with open(yaml_path) as f:
+            self.config = yaml.safe_load(f)
+
+        self.version = self.config.get("version", "1.0")
+        self.description = self.config.get("description", "")
+        self.provides = self.config.get("provides", {})
+        self.requires = self.config.get("requires", [])
+        self.grammar = self.config.get("grammar", {})
+
+        vocab = self.config.get("vocabulary", {})
+        self.verbs = set(vocab.get("verbs", []))
+
+        self.expectations = self.config.get("expectations", {})
+        self.inference = self.config.get("inference", [])
+        self.commands = self.config.get("commands", [])
+        self.selectors = self.config.get("selectors", {})
+        self.context = self.config.get("context", {})
+        self.integration = self.config.get("integration", {})
+
+    def is_active(self) -> bool:
+        """Check if plugin should be active based on context requirements."""
+        if not self.context:
+            return True
+
+        if "requires_env" in self.context:
+            import os
+
+            required = self.context["requires_env"]
+            if isinstance(required, str):
+                required = [required]
+            for env_var in required:
+                if env_var not in os.environ:
+                    return False
+
+        return True
+
+    def init(self) -> int:
+        """Initialize plugin integration files and show instructions.
+
+        Returns:
+            Exit code: 0 for success, 1 for error
+        """
+        if not self.integration:
+            print(
+                f"Plugin '{self.name}' has no integration configuration",
+                file=sys.stderr,
+            )
+            return 1
+
+        print(f"Initializing {self.name} integration...", file=sys.stderr)
+
+        for file_info in self.integration.get("files", []):
+            source = self.path.parent / file_info["source"]
+            target = Path(file_info["target"]).expanduser()
+
+            if not source.exists():
+                print(f"✗ Source file not found: {source}", file=sys.stderr)
+                continue
+
+            target.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                shutil.copy(source, target)
+                print(f"✓ Copied {file_info['source']} to {target}", file=sys.stderr)
+            except Exception as e:
+                print(f"✗ Failed to copy {file_info['source']}: {e}", file=sys.stderr)
+
+        check_cmd = self.integration.get("check_command")
+        if check_cmd:
+            result = subprocess.run(check_cmd, shell=True, capture_output=True)
+            if result.returncode == 0:
+                print("✓ Already integrated", file=sys.stderr)
+            else:
+                print("✗ Not yet integrated", file=sys.stderr)
+                print("\nTo complete setup:", file=sys.stderr)
+                print(self.integration.get("instructions", ""), file=sys.stderr)
+
+        usage = self.integration.get("usage")
+        if usage:
+            print(f"\nUsage: {usage}", file=sys.stderr)
+
+        return 0
+
+    def __repr__(self):
+        """Return string representation of plugin."""
+        return f"Plugin({self.name} v{self.version})"

ali_tool/core/registry.py

@@ -0,0 +1,62 @@
+"""Service Registry - Tracks plugin services and dependencies."""
+
+from typing import Dict, List
+from pathlib import Path
+from .plugin import Plugin
+
+
+class ServiceRegistry:
+    """Tracks what services plugins provide and require."""
+
+    def __init__(self, logger=None):
+        self.plugins: List[Plugin] = []
+        self.providers: Dict[str, List[Plugin]] = {}
+        self.verb_index: Dict[str, List[Plugin]] = {}
+        self.logger = logger
+
+    def load_plugins(self, plugin_dir: Path) -> None:
+        """Load all plugins from directory and build indices."""
+        self.plugins = []
+        self.providers = {}
+        self.verb_index = {}
+
+        for yaml_path in plugin_dir.glob("*/plugin.yaml"):
+            try:
+                plugin = Plugin(yaml_path)
+
+                if plugin.is_active():
+                    self.register(plugin)
+                else:
+                    if self.logger:
+                        self.logger.debug(f"Skipped (inactive): {plugin.name}")
+
+            except Exception as e:
+                if self.logger:
+                    self.logger.log_plugin_load(yaml_path.parent.name, False, str(e))
+
+    def register(self, plugin: Plugin) -> None:
+        """Register plugin and build service and verb indices."""
+        self.plugins.append(plugin)
+
+        if isinstance(plugin.provides, dict):
+            for service_name in plugin.provides:
+                if service_name not in self.providers:
+                    self.providers[service_name] = []
+                self.providers[service_name].append(plugin)
+        elif isinstance(plugin.provides, list):
+            for service_name in plugin.provides:
+                if service_name not in self.providers:
+                    self.providers[service_name] = []
+                self.providers[service_name].append(plugin)
+
+        for verb in plugin.verbs:
+            if verb not in self.verb_index:
+                self.verb_index[verb] = []
+            self.verb_index[verb].append(plugin)
+
+        if self.logger:
+            self.logger.log_plugin_load(plugin.name, True)
+
+    def get_plugins_for_verb(self, verb: str) -> List[Plugin]:
+        """Get all plugins that handle the given verb."""
+        return self.verb_index.get(verb.upper(), [])