pcode 0.1.6__tar.gz → 0.1.7__tar.gz

{pcode-0.1.6 → pcode-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pcode
-Version: 0.1.6
+Version: 0.1.7
 Summary: Terminal-native AI coding agent with background jobs, parallel worktrees, forkable sessions, and multi-model support
 Project-URL: Homepage, https://github.com/cruxwell/pcode
 Project-URL: Documentation, https://cruxwell.github.io/pcode/

{pcode-0.1.6 → pcode-0.1.7}/src/pcode/app.py

@@ -1227,14 +1227,24 @@ class PreviewApp:
         self.transcript.syntax_gallery()
 
     def theme(self, argument: str) -> None:
-        self.transcript.theme = argument or (
-            "light" if self.transcript.resolved_theme == "dark" else "dark"
-        )
-        self.persist_defaults(theme=self.transcript.theme)
-        selected = self.transcript.theme
-        if selected == "auto":
-            selected += f" ({self.transcript.resolved_theme})"
-        self.transcript.flash(f"Theme: {selected}.")
+        """Pick and save a palette; bare `/theme` flips it for this session only.
+
+        Saving the flip would pin every later session to it, and with it turn
+        off following the terminal's light/dark switches.
+        """
+        theme = argument or ("light" if self.transcript.resolved_theme == "dark" else "dark")
+        self.transcript.theme = theme
+        if not argument:
+            message = f"{theme} for this session; /theme {theme} saves it"
+        else:
+            self.persist_defaults(theme=theme)
+            message = theme
+        if theme == "auto":
+            message += f" ({self.transcript.resolved_theme})"
+            if self._appearance is not None:
+                # The detected value may be stale; the answer repaints if it differs.
+                self._appearance.refresh()
+        self.transcript.flash(f"Theme: {message}.")
         self.transcript.regenerate()
 
     def follow_appearance(self, detected: str) -> None:
@@ -2709,6 +2719,9 @@ def main() -> None:
         "hosts",
     )
     parser.add_argument("--hosts", action="store_true", help="List running session hosts and exit")
+    parser.add_argument(
+        "--json", action="store_true", help="With --hosts: one JSON array, for scripts and plugins"
+    )
     host_kinds = ("all", "stale", "idle")
     parser.add_argument(
         "--kill-hosts",
@@ -3179,6 +3192,8 @@ def _run_cli(args: argparse.Namespace, parser: argparse.ArgumentParser) -> None:
         parser.error("--fork cannot be combined with --attach")
     if args.compact and not args.sessions:
         parser.error("--compact applies to --sessions")
+    if args.json and not args.hosts:
+        parser.error("--json applies to --hosts")
     if args.print:
         if args.theme_preview or args.sessions:
             parser.error("--print cannot be combined with --theme-preview or --sessions")
@@ -3225,6 +3240,13 @@ def _run_cli(args: argparse.Namespace, parser: argparse.ArgumentParser) -> None:
         if args.kill_hosts:
             _kill_hosts(args.kill_hosts, entries, code)
             return
+        if args.json:
+            import json
+
+            # A contract for callers such as the Obsidian bridge: add keys, never rename.
+            keys = ("id", "session_id", "state", "workspace", "title", "last_prompt", "attached")
+            print(json.dumps([{key: getattr(entry, key) for key in keys} for entry in entries]))
+            return
         for entry in entries:
             print(f"{entry.id}  {host_row(entry, None, code=code).strip()}")
         if not entries:

{pcode-0.1.6 → pcode-0.1.7}/src/pcode/appearance.py

@@ -144,6 +144,13 @@ class AppearanceWatch:
             self.suspended = False
             if enabled:
                 self.enabled = _write_all(self.fd, ENABLE_REPORTS)
+                # A switch while the other program had the terminal went unseen.
+                self.refresh()
+
+    def refresh(self) -> None:
+        """Ask for the background now; the answer arrives as input like any other."""
+        if self.enabled and not self.suspended:
+            _write_all(self.fd, QUERY_BACKGROUND)
 
     async def query(self) -> None:
         for delay in QUERY_DELAYS:
@@ -155,6 +162,9 @@ class AppearanceWatch:
         if self.fd is None or not _isatty(self.fd) or os.environ.get("TERM") == "dumb":
             return
         self.enabled = _write_all(self.fd, ENABLE_REPORTS)
+        # The startup probe is skipped when input is already waiting, leaving a
+        # guess from COLORFGBG that only a later switch would otherwise correct.
+        self.refresh()
         reader = self.reader if self.reader is not None else desktop_reader()
         pending = None
         try:

{pcode-0.1.6 → pcode-0.1.7}/src/pcode/extensions/basic_memory/Brief format.md

@@ -52,6 +52,8 @@ A **brief** explains one project as it is now: what it is, where it's at, how it
 | `plans` | links to open plans | | |
 | `sources` | session IDs, plus code paths or commit ranges | same | |
 
+Properties are YAML, and one bad value breaks the whole block: Obsidian then shows it as raw red text instead of properties. Wrap every free-text value (`scope`, `tldr`, `next` and each `sources` item) in single quotes, doubling any `'` inside: `tldr: 'Checks the org''s code: once per ticket'`. Unquoted, a `: ` anywhere or a leading `` ` ``, `#`, `*`, `[`, `{`, `&`, `!`, `|`, `>`, `%` or `@` breaks it.
+
 ## Sections
 
 | Section | Answers | Budget |

{pcode-0.1.6 → pcode-0.1.7}/src/pcode/extensions/basic_memory/__init__.py

@@ -6,7 +6,7 @@ config directory, which is never in a repository, so org names stay local.
 
 A **brief** explains a project as it is: what it is, where it's at, how it
 works, what's wrong, what's next. A **plan** is a proposed brief in the same
-format; with this extension on, `/plan` writes it into the vault. How both
+format; `/plan --obsidian` writes it into the vault. How both
 are written lives in the vault's `Brief format.md`, which the model reads
 before writing, so the user can change the format without touching code.
 
@@ -23,9 +23,7 @@ tools. What this module adds is only:
   Obsidian reach the model without being retyped.
 
 Known limits: an edit the user makes mid-turn to a note the model then edits
-again is folded into the model's edit and not reported; and `plan_location`
-trusts the extensions_on preference, so a user file that overrides this
-extension still gets vault plans from this module.
+again is folded into the model's edit and not reported.
 """
 
 import asyncio
@@ -34,6 +32,7 @@ import json
 import re
 import shlex
 import shutil
+import tempfile
 import tomllib
 from dataclasses import dataclass
 from pathlib import Path
@@ -120,11 +119,22 @@ def load_orgs(path: Path | None = None) -> list[Org]:
     except (OSError, tomllib.TOMLDecodeError) as error:
         raise ValueError(f"{path}: {error}") from None
     default_sync = bool(data.get("auto_sync", False))
-    vault_root = Path(str(data.get("vault_root", DEFAULT_VAULT_ROOT))).expanduser()
+    root_value = data.get("vault_root", DEFAULT_VAULT_ROOT)
+    if not isinstance(root_value, str) or not root_value.strip():
+        raise ValueError(f"{path}: vault_root must be a nonempty path string")
+    vault_root = Path(root_value).expanduser()
+    entries = data.get("org", [])
+    if not isinstance(entries, list):
+        raise ValueError(f"{path}: org must be an array of [[org]] tables")
     orgs = []
-    for entry in data.get("org", []):
-        if not isinstance(entry, dict) or not entry.get("name") or not entry.get("root"):
+    for entry in entries:
+        if not isinstance(entry, dict) or any(
+            not isinstance(entry.get(key), str) or not entry[key].strip()
+            for key in ("name", "root")
+        ):
             raise ValueError(f"{path}: every [[org]] needs a name and a root")
+        if "vault" in entry and (not isinstance(entry["vault"], str) or not entry["vault"].strip()):
+            raise ValueError(f"{path}: vault must be a nonempty path string")
         name = str(entry["name"])
         if safe_name(name) != name:
             raise ValueError(f"{path}: org name {name!r} must be a plain file name")
@@ -235,6 +245,43 @@ def edit_diff(path: Path, before: str, after: str) -> str:
     return "\n".join(lines)
 
 
+def is_side(ctx) -> bool:
+    """Side questions and shared workers must not consume the main conversation's edits."""
+    from pcode.aside_guard import AsideGuard
+
+    if getattr(getattr(ctx, "agent", None), "name", None) == "worker":
+        return True
+    capabilities = getattr(ctx, "capabilities", None) or {}
+    return any(isinstance(c, AsideGuard) for c in capabilities.values())
+
+
+class NoteFeedback:
+    """Snapshots shared by broad memory feedback and active-plan-only feedback."""
+
+    def __init__(self):
+        self.seen: dict[Path, str] = {}
+
+    def observe(self, path: Path) -> None:
+        try:
+            self.seen[path] = path.read_text(encoding="utf-8")
+        except OSError:
+            self.seen.pop(path, None)
+
+    def edits(self, only: Path | None = None) -> list[str]:
+        changed = []
+        for path, before in list(self.seen.items()):
+            if only is not None and path != only:
+                continue
+            try:
+                after = path.read_text(encoding="utf-8")
+            except OSError:
+                continue
+            if after != before:
+                self.seen[path] = after
+                changed.append(f"`{path}`:\n```diff\n{edit_diff(path, before, after)}\n```")
+        return changed
+
+
 # --- Vault setup ---------------------------------------------------------------------
 
 
@@ -302,24 +349,49 @@ def enabled() -> bool:
     return NAME in name_list("extensions_on") - name_list("extensions_off")
 
 
-def plan_location(workspace: Path) -> PlanLocation | None:
-    """Where `/plan` writes when this extension is on and `workspace` is in an org."""
-    if not enabled():
-        return None
+def plan_guidance(directory: Path) -> str:
+    """Guidance also works for a saved absolute marker without current org configuration."""
+    return (
+        f"- This plan is a proposed brief: re-read `{directory.parent / FORMAT_NOTE}` before "
+        "creating or revising it and follow its Plans section (type: plan, state: proposed, "
+        "cssclasses: [proposed], the PROPOSED banner). Link an existing project brief via "
+        f"`project:` if one in `{directory}` matches this workspace's `dirs`. "
+        "If none exists, write a standalone plan; do not create a project brief."
+    )
+
+
+def plan_location(workspace: Path) -> PlanLocation:
+    """The vault for `/plan --obsidian`, whether or not this extension is on.
+
+    Raises ValueError with setup guidance when no writable org vault covers `workspace`.
+    """
     try:
         place = place_for(workspace)
-    except ValueError:
-        return None
-    if place is None:
-        return None
-    vault = place.org.vault
+        if place is None:
+            raise ValueError(f"No configured org covers {workspace}")
+        vault = place.org.vault
+        # Planning needs neither the dashboard nor Obsidian settings or sync.
+        format_note = vault / FORMAT_NOTE
+        if (format_note.exists() or format_note.is_symlink()) and not format_note.is_file():
+            raise ValueError(f"{format_note} must be a file")
+        briefs = vault / BRIEFS
+        briefs.mkdir(parents=True, exist_ok=True)
+        # Existing directories and format notes don't prove new plans can be written.
+        with tempfile.NamedTemporaryFile(dir=briefs, prefix=".pcode-plan-") as probe:
+            probe.write(b"plan write probe\n")
+            probe.flush()
+        if not format_note.exists():
+            write_text(format_note, (FILES / FORMAT_NOTE).read_text(encoding="utf-8"))
+    except (OSError, ValueError) as error:
+        raise ValueError(
+            f"/plan --obsidian: {error}. Configure a matching [[org]] with name, root "
+            f"and a writable vault in {config_path()}, then retry (or use /plan --local)."
+        ) from None
     project = place.repo or (Path(place.dir).name if place.dir != "." else place.org.name)
     return PlanLocation(
         vault / BRIEFS,
         safe_name(project, 40) or place.org.name,
-        f"- This plan is a proposed brief: read `{vault / FORMAT_NOTE}` first and follow its "
-        "Plans section (type: plan, state: proposed, cssclasses: [proposed], the PROPOSED "
-        "banner, `project:` linking the brief it changes, and only the sections that change).",
+        plan_guidance(vault / BRIEFS),
     )
 
 
@@ -410,7 +482,7 @@ def setup(pcode) -> None:
     current: dict = {"session": None}
     # Sync per session; None holds a choice made before the first message.
     sync: dict[str | None, bool] = {}
-    seen: dict[Path, str] = {}  # Note text as the model last read or wrote it.
+    feedback = NoteFeedback()
 
     def session_of(ctx) -> str | None:
         return base_conversation(getattr(ctx, "conversation_id", None)) or current["session"]
@@ -433,14 +505,6 @@ def setup(pcode) -> None:
         if session and state_path(session).parent.is_dir():  # Unsaved sessions have none.
             write_text(state_path(session), json.dumps({"sync": on}))
 
-    def is_side(ctx) -> bool:
-        from pcode.aside_guard import AsideGuard
-
-        if getattr(getattr(ctx, "agent", None), "name", None) == "worker":
-            return True
-        capabilities = getattr(ctx, "capabilities", None) or {}
-        return any(isinstance(c, AsideGuard) for c in capabilities.values())
-
     def in_vault(path: Path) -> bool:
         return path.suffix == ".md" and (path == vault or vault in path.parents)
 
@@ -450,7 +514,7 @@ def setup(pcode) -> None:
         if is_side(ctx) or not session or session == current["session"]:
             return
         current["session"] = session
-        seen.clear()  # Notes read in another conversation are not this one's to diff.
+        feedback.seen.clear()  # Another conversation's notes are not this one's to diff.
         if None in sync:
             set_sync(sync.pop(None), session)
 
@@ -460,24 +524,9 @@ def setup(pcode) -> None:
             path = Path(str(args.get("path", ""))).expanduser()
             path = (path if path.is_absolute() else pcode.workspace / path).resolve()
             if in_vault(path):
-                try:
-                    seen[path] = await asyncio.to_thread(path.read_text, encoding="utf-8")
-                except OSError:
-                    seen.pop(path, None)
+                await asyncio.to_thread(feedback.observe, path)
         return result
 
-    def edits() -> list[str]:
-        changed = []
-        for path, before in list(seen.items()):
-            try:
-                after = path.read_text(encoding="utf-8")
-            except OSError:
-                continue
-            if after != before:
-                seen[path] = after
-                changed.append(f"`{path}`:\n```diff\n{edit_diff(path, before, after)}\n```")
-        return changed
-
     @pcode.hooks.on.before_model_request
     async def remind(ctx, request_context):
         # Once per user message, persisted in history so the cached prefix holds.
@@ -494,7 +543,7 @@ def setup(pcode) -> None:
         ):
             return request_context
         lines = [SYNC] if sync_on(session_of(ctx)) else []
-        changed = await asyncio.to_thread(edits)
+        changed = await asyncio.to_thread(feedback.edits)
         if changed:
             lines += [EDITED, *changed]
         if lines:

{pcode-0.1.6 → pcode-0.1.7}/src/pcode/extensions/plan_mode.py

@@ -13,18 +13,22 @@ The model is trusted rather than fenced in: nothing blocks edits, the reminder
 just says what the user wants. The active plan lives in a marker file beside
 the plans, so it survives `/reload` (which re-imports this module) and restarts.
 
-With the `basic_memory` extension on and the workspace in one of its orgs, the
-plan is a note in that org's vault instead (`briefs/Plan — <project> — <title>.md`),
-in the brief format, and on approval the model marks it approved there. The
-marker then holds the note's absolute path rather than a slug.
+`--obsidian` makes the plan a note in the workspace's org vault instead
+(`briefs/Plan — <project> — <title>.md`, configured in `memory.toml`), whether or
+not the `basic_memory` extension is on: where a plan lives is a per-plan choice,
+not a memory setting. `--local` (the default) keeps it in `.pcode/plans`. The
+marker holds a vault note's absolute path rather than a local slug. With memory
+off, only the active note gets edit feedback and lifecycle updates.
 """
 
+import asyncio
 import re
 from pathlib import Path
 
 from pydantic_ai import ModelRetry
 from pydantic_ai.messages import ModelRequest, ToolReturnPart, UserPromptPart
 
+from pcode.conversation_ids import base_conversation
 from pcode.steering import run_request
 
 PLANS = ".pcode/plans"
@@ -49,11 +53,6 @@ Plan mode is on. The user wants to agree on a plan before any implementation.
 </plan-mode>"""
 
 
-def is_worker(ctx) -> bool:
-    """A shared delegate runs this extension's hooks too; plan mode is the parent's."""
-    return getattr(ctx.agent, "name", None) == "worker"
-
-
 def slugify(text: str) -> str:
     slug = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
     if len(slug) > 60:  # Cut at a word boundary when there is one.
@@ -67,14 +66,39 @@ def topic_slug(request: str) -> str:
     return slugify(" ".join(request.split("\n", 1)[0].split()[:8]))
 
 
+def parse_destination(argument: str) -> tuple[str | None, str]:
+    """Consume only leading flags, leaving the request's internal whitespace untouched."""
+    destination = None
+    argument = argument.strip()
+    while argument.startswith("-"):
+        flag, *rest = argument.split(maxsplit=1)
+        if flag not in ("--obsidian", "--local"):
+            raise ValueError(f"Unknown /plan flag {flag!r}; use --obsidian or --local.")
+        if destination is not None and destination != flag:
+            raise ValueError("/plan --obsidian and --local cannot be combined.")
+        destination = flag
+        argument = rest[0] if rest else ""
+    return destination, argument
+
+
 def setup(pcode) -> None:
     if pcode.is_worker:
         return
     plans = pcode.workspace / PLANS
     marker = plans / ACTIVE
-    from pcode.extensions.basic_memory import plan_location
+    from pcode.extensions.basic_memory import (
+        EDITED,
+        NOTE_TOOLS,
+        NoteFeedback,
+        enabled,
+        is_side,
+        plan_guidance,
+        plan_location,
+    )
 
-    location = plan_location(pcode.workspace)  # None: plans stay in .pcode/plans
+    memory_on = enabled()
+    feedback = NoteFeedback()
+    session = None
 
     def active() -> str | None:
         try:
@@ -98,15 +122,13 @@ def setup(pcode) -> None:
     def latest() -> str | None:
         # Only local plans: a vault holds every repo's plans, so "the newest" could
         # be another project's.
-        if location:
-            return None
         files = (
             sorted(plans.glob("*.md"), key=lambda p: p.stat().st_mtime) if plans.is_dir() else []
         )
         return files[-1].stem if files else None
 
-    def new_key(request: str) -> str:
-        return str(location.path_for(request)) if location else topic_slug(request)
+    def new_key(request: str, destination) -> str:
+        return str(destination.path_for(request)) if destination else topic_slug(request)
 
     def start(slug: str) -> None:
         plans.mkdir(parents=True, exist_ok=True)
@@ -116,22 +138,42 @@ def setup(pcode) -> None:
         marker.write_text(slug + "\n")
 
     def plan_command(argument: str) -> str | None:
-        argument = argument.strip()
+        flag, argument = parse_destination(argument)
         current = active()
-        if argument == "off":
+        if flag is None and argument == "off":
             if current is None:
                 pcode.ui.notify("Plan mode is already off.")
                 return
             marker.unlink(missing_ok=True)
             pcode.ui.notify(f"Plan mode off. The plan stays in {relative(current)}.")
             return
-        if argument == "status":
+        if flag is None and argument == "status":
             pcode.ui.notify(
                 f"Plan mode on: {relative(current)}" if current else "Plan mode is off."
             )
             return
-        slug = new_key(argument) if argument else (current or latest() or new_key("plan"))
+        destination = plan_location(pcode.workspace) if flag == "--obsidian" else None
+        compatible = current
+        if flag and current:
+            matches = (
+                Path(current).parent == destination.directory
+                if destination
+                else not is_vault(current)
+            )
+            if not matches:
+                compatible = None
+        slug = (
+            new_key(argument, destination)
+            if argument
+            else (
+                compatible or (latest() if flag is None else None) or new_key("plan", destination)
+            )
+        )
         start(slug)
+        if not memory_on and is_vault(slug):
+            path = path_of(slug).resolve()
+            if slug != current or path not in feedback.seen:
+                feedback.observe(path)
         exists = path_of(slug).exists()
         verb = "Resuming" if exists else "Planning in"
         ask = "Say" if argument else "Describe the change; say"
@@ -147,9 +189,11 @@ def setup(pcode) -> None:
         "/plan",
         "Plan before implementing; the model exits when you approve",
         plan_command,
-        arguments=("off", "status"),
+        arguments=("off", "status", "--obsidian", "--local"),
         free_arguments=True,  # anything else is the request to plan
         argument_descriptions={
+            "--obsidian": "Keep the plan in the org's Obsidian vault",
+            "--local": "Keep the plan in .pcode/plans (the default)",
             "off": "Leave plan mode (the plan file is kept)",
             "status": "Show whether plan mode is on and its file",
         },
@@ -174,24 +218,68 @@ def setup(pcode) -> None:
         if is_vault(current):
             result += (
                 " First mark it approved, as the brief format says: `state: approved`, "
-                "`cssclasses: [approved]`, the APPROVED banner, and ✅ on the brief's Open plans "
-                "line. When the work ships, fold it into the brief and mark the plan implemented."
+                "`cssclasses: [approved]`, and the APPROVED banner."
             )
+            if memory_on:
+                result += (
+                    " If an existing brief is linked, add ✅ on the brief's Open plans line "
+                    "and, when the work ships, fold it into the brief. Mark the plan implemented "
+                    "when shipped, even if it is standalone; do not create a brief implicitly."
+                )
+            else:
+                result += (
+                    " When the work ships, mark the plan implemented. Project memory is off: "
+                    "update only this plan, not a project brief; do not create or maintain one."
+                )
         return result
 
     @pcode.hooks.on.before_tool_execute
     async def workers_cannot_exit(ctx, *, call, tool_def, args):
-        if tool_def.name == "exit_plan_mode" and is_worker(ctx):
+        if tool_def.name == "exit_plan_mode" and is_side(ctx):
             raise ModelRetry("Only the main agent can leave plan mode.")
         return args
 
+    if not memory_on:
+        current = active()
+        if current and is_vault(current):
+            feedback.observe(path_of(current).resolve())
+
+        @pcode.hooks.on.before_run
+        async def remember_session(ctx):
+            nonlocal session
+            incoming = base_conversation(getattr(ctx, "conversation_id", None))
+            if is_side(ctx) or not incoming or incoming == session:
+                return
+            if session is not None:
+                feedback.seen.clear()
+                current = active()
+                if current and is_vault(current):
+                    await asyncio.to_thread(feedback.observe, path_of(current).resolve())
+            session = incoming
+
+        @pcode.hooks.on.after_tool_execute
+        async def note_seen(ctx, *, call, tool_def, args, result):
+            current = active()
+            if (
+                current
+                and is_vault(current)
+                and tool_def.name in NOTE_TOOLS
+                and not is_side(ctx)
+                and isinstance(args, dict)
+            ):
+                path = Path(str(args.get("path", ""))).expanduser()
+                path = (path if path.is_absolute() else pcode.workspace / path).resolve()
+                if path == path_of(current).resolve():
+                    await asyncio.to_thread(feedback.observe, path)
+            return result
+
     @pcode.hooks.on.before_model_request
     async def remind(ctx, request_context):
         # Once per user turn, persisted in history so the prompt prefix stays
         # cached. A retried turn resends the same request, so skip one that
         # already carries the reminder or is mid-turn (holds tool results).
         current = active()
-        if current is None or is_worker(ctx):
+        if current is None or is_side(ctx):
             return request_context
         request = run_request(ctx, request_context)
         parts = request.parts if isinstance(request, ModelRequest) else ()
@@ -201,6 +289,22 @@ def setup(pcode) -> None:
             and not any(isinstance(p, ToolReturnPart) for p in parts)
             and not any(str(p.content).startswith("<plan-mode>") for p in prompts)
         ):
-            extra = f"\n{location.guidance}" if location and is_vault(current) else ""
+            extra = ""
+            if is_vault(current):
+                extra = "\n" + plan_guidance(path_of(current).parent)
+                if conversation := base_conversation(getattr(ctx, "conversation_id", None)):
+                    # The Obsidian bridge plugin finds this conversation through it.
+                    extra += (
+                        f"\n- Keep `session: {conversation}` in the plan's front matter "
+                        "(add it, or update it if it names another session)."
+                    )
+                if not memory_on:
+                    extra += (
+                        "\n- Project memory is off. Update only this plan, not project briefs, "
+                        "including on approval and completion."
+                    )
+                    changed = await asyncio.to_thread(feedback.edits, path_of(current).resolve())
+                    if changed:
+                        extra += "\n" + EDITED + "\n" + "\n\n".join(changed)
             parts.append(UserPromptPart(REMINDER.format(path=relative(current), extra=extra)))
         return request_context

{pcode-0.1.6 → pcode-0.1.7}/src/pcode/file_refs.py

@@ -200,10 +200,7 @@ def reference_fragment(text: str) -> str | None:
 
 
 class ReferenceLexer(Lexer):
-    """Style file references in the editor so they read as paths, not prose.
-
-    ``extra`` adds further ``(pattern, style)`` tokens, such as paste markers.
-    """
+    """Style file references in the editor so they read as paths, not prose."""
 
     def __init__(self, extra: list[tuple[re.Pattern[str], str]] = ()) -> None:
         self.patterns = [(REFERENCE_PATTERN, "class:reference"), *extra]