lackpy 0.1.0__py3-none-any.whl

lackpy/__init__.py

@@ -0,0 +1,24 @@
+"""lackpy: Python that lacks most of Python."""
+
+__version__ = "0.1.0"
+
+from .service import LackpyService
+from .lang.validator import validate, ValidationResult
+from .lang.grader import Grade, compute_grade
+from .lang.grammar import ALLOWED_NODES, FORBIDDEN_NODES, FORBIDDEN_NAMES, ALLOWED_BUILTINS
+from .kit.toolbox import Toolbox, ToolSpec, ArgSpec
+from .kit.registry import resolve_kit, ResolvedKit
+from .run.runner import RestrictedRunner
+from .run.base import ExecutionResult
+from .run.trace import Trace, TraceEntry
+
+__all__ = [
+    "LackpyService",
+    "validate", "ValidationResult",
+    "Grade", "compute_grade",
+    "ALLOWED_NODES", "FORBIDDEN_NODES", "FORBIDDEN_NAMES", "ALLOWED_BUILTINS",
+    "Toolbox", "ToolSpec", "ArgSpec",
+    "resolve_kit", "ResolvedKit",
+    "RestrictedRunner", "ExecutionResult",
+    "Trace", "TraceEntry",
+]

lackpy/cli.py

@@ -0,0 +1,255 @@
+"""Command-line interface for lackpy."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def _parse_kit(kit_str: str) -> str | list[str]:
+    if "," in kit_str:
+        return [k.strip() for k in kit_str.split(",")]
+    return kit_str
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="lackpy",
+        description="lackpy — micro-inferencer for restricted Python programs",
+    )
+    parser.add_argument(
+        "--workspace", type=Path, default=None,
+        help="Workspace directory (default: cwd)",
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    # delegate
+    delegate_p = subparsers.add_parser("delegate", help="Generate and run a program from intent")
+    delegate_p.add_argument("intent", help="Natural language intent")
+    delegate_p.add_argument("--kit", default=None, help="Kit name, comma-separated list, or @file")
+    delegate_p.add_argument("--sandbox", default=None, help="Sandbox profile")
+
+    # generate
+    generate_p = subparsers.add_parser("generate", help="Generate a program from intent without running")
+    generate_p.add_argument("intent", help="Natural language intent")
+    generate_p.add_argument("--kit", default=None, help="Kit name or comma-separated list")
+
+    # run
+    run_p = subparsers.add_parser("run", help="Run a program file")
+    run_p.add_argument("file", help="Program file to run")
+    run_p.add_argument("--kit", default=None, help="Kit name or comma-separated list")
+
+    # create
+    create_p = subparsers.add_parser("create", help="Validate and save a program as a template")
+    create_p.add_argument("file", help="Program file to save as template")
+    create_p.add_argument("--name", required=True, help="Template name")
+    create_p.add_argument("--kit", default=None, help="Kit name or comma-separated list")
+    create_p.add_argument("--pattern", default=None, help="Intent pattern regex")
+
+    # validate
+    validate_p = subparsers.add_parser("validate", help="Validate a program without running")
+    validate_p.add_argument("file", help="Program file to validate")
+    validate_p.add_argument("--kit", default=None, help="Kit name or comma-separated list")
+
+    # spec
+    subparsers.add_parser("spec", help="Print language spec")
+
+    # status
+    subparsers.add_parser("status", help="Show lackpy status and configuration")
+
+    # kit
+    kit_p = subparsers.add_parser("kit", help="Manage kits")
+    kit_sub = kit_p.add_subparsers(dest="kit_command")
+
+    kit_sub.add_parser("list", help="List available kits")
+
+    kit_info_p = kit_sub.add_parser("info", help="Show kit info")
+    kit_info_p.add_argument("name", help="Kit name or comma-separated tools")
+    kit_info_p.add_argument("--tools", nargs="+", default=None, help="Tool names")
+
+    kit_create_p = kit_sub.add_parser("create", help="Create a new kit")
+    kit_create_p.add_argument("name", help="Kit name")
+    kit_create_p.add_argument("--tools", nargs="+", required=True, help="Tool names to include")
+    kit_create_p.add_argument("--description", default=None, help="Kit description")
+
+    # toolbox
+    toolbox_p = subparsers.add_parser("toolbox", help="Manage toolbox")
+    toolbox_sub = toolbox_p.add_subparsers(dest="toolbox_command")
+
+    toolbox_sub.add_parser("list", help="List all registered tools")
+
+    toolbox_show_p = toolbox_sub.add_parser("show", help="Show tool details")
+    toolbox_show_p.add_argument("name", help="Tool name")
+
+    # template
+    template_p = subparsers.add_parser("template", help="Manage templates")
+    template_sub = template_p.add_subparsers(dest="template_command")
+
+    template_sub.add_parser("list", help="List available templates")
+
+    template_test_p = template_sub.add_parser("test", help="Test a template")
+    template_test_p.add_argument("name", help="Template name")
+
+    # init
+    init_p = subparsers.add_parser("init", help="Initialize .lackpy workspace")
+    init_p.add_argument("--ollama-model", default="qwen2.5-coder:1.5b", help="Default Ollama model")
+
+    return parser
+
+
+def _init_config(workspace: Path, ollama_model: str) -> None:
+    config_dir = workspace / ".lackpy"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    (config_dir / "templates").mkdir(exist_ok=True)
+    (config_dir / "kits").mkdir(exist_ok=True)
+    config_file = config_dir / "config.toml"
+    if config_file.exists():
+        print(f"Config already exists at {config_file}", file=sys.stderr)
+        return
+    config_file.write_text(f"""\
+[inference]
+order = ["templates", "rules", "ollama-local"]
+
+[inference.providers.ollama-local]
+plugin = "ollama"
+host = "http://localhost:11434"
+model = "{ollama_model}"
+
+[kit]
+default = "debug"
+
+[sandbox]
+enabled = false
+timeout_seconds = 120
+memory_mb = 512
+""")
+    print(f"Initialized lackpy workspace at {config_dir}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command is None:
+        parser.print_help()
+        return 0
+
+    workspace = args.workspace or Path.cwd()
+
+    if args.command == "init":
+        _init_config(workspace, args.ollama_model)
+        return 0
+
+    if args.command == "spec":
+        from .lang.spec import get_spec
+        print(json.dumps(get_spec(), indent=2))
+        return 0
+
+    from .service import LackpyService
+    svc = LackpyService(workspace=workspace)
+
+    if args.command == "status":
+        config = svc._config
+        info = {
+            "workspace": str(workspace),
+            "config_dir": str(config.config_dir),
+            "inference_order": config.inference_order,
+            "kit_default": config.kit_default,
+            "sandbox_enabled": config.sandbox_enabled,
+            "tools": len(svc.toolbox.tools),
+        }
+        print(json.dumps(info, indent=2))
+        return 0
+
+    if args.command == "toolbox":
+        if args.toolbox_command == "list":
+            tools = svc.toolbox_list()
+            print(json.dumps(tools, indent=2))
+        elif args.toolbox_command == "show":
+            tools = svc.toolbox_list()
+            match = [t for t in tools if t["name"] == args.name]
+            if not match:
+                print(f"Tool '{args.name}' not found", file=sys.stderr)
+                return 1
+            print(json.dumps(match[0], indent=2))
+        else:
+            print("Usage: lackpy toolbox {list|show}", file=sys.stderr)
+            return 1
+        return 0
+
+    if args.command == "kit":
+        if args.kit_command == "list":
+            kits = svc.kit_list()
+            print(json.dumps(kits, indent=2))
+        elif args.kit_command == "info":
+            kit = _parse_kit(args.name) if args.tools is None else args.tools
+            info = svc.kit_info(kit)
+            print(json.dumps(info, indent=2))
+        elif args.kit_command == "create":
+            result = svc.kit_create(args.name, args.tools, args.description)
+            print(json.dumps(result, indent=2))
+        else:
+            print("Usage: lackpy kit {list|info|create}", file=sys.stderr)
+            return 1
+        return 0
+
+    if args.command == "template":
+        if args.template_command == "list":
+            templates_dir = svc._config.config_dir / "templates"
+            if not templates_dir.exists():
+                print("[]")
+            else:
+                tmpls = [{"name": p.stem, "path": str(p)} for p in sorted(templates_dir.glob("*.tmpl"))]
+                print(json.dumps(tmpls, indent=2))
+        elif args.template_command == "test":
+            print(f"Testing template '{args.name}' not yet implemented", file=sys.stderr)
+            return 1
+        else:
+            print("Usage: lackpy template {list|test}", file=sys.stderr)
+            return 1
+        return 0
+
+    kit = _parse_kit(args.kit) if getattr(args, "kit", None) else None
+
+    if args.command == "validate":
+        program = Path(args.file).read_text()
+        result = svc.validate(program, kit=kit)
+        out: dict[str, Any] = {"valid": result.valid, "errors": result.errors, "calls": list(result.calls)}
+        print(json.dumps(out, indent=2))
+        return 0 if result.valid else 1
+
+    if args.command == "run":
+        program = Path(args.file).read_text()
+        result = asyncio.run(svc.run_program(program, kit=kit))
+        out = {"success": result.success, "output": result.output, "error": result.error}
+        print(json.dumps(out, indent=2))
+        return 0 if result.success else 1
+
+    if args.command == "generate":
+        result = asyncio.run(svc.generate(args.intent, kit=kit))
+        print(result.program)
+        return 0
+
+    if args.command == "create":
+        program = Path(args.file).read_text()
+        result = asyncio.run(svc.create(program, kit=kit, name=args.name, pattern=args.pattern))
+        print(json.dumps(result, indent=2))
+        return 0 if result.get("success") else 1
+
+    if args.command == "delegate":
+        sandbox = getattr(args, "sandbox", None)
+        result = asyncio.run(svc.delegate(args.intent, kit=kit, sandbox=sandbox))
+        print(json.dumps(result, indent=2))
+        return 0 if result["success"] else 1
+
+    print(f"Unknown command: {args.command}", file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

lackpy/config.py

@@ -0,0 +1,56 @@
+"""Configuration loading from .lackpy/config.toml."""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomllib
+    except ImportError:
+        import tomli as tomllib  # type: ignore[no-redef]
+
+
+@dataclass
+class LackpyConfig:
+    inference_order: list[str] = field(default_factory=lambda: ["templates", "rules"])
+    inference_providers: dict[str, dict[str, Any]] = field(default_factory=dict)
+    kit_default: str = "debug"
+    sandbox_enabled: bool = False
+    sandbox_timeout: int = 120
+    sandbox_memory_mb: int = 512
+    tool_providers: dict[str, dict[str, Any]] = field(default_factory=dict)
+    config_dir: Path = field(default_factory=lambda: Path(".lackpy"))
+
+
+def load_config(workspace: Path | None = None) -> LackpyConfig:
+    if workspace is None:
+        workspace = Path.cwd()
+    config_dir = workspace / ".lackpy"
+    config_file = config_dir / "config.toml"
+    if not config_file.exists():
+        return LackpyConfig(config_dir=config_dir)
+    with open(config_file, "rb") as f:
+        data = tomllib.load(f)
+    inference = data.get("inference", {})
+    kit = data.get("kit", {})
+    sandbox = data.get("sandbox", {})
+    tool_providers = data.get("tool_providers", {})
+    providers: dict[str, dict[str, Any]] = {}
+    for name, cfg in inference.get("providers", {}).items():
+        providers[name] = cfg
+    return LackpyConfig(
+        inference_order=inference.get("order", ["templates", "rules"]),
+        inference_providers=providers,
+        kit_default=kit.get("default", "debug"),
+        sandbox_enabled=sandbox.get("enabled", False),
+        sandbox_timeout=sandbox.get("timeout_seconds", 120),
+        sandbox_memory_mb=sandbox.get("memory_mb", 512),
+        tool_providers=tool_providers,
+        config_dir=config_dir,
+    )

lackpy/infer/__init__.py

@@ -0,0 +1 @@
+"""lackpy inference: program generation from natural language intent."""

lackpy/infer/dispatch.py

@@ -0,0 +1,60 @@
+"""Priority-ordered inference dispatch across provider plugins."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any
+
+from ..lang.validator import validate
+from .sanitize import sanitize_output
+
+
+@dataclass
+class GenerationResult:
+    program: str
+    provider_name: str
+    generation_time_ms: float
+
+
+class InferenceDispatcher:
+    def __init__(self, providers: list[Any]) -> None:
+        self._providers = providers
+
+    async def generate(self, intent: str, namespace_desc: str, allowed_names: set[str],
+                       params_desc: str | None = None, extra_rules: list | None = None) -> GenerationResult:
+        start = time.perf_counter()
+        errors_by_provider: dict[str, list[str]] = {}
+
+        for provider in self._providers:
+            if not provider.available():
+                continue
+
+            raw = await provider.generate(intent, namespace_desc)
+            if raw is None:
+                continue
+
+            program = sanitize_output(raw)
+            validation = validate(program, allowed_names=allowed_names, extra_rules=extra_rules)
+            if validation.valid:
+                elapsed = (time.perf_counter() - start) * 1000
+                return GenerationResult(program=program, provider_name=provider.name, generation_time_ms=elapsed)
+
+            errors_by_provider[provider.name] = validation.errors
+            raw = await provider.generate(intent, namespace_desc, error_feedback=validation.errors)
+            if raw is None:
+                continue
+
+            program = sanitize_output(raw)
+            validation = validate(program, allowed_names=allowed_names, extra_rules=extra_rules)
+            if validation.valid:
+                elapsed = (time.perf_counter() - start) * 1000
+                return GenerationResult(program=program, provider_name=provider.name, generation_time_ms=elapsed)
+
+            errors_by_provider[provider.name] = validation.errors
+
+        provider_names = [p.name for p in self._providers if p.available()]
+        raise RuntimeError(
+            f"All {len(provider_names)} providers failed to produce a valid program. "
+            f"Tried: {', '.join(provider_names)}. Last errors: {errors_by_provider}"
+        )

lackpy/infer/prompt.py

@@ -0,0 +1,51 @@
+"""System prompt construction for inference providers."""
+
+from __future__ import annotations
+
+from ..lang.grammar import ALLOWED_BUILTINS
+
+_TEMPLATE = """\
+You are a Jupyter notebook cell generator. Write a single cell \
+using ONLY the pre-loaded kernel namespace below.
+
+Output ONLY the cell contents — no markdown, no explanation, no code fences.
+
+Assign tool results to variables and reuse them. Never call the same function twice \
+when you can reuse a variable.
+
+Kernel namespace:
+{namespace_desc}
+
+Builtins: {builtins_list}
+{params_section}\
+Not available: import, def, class, while, try/except, lambda, open
+
+The cell's last expression is displayed as output."""
+
+
+def build_system_prompt(namespace_desc: str, params_desc: str | None = None) -> str:
+    builtins_list = ", ".join(sorted(ALLOWED_BUILTINS))
+    params_section = ""
+    if params_desc:
+        params_section = (
+            f"\nPre-set variables (already defined, use directly):\n"
+            f"{params_desc}\n\n"
+        )
+    return _TEMPLATE.format(
+        namespace_desc=namespace_desc,
+        builtins_list=builtins_list,
+        params_section=params_section,
+    )
+
+
+def format_params_description(params: dict) -> str:
+    lines = []
+    for name, value in params.items():
+        if isinstance(value, dict) and "value" in value:
+            ptype = value.get("type", type(value["value"]).__name__)
+            desc = value.get("description", "")
+            lines.append(f"  {name}: {ptype}" + (f" — {desc}" if desc else ""))
+        else:
+            ptype = type(value).__name__
+            lines.append(f"  {name}: {ptype}")
+    return "\n".join(lines)

lackpy/infer/providers/__init__.py

@@ -0,0 +1 @@
+"""Inference provider plugins."""

lackpy/infer/providers/anthropic.py

@@ -0,0 +1,46 @@
+"""Tier 3: Anthropic API fallback inference."""
+
+from __future__ import annotations
+
+from ..prompt import build_system_prompt
+
+
+class AnthropicProvider:
+    def __init__(self, model: str = "claude-haiku-4-5-20251001", max_tokens: int = 1024) -> None:
+        self._model = model
+        self._max_tokens = max_tokens
+
+    @property
+    def name(self) -> str:
+        return "anthropic"
+
+    def available(self) -> bool:
+        try:
+            import anthropic  # noqa: F401
+            return True
+        except ImportError:
+            return False
+
+    async def _create_message(self, system: str, messages: list[dict]) -> object:
+        import anthropic
+        client = anthropic.AsyncAnthropic()
+        return await client.messages.create(
+            model=self._model, max_tokens=self._max_tokens,
+            system=system, messages=messages,
+        )
+
+    async def generate(self, intent: str, namespace_desc: str,
+                       config: dict | None = None, error_feedback: list[str] | None = None) -> str | None:
+        if not self.available():
+            return None
+        system = build_system_prompt(namespace_desc)
+        user_msg = intent
+        if error_feedback:
+            user_msg += "\n\nPrevious attempt had these errors, please fix:\n" + "\n".join(f"- {e}" for e in error_feedback)
+        messages = [{"role": "user", "content": user_msg}]
+        try:
+            response = await self._create_message(system, messages)
+            content = response.content[0].text
+            return content.strip() if content else None
+        except Exception:
+            return None

lackpy/infer/providers/base.py

@@ -0,0 +1,15 @@
+"""Base protocol for inference providers."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+
+class InferenceProvider(Protocol):
+    @property
+    def name(self) -> str: ...
+    def available(self) -> bool: ...
+    async def generate(
+        self, intent: str, namespace_desc: str,
+        config: dict | None = None, error_feedback: list[str] | None = None,
+    ) -> str | None: ...

lackpy/infer/providers/ollama.py

@@ -0,0 +1,50 @@
+"""Tier 2: Ollama local model inference."""
+
+from __future__ import annotations
+
+from ..prompt import build_system_prompt
+
+
+class OllamaProvider:
+    def __init__(self, host: str = "http://localhost:11434", model: str = "qwen2.5-coder:1.5b",
+                 temperature: float = 0.2, keep_alive: str = "30m") -> None:
+        self._host = host
+        self._model = model
+        self._temperature = temperature
+        self._keep_alive = keep_alive
+
+    @property
+    def name(self) -> str:
+        return "ollama"
+
+    def available(self) -> bool:
+        try:
+            import ollama  # noqa: F401
+            return True
+        except ImportError:
+            return False
+
+    async def _chat(self, messages: list[dict], **kwargs) -> dict:
+        import ollama
+        client = ollama.AsyncClient(host=self._host)
+        return await client.chat(
+            model=self._model, messages=messages,
+            options={"temperature": self._temperature},
+            keep_alive=self._keep_alive, **kwargs,
+        )
+
+    async def generate(self, intent: str, namespace_desc: str,
+                       config: dict | None = None, error_feedback: list[str] | None = None) -> str | None:
+        if not self.available():
+            return None
+        system = build_system_prompt(namespace_desc)
+        user_msg = intent
+        if error_feedback:
+            user_msg += "\n\nPrevious attempt had these errors, please fix:\n" + "\n".join(f"- {e}" for e in error_feedback)
+        messages = [{"role": "system", "content": system}, {"role": "user", "content": user_msg}]
+        try:
+            response = await self._chat(messages)
+            content = response["message"]["content"]
+            return content.strip() if content else None
+        except Exception:
+            return None

lackpy/infer/providers/rules.py

@@ -0,0 +1,46 @@
+"""Tier 1: Rule-based inference — deterministic keyword-to-program mapping."""
+
+from __future__ import annotations
+
+import re
+
+
+class RulesProvider:
+    @property
+    def name(self) -> str:
+        return "rules"
+
+    def available(self) -> bool:
+        return True
+
+    async def generate(self, intent: str, namespace_desc: str,
+                       config: dict | None = None, error_feedback: list[str] | None = None) -> str | None:
+        lower = intent.lower().strip()
+        original = intent.strip()
+
+        m = re.match(r"read (?:the )?file (.+)", lower)
+        if m and "read(" in namespace_desc:
+            path = re.match(r"read (?:the )?file (.+)", original, re.IGNORECASE).group(1).strip().strip("'\"")
+            return f"content = read('{path}')\ncontent"
+
+        m = re.match(r"find (?:the )?definitions? (?:of |for )?(.+)", lower)
+        if m and "find_definitions(" in namespace_desc:
+            name = re.match(r"find (?:the )?definitions? (?:of |for )?(.+)", original, re.IGNORECASE).group(1).strip().strip("'\"")
+            return f"results = find_definitions('{name}')\nresults"
+
+        m = re.match(r"find (?:all )?(?:callers?|usages?|references?) (?:of |for )?(.+)", lower)
+        if m and "find_callers(" in namespace_desc:
+            name = re.match(r"find (?:all )?(?:callers?|usages?|references?) (?:of |for )?(.+)", original, re.IGNORECASE).group(1).strip().strip("'\"")
+            return f"results = find_callers('{name}')\nresults"
+
+        m = re.match(r"(?:find|list) all (\w+) files", lower)
+        if m and "glob(" in namespace_desc:
+            ext = m.group(1).strip()
+            return f"files = glob('**/*.{ext}')\nfiles"
+
+        m = re.match(r"glob (.+)", lower)
+        if m and "glob(" in namespace_desc:
+            pattern = re.match(r"glob (.+)", original, re.IGNORECASE).group(1).strip().strip("'\"")
+            return f"files = glob('{pattern}')\nfiles"
+
+        return None