@passioncode-ai/passioncode 0.2.45 → 0.2.46

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session_env.py

@@ -58,7 +58,7 @@ SESSION_ID = re.compile(r"[A-Za-z0-9._:-]{1,128}")
 LOOPBACK_ORIGIN = re.compile(r"http://127\.0\.0\.1:(\d{1,5})")
 
 
-VERSION = "0.55.0"
+VERSION = "0.56.0"
 
 
 HOSTS = {"claude": "Claude Code", "codex": "Codex", "kimi": "Kimi Code",
@@ -100,21 +100,26 @@ def nudge_shown(line: str) -> str:
 WATCH_NUDGES_FILE = "nudges.watch.json"
 MAX_NUDGES = 5
 MAX_NUDGE_CHARS = 400
+#: At most this many items of an answer's nudges are read (FAA-143): a broken Fabric's long list costs linear time.
+MAX_NUDGE_ITEMS = 1000
 _CONTROL = re.compile(r"[\x00-\x1f\x7f-\x9f\u2028\u2029]+")
 
 
 def nudge_lines(value: Any, limit: Optional[int] = MAX_NUDGES) -> List[str]:
     """The `says` of a nudges list as clean lines: one line each (controls and line breaks become a space), cut to
-    MAX_NUDGE_CHARS, blanks and repeats dropped, at most `limit` (None: all). Anything that is not such a list gives []."""
+    MAX_NUDGE_CHARS, blanks and repeats dropped, at most `limit` (None: all) from the first MAX_NUDGE_ITEMS items.
+    Anything that is not such a list gives []."""
     lines: List[str] = []
+    seen = set()
     if not isinstance(value, list):
         return lines
-    for item in value:
+    for item in value[:MAX_NUDGE_ITEMS]:
         says = item.get("says") if isinstance(item, dict) else None
         if not isinstance(says, str):
             continue
         line = " ".join(_CONTROL.sub(" ", says).split())[:MAX_NUDGE_CHARS].rstrip()
-        if line and line not in lines:
+        if line and line not in seen:
+            seen.add(line)
             lines.append(line)
         if limit is not None and len(lines) == limit:
             break
@@ -480,6 +485,10 @@ NO_SESSION_MARK = "no-session"
 #: `repositories` as {host, owner, name}: a worker writes it from the tool's schema and removes it when the schema stops
 #: saying so. Until it exists the Stop hook reads no transcript (FAA-140, seam and product readings 1).
 REPOSITORIES_MARK = "observe-takes-repositories"
+#: The file in the hooks' own folder that turns the transcript read off (FAA-160): the turn's git facts are still
+#: measured. The environment variable FABRIC_SESSION_NO_REPOSITORIES=1 does the same for one environment.
+NO_REPOSITORIES_MARK = "no-repositories"
+NO_REPOSITORIES_ENV = "FABRIC_SESSION_NO_REPOSITORIES"
 NO_SESSION_HOLD_S = 15 * 60.0
 
 
@@ -531,10 +540,18 @@ def _write_private(path: Path, text: str) -> None:
     os.replace(str(tmp), str(path))
 
 
+def repositories_off(env: Optional[Dict[str, str]] = None) -> bool:
+    """Whether the person turned the transcript read off (FAA-160): FABRIC_SESSION_NO_REPOSITORIES set to anything but
+    "" or "0", or the file NO_REPOSITORIES_MARK in the hooks' own folder."""
+    value = (os.environ if env is None else env).get(NO_REPOSITORIES_ENV, "")
+    return value not in ("", "0") or (state_root(env=env) / NO_REPOSITORIES_MARK).exists()
+
+
 def repositories_wanted(env: Optional[Dict[str, str]] = None) -> bool:
     """Whether the Stop hook reads the transcript for the turn's other repositories (FAA-140): only once a worker
-    left the mark, and never on Windows, where a Bash command's paths are not this host's (FAA-175)."""
-    return sys.platform != "win32" and (state_root(env=env) / REPOSITORIES_MARK).exists()
+    left the mark, and not when the person turned it off (FAA-160). On Windows too (FAA-175): bash_paths reads a Git
+    Bash command's /c/... and C:/... paths as this host's."""
+    return not repositories_off(env) and (state_root(env=env) / REPOSITORIES_MARK).exists()
 
 
 def session_dir(session_id: str, env: Optional[Dict[str, str]] = None) -> Path:

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session_mcp.py

@@ -16,6 +16,7 @@ from typing import List
 from typing import Optional
 from typing import Tuple
 
+from fabric_session_paths import _windows_path, bash_paths  # noqa: E402,F401 - read by turn_paths and the tests
 from fabric_session_env import (  # noqa: E402 - the kit (FAA-65)
     BOARD_STATUS_TOOL,
     GIT_TIMEOUT_S,
@@ -122,7 +123,7 @@ TRANSCRIPT_TAIL_BYTES = 512 * 1024
 
 #: FAA-140 (seam reading 1): the Bash command text one turn may split, in characters; a long unterminated quote costs
 #: shlex its whole length, so this caps the Stop hook's time on it.
-BASH_BYTES = 65536
+BASH_BYTES = 65536  # characters of Bash command text a turn, despite the name (kept: the facade exports it)
 
 
 #: FAA-140 (REQ-1): at most this many other repositories are named for one turn.
@@ -177,41 +178,6 @@ def parse_origin(url: str) -> Optional[Dict[str, str]]:
     return None
 
 
-def bash_paths(command: str, cwd: Path) -> List[str]:
-    """The folders a Bash command names as `cd <absolute path>` or `git -C <path>` (absolute, or relative to `cwd`),
-    in order. Nothing else of the command is kept; a command that does not split is [] (FAA-140)."""
-    import shlex  # only a Stop hook with a transcript needs it
-    try:
-        lexer = shlex.shlex(command, posix=True, punctuation_chars=True)
-        lexer.whitespace_split = True
-        tokens = list(lexer)
-    except ValueError:
-        return []
-    found: List[str] = []
-    separators = set("();&|<>")
-    start = True  # a command word may stand here
-    index = 0
-    while index < len(tokens):
-        token = tokens[index]
-        if token and set(token) <= separators:
-            start, index = True, index + 1
-            continue
-        if start and token == "cd" and index + 1 < len(tokens) and os.path.isabs(tokens[index + 1]):
-            found.append(os.path.normpath(tokens[index + 1]))
-        elif start and os.path.basename(token) == "git":
-            look = index + 1
-            while look < len(tokens) and tokens[look].startswith("-") and not set(tokens[look]) <= separators:
-                if tokens[look] == "-C" and look + 1 < len(tokens) and not set(tokens[look + 1]) <= separators:
-                    found.append(os.path.normpath(os.path.join(str(cwd), tokens[look + 1])))
-                    look += 1
-                elif tokens[look] == "-c":
-                    look += 1
-                look += 1
-        start = False
-        index += 1
-    return found
-
-
 def _prompt(entry: Dict[str, Any]) -> bool:
     """Whether a transcript entry is a prompt the person typed: a user entry that is no tool result, no meta entry
     and no subagent's."""
@@ -291,7 +257,7 @@ def turn_paths(transcript: Any, cwd: Path, until: Optional[float] = None) -> Lis
             value = arguments.get(CHANGING_TOOLS[name])
             named = [os.path.normpath(os.path.join(str(cwd), value))] if isinstance(value, str) and value else []
         elif name == "Bash" and isinstance(arguments.get("command"), str) and left > 0 \
-                and ("cd" in arguments["command"] or "git" in arguments["command"]):
+                and any(word in arguments["command"].lower() for word in ("cd", "git", "pushd")):  # GIT.EXE on Windows
             command = arguments["command"][:left]
             left -= len(command)
             named = bash_paths(command, cwd)
@@ -845,13 +811,18 @@ def _keep_nudges(directory: Path, value: Any, note: Callable[[str], None], sessi
         _write_private(directory / name, json.dumps(merged))
         note("session=%s event=turn nudges=%d dropped=%d" % (session_id[:8], len(offered), dropped))
     except OSError as exc:
+        saved: List[str] = []
         try:
             if kept:
                 _write_private(directory / name, json.dumps(kept))
+                saved = kept
         except OSError:
-            kept = []
+            pass
+        # Lost: every distinct line, pending or this turn's (capped ones included, FAA-143), that is not back in the file.
+        # Both lists are clean lines already: counted as a set, never through nudge_lines' item cap (0.56.0 unit r1).
+        lost = len(set(kept).union(offered) - set(saved))
         note("session=%s event=turn nudges=%d outcome=lost lost=%d reason=%r"
-             % (session_id[:8], len(offered), len(merged) - len(kept), type(exc).__name__))
+             % (session_id[:8], len(offered), lost, type(exc).__name__))
 
 
 def _drop_stale_ends(entries: List[Path], note: Callable[[str], None], session_id: str) -> List[Path]:

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session_paths.py

@@ -0,0 +1,190 @@
+"""working-with-fabric, part of fabric_session.py (FAA-65): reading the folders a Bash command names, for the Stop
+hook's repositories (FAA-140, FAA-166, FAA-175). Standard library only."""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path, PurePath
+from typing import Any
+from typing import List
+from typing import Optional
+
+
+_DRIVE_MOUNT = re.compile(r"/(?:cygdrive/)?([A-Za-z])(?=/|$)")
+
+
+def _windows_path(token: str) -> Optional[str]:
+    """A Git Bash path as this Windows host's (FAA-175): `/c/...` and `/cygdrive/c/...` are drive C, `C:/...` and
+    `C:\\...` stay a drive path, `\\\\host\\share` a share. None for another `/...` (Git's own root, which only
+    `cygpath` knows) and for a relative path."""
+    import ntpath
+    mount = _DRIVE_MOUNT.match(token)
+    if mount:
+        token = mount.group(1).upper() + ":\\" + token[mount.end():].lstrip("/")
+    elif token.startswith("/"):
+        return None
+    if not ntpath.isabs(token) or not (ntpath.splitdrive(token)[0]):
+        return None
+    return ntpath.normpath(token)
+
+
+#: Words after which a command word may still stand (reserved words and the prefixes that run their command here).
+KEYWORDS = frozenset(("{", "!", "then", "do", "else", "elif", "if", "while", "until", "time", "command", "builtin"))
+ASSIGNMENT = re.compile(r"[A-Za-z_][A-Za-z0-9_]*=")
+
+
+def bash_paths(command: str, cwd: Path, windows: Optional[bool] = None) -> List[str]:
+    """The folders a Bash command names as `cd <absolute path>` or `git -C <path>`, in order. A relative `-C` is read
+    against the folder the command last changed into with an absolute `cd`, else `cwd`; after a `cd` to a relative or
+    unknown folder it is dropped (FAA-166). A `cd` inside `( )`, a pipeline's stage or a list sent to the background
+    with `&` moves only a subshell, so the folder after it is the one before; a newline ends a command, a here-document's
+    body is text, `{`, `then`, `x=1` and the like still leave a command word to come, and `pushd` moves like `cd`. Nothing
+    else of the command is kept; a command that does not split is [] (FAA-140). On Windows (`windows`, default
+    `sys.platform == "win32"`) paths are read as Git Bash writes them, with its quoting: an unquoted `C:\\work` is
+    `C:work` there too, so a native path counts when it is quoted (FAA-175); Cygwin and MSYS2 Pythons read their own
+    POSIX paths (FAA-177)."""
+    import shlex  # only a Stop hook with a transcript needs it
+    windows = sys.platform == "win32" if windows is None else windows
+    if windows:
+        import ntpath as paths
+    else:
+        import posixpath as paths
+    try:
+        # A `\` before a newline joins the lines, as in bash; a `;` and a second newline after each newline keep a `#`
+        # comment, which the lexer reads to the end of its line, newline included, from swallowing the next command or
+        # the line end a here-document counts.
+        command = command.replace("\\\n", "").replace("\n", "\n;\n")
+        lexer = shlex.shlex(command, posix=True, punctuation_chars="();<>|&\n")
+        lexer.whitespace = " \t\r"  # a newline ends a command, as `;` does
+        lexer.whitespace_split = True
+        tokens = list(lexer)
+    except ValueError:
+        return []
+
+    def absolute(token: str) -> Optional[str]:
+        if windows:
+            return _windows_path(token)
+        return paths.normpath(token) if paths.isabs(token) else None
+
+    found: List[str] = []
+    separators = set("();&|<>\n")
+    # Where a relative -C points: None once a cd went somewhere unknown. POSIX rules read the folder with `/`, whatever
+    # the host writes (a test on Windows reads POSIX commands too).
+    base: Optional[str] = str(cwd) if windows else PurePath(cwd).as_posix()
+    # A cd in a pipeline's stage, in `( )` or in a backgrounded list moves only a subshell: the folder goes back to
+    # where that pipeline, subshell or list began.
+    pipe_start = list_start = base
+    in_pipeline = False
+    stack: List[Any] = []
+
+    def end_pipeline() -> None:
+        nonlocal base, pipe_start, in_pipeline
+        if in_pipeline:
+            base = pipe_start
+        pipe_start, in_pipeline = base, False
+
+    heredocs: List[str] = []  # the delimiters of here-documents whose bodies start at the next newline
+
+    def past_heredocs(at: int) -> int:
+        """The index of the newline ending the last pending here-document's delimiter line (or the end): the body is
+        text for a command, never commands of its own."""
+        while heredocs and at < len(tokens):
+            line_end = at
+            while line_end < len(tokens) and "\n" not in tokens[line_end]:
+                line_end += 1
+            if tokens[at:line_end] == [heredocs[0]]:
+                heredocs.pop(0)
+                if not heredocs:
+                    return line_end
+            at = line_end + 1
+        heredocs.clear()
+        return len(tokens)
+
+    start = True  # a command word may stand here
+    index = 0
+    while index < len(tokens):
+        token = tokens[index]
+        if token and set(token) <= separators:
+            at, ends_command, newline = 0, False, False
+            while at < len(token):
+                pair, char = token[at:at + 2], token[at]
+                if pair in ("&&", "||"):
+                    end_pipeline()
+                    at, ends_command = at + 2, True
+                    continue
+                if token.startswith("<<<", at):  # a here-string: its word is text, no body follows
+                    at += 3
+                    continue
+                if pair == "<<" and index + 1 < len(tokens):
+                    delimiter = tokens[index + 1]  # <<EOF, <<'EOF', <<-EOF: shlex has taken the quotes off
+                    if delimiter == "-" and index + 2 < len(tokens):
+                        index, delimiter = index + 1, tokens[index + 2]
+                    heredocs.append(delimiter[1:] if delimiter.startswith("-") and len(delimiter) > 1 else delimiter)
+                    index += 1  # the delimiter is no command word
+                    at += 2
+                    continue
+                if pair == "&>":  # `&>` and `&>>` redirect, they background nothing
+                    at += 3 if token[at + 2:at + 3] == ">" else 2
+                    continue
+                if char in "<>":  # a redirection: `2>&1` backgrounds nothing, `>|` pipes nothing
+                    at += 2 if token[at + 1:at + 2] in ("&", "|") else 1
+                    continue
+                ends_command = True
+                if pair == "|&" or char == "|":
+                    base, in_pipeline = pipe_start, True
+                    at += 2 if pair == "|&" else 1
+                    continue
+                if char in ";\n":
+                    end_pipeline()
+                    list_start = base
+                    newline = newline or char == "\n"
+                elif char == "&":
+                    end_pipeline()
+                    base = pipe_start = list_start
+                elif char == "(":
+                    stack.append((base, pipe_start, list_start, in_pipeline))
+                    pipe_start = list_start = base
+                    in_pipeline = False
+                elif char == ")":
+                    end_pipeline()
+                    if stack:
+                        base, pipe_start, list_start, in_pipeline = stack.pop()
+                at += 1
+            start = start or ends_command  # a redirection alone starts no command
+            index = past_heredocs(index + 1) if newline and heredocs else index + 1
+            continue
+        if start and (token in KEYWORDS or ASSIGNMENT.match(token)):
+            index += 1  # `{ cd /a; }`, `then cd`, `x=1 cd`, `command cd`: a command word may still follow
+            continue
+        if start and token in ("pushd", "popd"):
+            target = tokens[index + 1] if token == "pushd" and index + 1 < len(tokens) else None
+            folder = absolute(target) if target and not set(target) <= separators else None
+            if folder:
+                found.append(folder)
+            base = folder  # popd, or pushd somewhere not known here: the folder is not known
+        elif start and token == "cd":
+            target = tokens[index + 1] if index + 1 < len(tokens) and not set(tokens[index + 1]) <= separators else None
+            folder = absolute(target) if target else None
+            if folder:
+                found.append(folder)
+            base = folder
+        elif start and (paths.basename(token).lower() if windows else paths.basename(token)) in ("git", "git.exe"):
+            look, at, moved = index + 1, base, False
+            while look < len(tokens) and tokens[look].startswith("-") and not set(tokens[look]) <= separators:
+                if tokens[look] == "-C" and look + 1 < len(tokens) and not set(tokens[look + 1]) <= separators:
+                    # git reads each relative -C against the one before it and runs in the last
+                    folder = absolute(tokens[look + 1])
+                    if folder is None and at is not None and not tokens[look + 1].startswith("/"):
+                        folder = paths.normpath(paths.join(at, tokens[look + 1]))
+                        if windows and not (paths.isabs(folder) and paths.splitdrive(folder)[0]):
+                            folder = None  # `C:work`, a drive-relative path: not known here
+                    at, moved = folder, True
+                    look += 1
+                elif tokens[look] == "-c":
+                    look += 1
+                look += 1
+            if moved and at:
+                found.append(at)
+        start = False
+        index += 1
+    return found

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/host_hooks.py

@@ -154,7 +154,7 @@ def main(argv=None, env=None, out=print, err=print):
                         'opencode':['hosts/context.mjs','hosts/opencode/fabric.mjs'],
                         'pi':['hosts/context.mjs','hosts/pi/fabric.mjs'],
                         'openclaw':['hosts/context.mjs','hosts/openclaw/index.mjs','hosts/openclaw/package.json','hosts/openclaw/openclaw.plugin.json']}[args.host]
-            required += ['fabric_session_env.py','fabric_session_mcp.py','fabric_session_mail.py','fabric_session_hosts.py','fabric_session_cli.py']  # the helper's own modules (FAA-65)
+            required += ['fabric_session_env.py','fabric_session_mcp.py','fabric_session_paths.py','fabric_session_mail.py','fabric_session_hosts.py','fabric_session_cli.py']  # the helper's own modules (FAA-65)
             if any(not (script.parent/p).is_file() for p in required):
                 raise fs.Refused('native adapter source is missing; update the complete skill before installing hooks')
         path=Path(args.config).expanduser().absolute() if args.config else destination(args.host,env)

package/payload/plugins/passioncode/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "passioncode",
   "displayName": "PassionCode.ai",
-  "version": "0.2.45",
+  "version": "0.2.46",
   "description": "Set up and check PassionCode.ai on a computer with one command (setting-up-passioncode), the organisation's working rules for every contributor's agent (working-in-passioncode), and a once-a-day check at session start that keeps the PassionCode.ai skill set current.",
   "author": {
     "name": "PassionCode.ai",