pal-code 0.1.1__tar.gz → 0.1.3__tar.gz

{pal_code-0.1.1 → pal_code-0.1.3}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Nandini Singh
+Copyright (c) 2026 Vrushal More
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{pal_code-0.1.1 → pal_code-0.1.3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pal-code
-Version: 0.1.1
+Version: 0.1.3
 Summary: Pal: build and plan with AI in your terminal (pal cli) or browser (pal web), on a layer that cuts tokens and latency.
-Author: Nandini Singh
+Author: Vrushal More
 License: MIT
 Keywords: ai,coding-assistant,cli,llm,ollama,tokens,code-graph
 Classifier: Development Status :: 4 - Beta
@@ -26,6 +26,9 @@ Requires-Dist: graphifyy>=0.9
 Requires-Dist: pypdf>=4.0
 Requires-Dist: python-pptx>=0.6.23
 Requires-Dist: openpyxl>=3.1
+Requires-Dist: sounddevice>=0.4
+Requires-Dist: numpy>=1.24
+Requires-Dist: faster-whisper>=1.0
 Provides-Extra: documents
 Requires-Dist: pymupdf4llm>=0.0.17; extra == "documents"
 Provides-Extra: graph
@@ -42,11 +45,8 @@ Provides-Extra: inprocess
 Requires-Dist: torch; extra == "inprocess"
 Requires-Dist: transformers; extra == "inprocess"
 Provides-Extra: voice
-Requires-Dist: sounddevice>=0.4; extra == "voice"
-Requires-Dist: numpy>=1.24; extra == "voice"
-Requires-Dist: faster-whisper>=1.0; extra == "voice"
 Provides-Extra: full
-Requires-Dist: pal-code[documents,voice]; extra == "full"
+Requires-Dist: pal-code[documents]; extra == "full"
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: ruff>=0.5; extra == "dev"

{pal_code-0.1.1 → pal_code-0.1.3}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pal-code"
-version = "0.1.1"
+version = "0.1.3"
 description = "Pal: build and plan with AI in your terminal (pal cli) or browser (pal web), on a layer that cuts tokens and latency."
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
-authors = [{ name = "Nandini Singh" }]
+authors = [{ name = "Vrushal More" }]
 keywords = ["ai", "coding-assistant", "cli", "llm", "ollama", "tokens", "code-graph"]
 classifiers = [
   "Development Status :: 4 - Beta",
@@ -32,6 +32,9 @@ dependencies = [
   "pypdf>=4.0",             # PDF -> markdown
   "python-pptx>=0.6.23",    # PowerPoint -> markdown
   "openpyxl>=3.1",          # Excel -> markdown
+  "sounddevice>=0.4",       # the mic: recording (PortAudio comes with it on Windows and macOS)
+  "numpy>=1.24",
+  "faster-whisper>=1.0",    # speech to text on this computer (Whisper); nothing leaves the computer
 ]
 
 [project.optional-dependencies]
@@ -42,8 +45,8 @@ litellm = []                     # kept so older install lines still work: litel
 vector = ["chromadb"]
 embeddings = ["sentence-transformers"]
 inprocess = ["torch", "transformers"]
-voice = ["sounddevice>=0.4", "numpy>=1.24", "faster-whisper>=1.0"]   # talk instead of typing (Ctrl+Space); speech-to-text on this computer
-full = ["pal-code[documents,voice]"]
+voice = []                       # kept so older install lines still work: the mic is installed by default now
+full = ["pal-code[documents]"]
 dev = ["pytest>=8", "ruff>=0.5", "mypy>=1.10", "types-requests", "types-PyYAML"]
 
 [project.scripts]

{pal_code-0.1.1 → pal_code-0.1.3}/src/pal/__init__.py

@@ -13,7 +13,7 @@ def _version() -> str:
             return version(name)
         except PackageNotFoundError:
             continue
-    return "0.1.1"           # a source checkout that is not installed
+    return "0.1.3"           # a source checkout that is not installed
 
 
 __version__ = _version()

{pal_code-0.1.1 → pal_code-0.1.3}/src/pal/cli.py

@@ -212,7 +212,8 @@ def load_dotenv(path: str | os.PathLike | None = None, env=None) -> list[str]:
     return loaded
 
 
-def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph=None, documents: list | None = None) -> int:
+def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph=None, documents: list | None = None, project_dir=None,
+           background=None) -> int:
     from pal.chat import ChatService
     from pal.web import create_app
 
@@ -221,7 +222,10 @@ def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph
     service = ChatService(settings, graph=graph) if graph is not None else ChatService(settings)
     if documents:
         service.preload_docs = list(documents)
-    app = create_app(service)
+    app = create_app(service, studio={"project_dir": project_dir}) if project_dir else create_app(service)
+    if background is not None:                                   # pal web: the folder's setup runs while the page is already usable
+        import threading as _bg
+        _bg.Thread(target=background, args=(service,), daemon=True, name="pal-web-setup").start()
     if s.host not in _LOOPBACK:
         print(f"WARNING: listening on {s.host}. Pal has no login: anyone who can reach this port can use "
               "your API keys' quota and read stored memory. Put it behind an authenticating reverse proxy.",
@@ -229,20 +233,21 @@ def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph
     shown = "localhost" if s.host in ("0.0.0.0", "::") else s.host  # noqa: S104
     url = f"http://{shown}:{s.port}" + ("/" + page.strip("/") if page else "")
     print(f"Pal {__version__} on {url}  (Ctrl+C to stop)")
-    from pal.chat.providers import API_PROVIDERS
-    keys = [p for p, var in API_PROVIDERS.items() if os.environ.get(var)]
-    print("API key found for: " + ", ".join(keys) if keys else
-          "No API key in the environment: paste one in the page (API key menu), or set e.g. GEMINI_API_KEY.")
-    status = service.local_status()
-    if status["ok"] is False:
-        print(f"WARNING: local model: {status['detail']}. Input reduction and local answers are off until it runs; "
-              "the app still works and sends everything to the API model.", file=sys.stderr)
-    else:
-        print(f"Local model: {status['detail']}")
+    if background is None:                                       # pal serve: say what is set up; pal web says nothing more and starts at once
+        from pal.chat.providers import API_PROVIDERS
+        keys = [p for p, var in API_PROVIDERS.items() if os.environ.get(var)]
+        print("API key found for: " + ", ".join(keys) if keys else
+              "No API key in the environment: paste one in the page (API key menu), or set e.g. GEMINI_API_KEY.")
+        status = service.local_status()
+        if status["ok"] is False:
+            print(f"WARNING: local model: {status['detail']}. Input reduction and local answers are off until it runs; "
+                  "the app still works and sends everything to the API model.", file=sys.stderr)
+        else:
+            print(f"Local model: {status['detail']}")
     if open_browser:
         import threading
         import webbrowser
-        threading.Timer(1.2, lambda: webbrowser.open(url)).start()
+        threading.Timer(0.3, lambda: webbrowser.open(url)).start()
     try:
         try:
             from waitress import serve

pal_code-0.1.3/src/pal/context_window.py

@@ -0,0 +1,42 @@
+"""How many tokens a model can take in one request (its context window), for the "tokens left" counters in the terminal and the web page.
+
+API models: the size LiteLLM knows for the model, else a safe default. Local models: the context Pal gives Ollama (num_ctx), which is what
+really limits them here, whatever the model could do on paper."""
+from __future__ import annotations
+
+from functools import lru_cache
+
+LOCAL_CONTEXT = 8192            # Pal runs local models with num_ctx 8192 (pal.terminal.backend.make_core)
+API_DEFAULT = 128_000           # a model LiteLLM does not know: most current API models take at least this
+LOCAL_PROVIDERS = ("local", "ollama", "lmstudio", "vllm", "llamacpp", "llama.cpp", "huggingface")
+
+
+@lru_cache(maxsize=256)
+def context_window(provider: str, model: str) -> int:
+    provider = (provider or "").lower()
+    if provider in LOCAL_PROVIDERS:
+        return LOCAL_CONTEXT
+    if not model:
+        return API_DEFAULT
+    try:
+        import litellm
+        for name in (f"{provider}/{model}" if provider else model, model, model.split("/")[-1]):
+            try:
+                info = litellm.get_model_info(name)
+            except Exception:  # noqa: BLE001  (not in LiteLLM's table under this name)
+                continue
+            size = info.get("max_input_tokens") or info.get("max_tokens")
+            if size:
+                return int(size)
+    except Exception:  # noqa: BLE001  (LiteLLM missing or broken: the default)
+        pass
+    return API_DEFAULT
+
+
+def tokens_left(window: int, last_prompt: int) -> int:
+    """What is left of the window after the last request's input (the next one is usually at least as big)."""
+    return max(0, window - max(0, last_prompt))
+
+
+def short(n: int) -> str:
+    return f"{n / 1000:.1f}k".replace(".0k", "k") if n >= 10_000 else f"{n:,}"

pal_code-0.1.3/src/pal/llm_wrapper/__init__.py

@@ -0,0 +1,34 @@
+"""The model layer. Its names are loaded on first use (PEP 562), so importing a light submodule such as pal.llm_wrapper.modes (the provider
+names and key variables) does not load the whole model stack: pal cli draws its first screen before any of it is needed."""
+from importlib import import_module
+
+_WHERE = {
+    "LLMAdapter": "pal.llm_wrapper.adapter",
+    "LLMAdapterResponse": "pal.llm_wrapper.components.adapter_types",
+    "LLMAdapterSyscall": "pal.llm_wrapper.components.adapter_types",
+    "LLMConfig": "pal.llm_wrapper.components.adapter_types",
+    "RouterStrategy": "pal.llm_wrapper.components.adapter_types",
+    "DeploymentType": "pal.llm_wrapper.components.base",
+    "LLMResponse": "pal.llm_wrapper.components.base",
+    "LLMSyscall": "pal.llm_wrapper.components.base",
+    "LLMWrapper": "pal.llm_wrapper.components.base",
+    "WrapperCapabilities": "pal.llm_wrapper.components.base",
+    "WrapperConfig": "pal.llm_wrapper.components.base",
+    "LLMWrapperPipeline": "pal.llm_wrapper.pipeline",
+    "available_backends": "pal.llm_wrapper.utils.registry",
+    "build_wrapper": "pal.llm_wrapper.utils.registry",
+}
+
+__all__ = list(_WHERE)
+
+
+def __getattr__(name: str):
+    if name in _WHERE:
+        value = getattr(import_module(_WHERE[name]), name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module 'pal.llm_wrapper' has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(set(globals()) | set(_WHERE))

{pal_code-0.1.1 → pal_code-0.1.3}/src/pal/studio/routes.py

@@ -49,7 +49,7 @@ def clean_references(raw) -> list[dict]:
 
 
 def register_studio(app, service, *, planner_core: Callable | None = None, core_factory: Callable | None = None, discover_fn: Callable | None = None,
-                    hot_turns: int | None = None) -> RunStore:
+                    hot_turns: int | None = None, project_dir: Path | None = None) -> RunStore:
     """Add the Studio page and endpoints to the app. The three callables are for tests: the planner's model, the builder's model, local-model discovery."""
     cfg = service.settings
     home = Path(cfg.storage_dir).expanduser() if cfg.storage_dir else data_dir()
@@ -71,7 +71,7 @@ def register_studio(app, service, *, planner_core: Callable | None = None, core_
             raise UserInputError("no local model is chosen: start Ollama and pull a model, or switch to an API model")
         return local_core(m["model"], num_ctx())
 
-    runs = RunStore(home / "studio", core_factory or default_core_factory, max_runs=cfg.studio.max_runs, hot_turns=hot_turns)
+    runs = RunStore(home / "studio", core_factory or default_core_factory, max_runs=cfg.studio.max_runs, hot_turns=hot_turns, project_dir=project_dir)
     app.extensions["studio_runs"] = runs
 
     def local() -> dict:

{pal_code-0.1.1 → pal_code-0.1.3}/src/pal/studio/runs.py

@@ -95,9 +95,22 @@ class Run:
         return self.arms[name]
 
 
+def build_target(project: Path, folder: str) -> Path:
+    """Where a build is written in the folder Pal was started in: the folder itself when it is empty, else a new subfolder named after the
+    product (with -2, -3 ... when that name is taken), so nothing that is already there is overwritten."""
+    project = Path(project)
+    if not any(p for p in project.iterdir() if not p.name.startswith(".")):
+        return project
+    target, n = project / folder, 2
+    while target.exists() and (not target.is_dir() or any(target.iterdir())):
+        target, n = project / f"{folder}-{n}", n + 1
+    return target
+
+
 class RunStore:
-    def __init__(self, root: Path, core_factory: Callable, max_runs: int = 6, hot_turns: int | None = None):
+    def __init__(self, root: Path, core_factory: Callable, max_runs: int = 6, hot_turns: int | None = None, project_dir: Path | None = None):
         self.root, self.core_factory, self.max_runs, self.hot_turns = Path(root), core_factory, max_runs, hot_turns
+        self.project_dir = Path(project_dir).resolve() if project_dir else None      # pal web's folder: the build is written there
         self._runs: dict[str, Run] = {}
         self._editors: dict[tuple[str, str], EditorSession] = {}
         self._lock = threading.Lock()
@@ -140,11 +153,17 @@ class RunStore:
                     break
                 policy = Policy(dict(plan["permissions"]))
                 save = plan["permissions"].get("write_project")
-                state = ArmState(arm, label, (self.root / run.id / arm / plan["product"]["folder"]) if save else None)
+                where = None
+                if save:
+                    where = (build_target(self.project_dir, plan["product"]["folder"]) if self.project_dir and arm != "baseline"
+                             else self.root / run.id / arm / plan["product"]["folder"])  # the plain client's comparison copy stays in Pal's folder
+                state = ArmState(arm, label, where)
                 run.arms[arm] = state
                 if state.workspace:
                     state.workspace.mkdir(parents=True, exist_ok=True)
                 run.emit("arm_start", f"{label}: starting" if twice else "Starting", arm=arm)
+                if state.workspace and self.project_dir and arm != "baseline":
+                    run.emit("saved_to", f"Files are written to {state.workspace}", arm=arm, path=str(state.workspace))
                 client: PlainClient | PalClient
                 if arm == "baseline":
                     client = PlainClient(core, SYSTEM)

{pal_code-0.1.1 → pal_code-0.1.3}/src/pal/terminal/bench.py

@@ -67,6 +67,7 @@ class BenchResult:
     plain: Arm
     pal: Arm
     when: float = field(default_factory=time.time)
+    pal_files: dict = field(default_factory=dict, repr=False)     # what Pal's way wrote: {path: bytes}, offered to keep in your folder
 
     @property
     def saved(self) -> int:
@@ -78,6 +79,7 @@ class BenchResult:
 
     def to_dict(self) -> dict:
         d = asdict(self)
+        d.pop("pal_files", None)
         d.update(saved=self.saved, saved_pct=self.saved_pct, plain_total=self.plain.total, pal_total=self.pal.total)
         return d
 
@@ -161,7 +163,12 @@ def run_bench(folder: Path, task: str, core_factory: Callable[[], Any], model: s
             pal_arm = _run_arm("pal", pal, steps, progress)
         finally:
             client.close()
-    result = BenchResult(task, model, str(folder), plain_arm, pal_arm)
+        kept = {}
+        for rel in sorted({f for st in pal_arm.steps for f in st.files}):
+            f = pal_dir / rel
+            if f.is_file():
+                kept[rel] = f.read_bytes()
+    result = BenchResult(task, model, str(folder), plain_arm, pal_arm, pal_files=kept)
     save(result, home)
     return result