polyglav 0.37.0__py3-none-any.whl

polyglav/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import version, PackageNotFoundError
+
+
+def get_version() -> str:
+    try:
+        return version('polyglav')
+    except PackageNotFoundError:
+        return 'unknown'

polyglav/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .main import main
+
+sys.exit(main())

polyglav/asks.py

@@ -0,0 +1,141 @@
+import json
+import threading
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+class Ask:
+    def __init__(self, id: int, question: str, origin: str,
+                 context: str = '', options: list | None = None,
+                 kind: str = 'direction', permission: str = '',
+                 status: str = 'pending', answer: str = '',
+                 created_at: str | None = None,
+                 answered_at: str | None = None):
+        now = datetime.now(timezone.utc).isoformat(timespec='seconds')
+        self.id = id
+        self.question = question
+        self.origin = origin
+        self.context = context
+        self.options = options or []
+        self.kind = kind
+        self.permission = permission
+        self.status = status
+        self.answer = answer
+        self.created_at = created_at or now
+        self.answered_at = answered_at or ''
+
+    def to_dict(self) -> dict:
+        return {
+            'id': self.id,
+            'question': self.question,
+            'origin': self.origin,
+            'context': self.context,
+            'options': self.options,
+            'kind': self.kind,
+            'permission': self.permission,
+            'status': self.status,
+            'answer': self.answer,
+            'created_at': self.created_at,
+            'answered_at': self.answered_at,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Ask':
+        return cls(
+            int(data['id']),
+            data.get('question', ''),
+            data.get('origin', ''),
+            data.get('context', ''),
+            data.get('options', []),
+            data.get('kind', 'direction'),
+            data.get('permission', ''),
+            data.get('status', 'pending'),
+            data.get('answer', ''),
+            data.get('created_at'),
+            data.get('answered_at'),
+        )
+
+
+class AskStore:
+    def __init__(self, path: Path):
+        self.path = path
+        self._lock = threading.Lock()
+
+    def _read(self) -> list[dict]:
+        if not self.path.exists():
+            return []
+        with open(self.path) as f:
+            data = json.load(f)
+        if not isinstance(data, list):
+            return []
+        return [d for d in data if isinstance(d, dict)]
+
+    def _write(self, asks: list[dict]):
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self.path.with_suffix('.json.tmp')
+        with open(tmp, 'w') as f:
+            json.dump(asks, f, indent=2)
+        tmp.replace(self.path)
+
+    def add(self, question: str, origin: str, context: str = '',
+            options: list | None = None, kind: str = 'direction',
+            permission: str = '') -> Ask:
+        with self._lock:
+            asks = self._read()
+            next_id = max((int(a.get('id', 0)) for a in asks), default=0) + 1
+            ask = Ask(next_id, question, origin, context, options,
+                      kind, permission)
+            asks.append(ask.to_dict())
+            self._write(asks)
+        return ask
+
+    def find(self, id: int) -> Ask | None:
+        asks = self._read()
+        for a in asks:
+            if int(a.get('id', -1)) == int(id):
+                return Ask.from_dict(a)
+        return None
+
+    def list(self, status: str | None = None) -> list[Ask]:
+        asks = [Ask.from_dict(a) for a in self._read()]
+        if status is not None:
+            asks = [a for a in asks if a.status == status]
+        return sorted(asks, key=lambda a: a.id)
+
+    def answer(self, id: int, text: str) -> Ask | None:
+        text = text.strip()
+        if not text:
+            return None
+        with self._lock:
+            asks = self._read()
+            target = None
+            for a in asks:
+                if int(a.get('id', -1)) == int(id):
+                    target = a
+                    break
+            if target is None:
+                return None
+            now = datetime.now(timezone.utc).isoformat(timespec='seconds')
+            target['status'] = 'answered'
+            target['answer'] = text
+            target['answered_at'] = now
+            self._write(asks)
+        return Ask.from_dict(target)
+
+
+def inject_answer(store: AskStore, ask: Ask):
+    latest = store.find(ask.id)
+    if latest is None:
+        return False
+    sessions_dir = store.path.parent / 'sessions'
+    from .sessions.manager import SessionManager
+    manager = SessionManager(sessions_dir)
+    session = manager.read(latest.origin)
+    if session is None:
+        return False
+    session.add_user(
+        f'[answer to parked ask #{latest.id}] {latest.answer}')
+    manager.save(session)
+    return True

polyglav/bundled_roles.json

@@ -0,0 +1,127 @@
+{
+  "assistant": {
+    "tags": ["management"],
+    "system_prompt": "You are the assistant, the operator's single point of contact. Answer small questions and quick tasks directly in this run. For work bigger than one step - building something, research and writing, a multi-part change - do not do it all yourself: delegate. Use the composer to design a team for the task (it creates the specialist types, skills, and stages), then run that team with the team tool. Use the leader type to supervise several pieces or a long job. Inspect what already exists with the catalog tool before composing. Keep the operator informed with short status updates, ask only when a decision is genuinely unclear, and finish with a concise summary of what was done and what needs attention."
+  },
+  "composer": {
+    "tags": ["management"],
+    "system_prompt": "You are the composer. Given a task, design a complete team and persist it with the catalog tool - never run the team yourself. Read the task and the existing catalog, decide the stages and the specialist roles each stage needs, create any missing roles and skills, then save the team with the right stage order, task hints, per-stage skills, and a review loop when the work needs checking. Use ask to resolve details the task leaves open. Report the team name, its stages, and the skills each member carries, so the caller can run it.",
+    "tool_permission": {
+      "bash": "deny",
+      "catalog": "allow",
+      "edit": "deny",
+      "list": "allow",
+      "read": "allow",
+      "team": "deny",
+      "web": "allow"
+    },
+    "ask_policy": {
+      "permission": "auto",
+      "direction": "human"
+    }
+  },
+  "leader": {
+    "tags": ["research", "writing", "programming", "review"],
+    "system_prompt": "You are the leader, a supervisor that coordinates delegated agents rather than doing the work itself. Plan the task, run the named team or delegate to the right roles, and park any question you cannot decide for the operator with ask. Finish each run with a short summary of what was done and what needs attention.",
+    "tool_permission": {
+      "ask": "allow",
+      "bash": "deny",
+      "edit": "allow",
+      "list": "allow",
+      "read": "allow",
+      "web": "deny"
+    },
+    "grant_permission": {
+      "ask": "allow",
+      "bash": "allow",
+      "edit": "allow",
+      "list": "allow",
+      "read": "allow",
+      "web": "allow"
+    },
+    "ask_policy": {
+      "permission": "auto",
+      "direction": "human"
+    }
+  },
+  "researcher": {
+    "tags": ["research", "writing"],
+    "system_prompt": "You are the researcher. Your job is to gather reliable information, not to write prose. Use web_search and fetch_page to find and evaluate sources, against the task you were given. Filter for credible, on-topic sources, note conflicts and gaps, and answer with a structured findings list: for each finding include the claim, the source URL, and a one-line assessment of its reliability. Do not draft final text, reference lists, or file writes.",
+    "tool_permission": {
+      "bash": "deny",
+      "edit": "deny",
+      "read": "allow",
+      "web": "allow"
+    }
+  },
+  "writer": {
+    "tags": ["writing"],
+    "system_prompt": "You are the writer. Take the findings you were given and write the requested document. Follow the brief closely: match the requested structure, tone, and length, and use the findings as the factual basis without inventing new claims. Write the result with write_file and report the resolved path as your answer. Do not go back to research; if something is missing, say so explicitly in your answer.",
+    "tool_permission": {
+      "bash": "deny",
+      "edit": "allow",
+      "read": "allow",
+      "web": "deny"
+    }
+  },
+  "referencer": {
+    "tags": ["writing"],
+    "system_prompt": "You are the referencer. Read the document you were given, find every citation and quoted or paraphrased source, resolve each to a stable reference, and produce a .bib file with write_file. Group entries consistently, include the URL and access date, and report the resolved .bib path. If a reference cannot be resolved, list it as unresolved rather than inventing it.",
+    "tool_permission": {
+      "bash": "deny",
+      "edit": "allow",
+      "read": "allow",
+      "web": "deny"
+    }
+  },
+  "editor": {
+    "tags": ["writing", "review"],
+    "system_prompt": "You are the editor. Review the document against the original task and the referenced sources it relies on. Check structure, factual consistency with the sources, and whether the document actually answers the prompt. Return findings as a list: each item is a severity (blocker, warning, note), the location, and the fix. Do not modify the document itself.",
+    "tool_permission": {
+      "bash": "deny",
+      "edit": "deny",
+      "read": "allow",
+      "web": "deny"
+    }
+  },
+  "planner": {
+    "tags": ["programming"],
+    "system_prompt": "You are the planner. Decompose the task into concrete, ordered steps without touching files. For a programming task name the modules or files likely involved and what change each needs; for a writing task outline the sections and their sources. Keep the plan implementable by another agent: each step says what, where, and how to verify. Return only the plan.",
+    "tool_permission": {
+      "bash": "deny",
+      "edit": "deny",
+      "read": "allow",
+      "web": "allow"
+    }
+  },
+  "programmer": {
+    "tags": ["programming"],
+    "system_prompt": "You are the programmer. Implement the requested change in the codebase: read the relevant files, write the code, and run the tests with run_command until they pass. Follow the project's existing conventions and keep changes minimal. Report what you changed, the test command, and its result.",
+    "tool_permission": {
+      "bash": "allow",
+      "edit": "allow",
+      "read": "allow",
+      "web": "deny"
+    }
+  },
+  "tester": {
+    "tags": ["programming"],
+    "system_prompt": "You are the tester. Write tests that cover the behavior you were asked to verify, run them with run_command, and report the outcome. For each failure include the failing assertion, the input that triggered it, and a short diagnosis. If a test is skipped or unreliable, mark it as such instead of removing it silently.",
+    "tool_permission": {
+      "bash": "allow",
+      "edit": "allow",
+      "read": "allow",
+      "web": "deny"
+    }
+  },
+  "code-reviewer": {
+    "tags": ["programming", "review"],
+    "system_prompt": "You are the code-reviewer. Review the change against the requirements you were given. Read the diff and the surrounding code, run the relevant checks only if they are quick, and return findings. Each finding has a severity (blocker, warning, nit), the file and line, and the suggested fix. Do not edit the code.",
+    "tool_permission": {
+      "bash": "allow",
+      "edit": "deny",
+      "read": "allow",
+      "web": "deny"
+    }
+  }
+}

polyglav/bundled_teams.json

@@ -0,0 +1,54 @@
+{
+  "writing": {
+    "description": "Document pipeline: research, write, reference, edit",
+    "tags": ["research", "writing"],
+    "stages": [
+      {
+        "role": "researcher",
+        "task_hint": "Gather and evaluate sources on the topic and return a structured findings list.",
+        "handoff_note": "Hand the findings list to the writer as the factual basis."
+      },
+      {
+        "role": "writer",
+        "task_hint": "Write the requested document from the findings list, matching the brief's structure, tone, and length.",
+        "handoff_note": "Hand the written document path to the referencer."
+      },
+      {
+        "role": "referencer",
+        "task_hint": "Read the written document, resolve its citations and sources into a .bib file.",
+        "handoff_note": "Hand the document and .bib paths to the editor."
+      },
+      {
+        "role": "editor",
+        "task_hint": "Review the document against the original task and the sources, returning a findings list.",
+        "handoff_note": "Return the review findings as the final answer."
+      }
+    ]
+  },
+  "programming": {
+    "description": "Programming pipeline: plan, implement, test, review",
+    "tags": ["programming"],
+    "stages": [
+      {
+        "role": "planner",
+        "task_hint": "Decompose the task into concrete, ordered steps with the modules or files involved and how to verify each step.",
+        "handoff_note": "Hand the plan to the programmer."
+      },
+      {
+        "role": "programmer",
+        "task_hint": "Implement the plan, run the relevant checks, and report the changed files.",
+        "handoff_note": "Hand the changed files and implementation summary to the tester."
+      },
+      {
+        "role": "tester",
+        "task_hint": "Write tests covering the behavior to verify, run them, and report the outcome.",
+        "handoff_note": "Hand the test results and failure diagnoses to the code-reviewer."
+      },
+      {
+        "role": "code-reviewer",
+        "task_hint": "Review the implementation and tests against the plan, returning a findings list.",
+        "handoff_note": "Return the review findings as the final answer."
+      }
+    ]
+  }
+}

polyglav/chat.py

@@ -0,0 +1,332 @@
+import sys
+import readline
+from pathlib import Path
+
+from .config import Config
+from .engine import Engine
+from .focus import FocusManager
+from .ui import ReplUI
+from . import get_version
+
+HISTFILE = '.polyglav_history'
+
+MAIN_PROMPT = '\001\033[1;36m\002>>>\001\033[0m\002 '
+CONT_PROMPT = '\001\033[1;36m\002...\001\033[0m\002 '
+
+
+def _open_delim(text: str) -> str | None:
+    if _overlap_count(text, '"""') % 2 == 1:
+        return '"""'
+    if _overlap_count(text, "'''") % 2 == 1:
+        return "'''"
+    return None
+
+
+def _overlap_count(text: str, delim: str) -> int:
+    n = 0
+    i = text.find(delim)
+    while i != -1:
+        n += 1
+        i = text.find(delim, i + 1)
+    return n
+
+
+def _strip_framing(text: str, delim: str) -> str:
+    first = text.find(delim)
+    last = text.rfind(delim)
+    if first == -1 or last <= first:
+        return text
+    return (text[:first] + text[first + len(delim):last]
+            + text[last + len(delim):]).strip('\n')
+
+
+def _strip_open(text: str, delim: str) -> str:
+    idx = text.find(delim)
+    if idx == -1:
+        return text
+    return (text[:idx] + text[idx + len(delim):]).strip('\n')
+
+
+class ChatLoop(Engine):
+    def __init__(self, config: Config):
+        ui = ReplUI(self)
+        super().__init__(config, ui=ui)
+        self._bind_assistant()
+        self.focus = FocusManager(self)
+        self._load_history(config)
+        self._setup_readline()
+
+    def active(self) -> Engine:
+        focus = getattr(self, 'focus', None)
+        if focus is None:
+            return self
+        return focus.active
+
+    def _bind_assistant(self):
+        if not self.config.get('assistant', True):
+            return
+        name = str(self.config.get('assistant_role') or '').strip()
+        if name:
+            self.bind_root_agent(name)
+
+    def _load_history(self, config):
+        hist = config.local_path.parent / HISTFILE
+        if hist.exists():
+            try:
+                readline.read_history_file(str(hist))
+            except OSError:
+                pass
+        readline.set_history_length(1000)
+
+    def _save_history(self):
+        hist = self.config.local_path.parent / HISTFILE
+        try:
+            hist.parent.mkdir(parents=True, exist_ok=True)
+            readline.write_history_file(str(hist))
+        except OSError:
+            pass
+
+    def _setup_readline(self):
+        readline.set_completer(self._completer)
+        readline.set_completer_delims(' \t\n')
+        if 'libedit' in (readline.__doc__ or ''):
+            readline.parse_and_bind('bind ^I rl_complete')
+        else:
+            readline.parse_and_bind('tab: complete')
+
+    def _completer(self, text: str, state: int) -> str | None:
+        line = readline.get_line_buffer()
+        head = line[: len(line) - len(text)]
+        for prefix in ('/session load ', '/sessions preview ', '/sessions delete ', '/sessions export '):
+            if head.endswith(prefix):
+                names = [n for n in self.sessions.list() if n.startswith(text)]
+                if state < len(names):
+                    return names[state] + ' '
+                return None
+        for prefix in ('/plugins enable ', '/plugins disable ',
+                       '/plugins update ', '/plugins uninstall '):
+            if head.endswith(prefix):
+                pm = getattr(self, '_plugin_manager', None)
+                names = [i.name for i in pm.status()] if pm else []
+                options = sorted(n for n in names if n.startswith(text))
+                if state < len(options):
+                    return options[state] + ' '
+                return None
+        if head.endswith('/tool '):
+            options = sorted(n for n in self._tool_names() if n.startswith(text))
+            if state < len(options):
+                return options[state] + ' '
+            return None
+        if head.endswith('/mode '):
+            from .modes import mode_list
+            options = sorted(m.name for m in mode_list(self.config)
+                             if m.name.startswith(text))
+            if state < len(options):
+                return options[state] + ' '
+            return None
+        if head.lstrip().startswith('/'):
+            cmd = head.lstrip()[1:].strip().split(maxsplit=1)[0]
+            meta = self.registry.meta.get(cmd)
+            if meta and meta.get('subcommands'):
+                options = sorted(n for n, _ in meta['subcommands']
+                                 if n.startswith(text))
+                if state < len(options):
+                    return options[state] + ' '
+                return None
+            return self._path_complete(text, state)
+        if text.startswith('/'):
+            term = text[1:]
+            options = sorted(c for c in self.registry.commands if c.startswith(term))
+            if state < len(options):
+                return '/' + options[state] + ' '
+            return None
+        return None
+
+    def _tool_names(self):
+        if not getattr(self, '_tool_registry', None):
+            return []
+        policy = getattr(self, '_tool_policy', None)
+        names = self._tool_registry.names()
+        if policy is None:
+            return names
+        return [n for n in names
+                if policy.allowed(n, self._tool_registry.permission_for(n))]
+
+    def _path_complete(self, text: str, state: int) -> str | None:
+        path = Path(text) if text else Path('.')
+        name = path.name
+        parent = path.parent if str(path.parent) else Path('.')
+        try:
+            options = sorted(p for p in parent.glob(name + '*'))
+        except OSError:
+            options = []
+        if state < len(options):
+            cand = options[state]
+            return str(cand) + ('/' if cand.is_dir() else ' ')
+        return None
+
+    def _read_line(self) -> str | None:
+        try:
+            line = input(self._prompt()).strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return None
+        delim = _open_delim(line)
+        if delim is not None:
+            return self._read_block(line, delim)
+        if line.endswith('\\'):
+            return self._read_continued(line)
+        return line
+
+    def _read_block(self, line: str, delim: str) -> str | None:
+        parts = [line]
+        while True:
+            try:
+                nxt = input(CONT_PROMPT).rstrip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                return None
+            parts.append(nxt)
+            stripped = nxt.strip()
+            if stripped == delim:
+                composed = _strip_framing('\n'.join(parts), delim)
+                self._remember(composed)
+                return composed
+            if stripped == '':
+                composed = _strip_open('\n'.join(parts), delim)
+                self._remember(composed)
+                return composed
+
+    def _read_continued(self, line: str) -> str | None:
+        parts = [line[:-1].rstrip()]
+        while True:
+            try:
+                nxt = input(CONT_PROMPT).rstrip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                return None
+            if nxt.endswith('\\'):
+                parts.append(nxt[:-1].rstrip())
+                continue
+            parts.append(nxt)
+            composed = '\n'.join(parts)
+            self._remember(composed)
+            return composed
+
+    def _remember(self, text: str):
+        try:
+            readline.add_history(text)
+        except Exception:
+            pass
+
+    def _prompt(self) -> str:
+        role = ''
+        if self.config.get('prompt_role', False):
+            role = str(getattr(self.active(), 'role', '') or '')
+        if not role:
+            return MAIN_PROMPT
+        label = role[:1].upper() + role[1:]
+        return f'\001\033[1;36m\002{label} >>>\001\033[0m\002 '
+
+    def _open_output_log(self):
+        if not self.config.get('output_log', False):
+            return None
+        from .ui import TeeStream
+        worktree = self.config.local_path.parent.parent
+        base = Path(str(self.config.get('output_log_dir', '.polyglav/output')
+                         or '.polyglav/output'))
+        if not base.is_absolute():
+            base = worktree / base
+        try:
+            base.mkdir(parents=True, exist_ok=True)
+            name = self.current_session.session_name or 'output'
+            path = base / f'{name}.txt'
+            stream = TeeStream(sys.stdout, path)
+            stream.write(f'# Polyglav output log - {path.name}\n')
+            return stream
+        except OSError:
+            return None
+
+    def run(self):
+        tee = self._open_output_log()
+        if tee is not None:
+            sys.stdout = tee
+        try:
+            self._run_repl()
+        finally:
+            if tee is not None:
+                sys.stdout = tee._stream
+                tee.close()
+
+    def _run_repl(self):
+        if self.config.get('clear_screen', True):
+            sys.stdout.write('\033[3J\033[2J\033[H')
+            sys.stdout.flush()
+
+        model_str = self.config.get('model', '?')
+        provider_str = self.config.get('provider', '?')
+        mode_str = self.config.get('mode', 'build')
+        suffix = f'  [{mode_str} mode]' if mode_str != 'build' else ''
+        if self.config.get('show_version', True):
+            print(f'Polyglav v{get_version()} ({provider_str}: {model_str}){suffix}  /help for commands')
+        else:
+            print(f'Polyglav ({provider_str}: {model_str}){suffix}  /help for commands')
+
+        while True:
+            line = self._read_line()
+            if line is None:
+                self._save_sessions()
+                self._save_history()
+                break
+
+            if not line:
+                continue
+
+            engine = self.active()
+            try:
+                if line.startswith('/'):
+                    engine.current_session.add_command(line)
+                    engine.registry.dispatch(line)
+                    engine.session_auto_save()
+                else:
+                    engine.chat(line)
+            except Exception as e:
+                engine.current_session.add_error(0, str(e))
+                print(f'\001\033[91m\002[Error]\001\033[0m\002 {e}')
+
+            self._apply_handoff()
+
+        self._save_history()
+
+    def _apply_handoff(self):
+        pending = (getattr(self, '_pending_handoff', None)
+                   or getattr(self, '_pending_focus', None))
+        if not pending:
+            return
+        self._pending_handoff = None
+        self._pending_focus = None
+        focus = getattr(self, 'focus', None)
+        if focus is None:
+            return
+        run_id = pending.get('run')
+        session_name = pending.get('session')
+        try:
+            if run_id is not None:
+                engine = focus.enter(run_id)
+            elif session_name:
+                engine = focus.focus_session(session_name)
+            else:
+                return
+        except ValueError as e:
+            print(f'\001\033[91m\002[Cannot focus]\001\033[0m\002 {e}')
+            return
+        run = getattr(engine, 'current_run', None)
+        prefix = f'#{run.id} ' if run is not None else ''
+        label = f'{prefix}{engine.role or "root"} ({engine.current_session.session_name})'
+        print(f'Focused: {label}')
+
+    def _save_sessions(self):
+        focus = getattr(self, 'focus', None)
+        engines = focus.engines() if focus is not None else [self]
+        for engine in engines:
+            engine.session_auto_save()