housebroken-cli 0.6.8__tar.gz → 0.6.9__tar.gz

{housebroken_cli-0.6.8 → housebroken_cli-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: housebroken-cli
-Version: 0.6.8
+Version: 0.6.9
 Summary: Agent-written pull requests that do not make a mess in someone else's house.
 Project-URL: Repository, https://github.com/lenamonj/housebroken
 License-Expression: MIT
@@ -76,8 +76,8 @@ Before the first pull request to an organization: CLA, DCO, signed-commit requir
 A memory-safety, remote-abort, injection or path-escape finding goes by the project's SECURITY.md route, privately, and never becomes a public pull request until the project answers.
 
 **9. File through the gate.**
-`branch-check.sh` refuses a dirty working tree, a file whose mode disagrees with its siblings, a file the repository's own `.gitignore` excludes, a working artifact, a commit carrying a tool trailer, a session link or a tool identity, a sign-off naming a username, a branch not on top of its base, and any comment added to code; it prints every absolute claim in added prose for falsification, and stamps the head it passed.
-`review.sh` names the adversarial reviewer: a different model from the one that wrote the change, one tier down, never below Sonnet. The reviewer gets a fresh context, hard read-only limits and an attack list that starts with every claim the prose makes and includes the form of the code: the reviewer writes the changed block the way the strongest engineer in that language would, in the repository's own idioms, and a smaller or clearer version is a finding; every finding carries evidence it produced itself, and its report is bound to the head and the text it read. A fix is a new head and gets a new review.
+`branch-check.sh` refuses a dirty working tree, a file whose mode disagrees with its siblings, a file the repository's own `.gitignore` excludes, a working artifact, a commit carrying a tool trailer, a session link or a tool identity, a sign-off naming a username, a branch not on top of its base, any comment added to code, a warning suppression no build log shows firing, and reflection added to a .NET project that declares AOT or trim support without an AOT publish log; it prints every absolute claim in added prose for falsification, and stamps the head it passed.
+`review.sh` names the adversarial reviewer: a different model from the one that wrote the change, one tier down, never below Sonnet. The reviewer gets a fresh context, hard read-only limits, and before it reads the diff it writes its own fix from the bug alone, so it is not anchored on ours; the report names that fix and the gate refuses one that does not. Its attack list starts with every claim the prose makes and includes the form of the code: the reviewer writes the changed block the way the strongest engineer in that language would, in the repository's own idioms, and a smaller or clearer version is a finding; every finding carries evidence it produced itself, and its report is bound to the head and the text it read. A fix is a new head and gets a new review.
 `file-pr.sh` is the only way a pull request is opened. It refuses without a prior-art printout under a day old, a policy printout under a day old that does not read BAN, a body that discloses when the policy asks, a branch stamp for the exact head, and a POST AS IS review of that head and that body.
 `file-issue.sh` is the only way an issue is opened. It refuses without the same prior-art and policy printouts, refuses the same prose, and refuses a body that mentions a fix, a patch or a pull request without a GitHub link to the branch or commit, so work that exists is attributable to whoever did it.
 

{housebroken_cli-0.6.8 → housebroken_cli-0.6.9}/README.md

@@ -64,8 +64,8 @@ Before the first pull request to an organization: CLA, DCO, signed-commit requir
 A memory-safety, remote-abort, injection or path-escape finding goes by the project's SECURITY.md route, privately, and never becomes a public pull request until the project answers.
 
 **9. File through the gate.**
-`branch-check.sh` refuses a dirty working tree, a file whose mode disagrees with its siblings, a file the repository's own `.gitignore` excludes, a working artifact, a commit carrying a tool trailer, a session link or a tool identity, a sign-off naming a username, a branch not on top of its base, and any comment added to code; it prints every absolute claim in added prose for falsification, and stamps the head it passed.
-`review.sh` names the adversarial reviewer: a different model from the one that wrote the change, one tier down, never below Sonnet. The reviewer gets a fresh context, hard read-only limits and an attack list that starts with every claim the prose makes and includes the form of the code: the reviewer writes the changed block the way the strongest engineer in that language would, in the repository's own idioms, and a smaller or clearer version is a finding; every finding carries evidence it produced itself, and its report is bound to the head and the text it read. A fix is a new head and gets a new review.
+`branch-check.sh` refuses a dirty working tree, a file whose mode disagrees with its siblings, a file the repository's own `.gitignore` excludes, a working artifact, a commit carrying a tool trailer, a session link or a tool identity, a sign-off naming a username, a branch not on top of its base, any comment added to code, a warning suppression no build log shows firing, and reflection added to a .NET project that declares AOT or trim support without an AOT publish log; it prints every absolute claim in added prose for falsification, and stamps the head it passed.
+`review.sh` names the adversarial reviewer: a different model from the one that wrote the change, one tier down, never below Sonnet. The reviewer gets a fresh context, hard read-only limits, and before it reads the diff it writes its own fix from the bug alone, so it is not anchored on ours; the report names that fix and the gate refuses one that does not. Its attack list starts with every claim the prose makes and includes the form of the code: the reviewer writes the changed block the way the strongest engineer in that language would, in the repository's own idioms, and a smaller or clearer version is a finding; every finding carries evidence it produced itself, and its report is bound to the head and the text it read. A fix is a new head and gets a new review.
 `file-pr.sh` is the only way a pull request is opened. It refuses without a prior-art printout under a day old, a policy printout under a day old that does not read BAN, a body that discloses when the policy asks, a branch stamp for the exact head, and a POST AS IS review of that head and that body.
 `file-issue.sh` is the only way an issue is opened. It refuses without the same prior-art and policy printouts, refuses the same prose, and refuses a body that mentions a fix, a patch or a pull request without a GitHub link to the branch or commit, so work that exists is attributable to whoever did it.
 

{housebroken_cli-0.6.8 → housebroken_cli-0.6.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "housebroken-cli"
-version = "0.6.8"
+version = "0.6.9"
 description = "Agent-written pull requests that do not make a mess in someone else's house."
 dynamic = ["readme"]
 license = "MIT"

{housebroken_cli-0.6.8 → housebroken_cli-0.6.9}/scripts/branch-check.sh

@@ -7,20 +7,29 @@
 # .gitignore excludes; a working artifact; a commit carrying a tool trailer, a
 # session link or a tool identity; a sign-off naming a username; a branch that
 # is not on top of its base; and a comment added to code, test files included,
-# unless a maintainer asked for it (comment-check.sh). Absolute claims in added
-# prose are printed for you to falsify one by one; some of them are true.
+# unless a maintainer asked for it (comment-check.sh); a warning suppression the
+# branch adds, until a build log shows the warning it suppresses firing; and
+# reflection added to a .NET project that declares itself AOT compatible or
+# trimmable, until an AOT publish log is given. shouldly #1335 suppressed an
+# IL2075 that never fired, and the reflection under it found nothing under
+# Native AOT. Absolute claims in added prose are printed for you to falsify one
+# by one; some of them are true.
 #
 # A branch that passes gets a stamp at $HOUSEBROKEN_HOME/branch-checks/<head>,
 # which file-pr.sh requires for the head it files.
 #
 # Usage:
 #   bash branch-check.sh [CLONE] [--base REF] [--asked URL]
+#                        [--warning-log FILE] [--aot-log FILE]
 #   bash branch-check.sh --help
 #
 # CLONE defaults to the current directory. REF defaults to the first of
 # upstream/main, upstream/master, origin/main, origin/master that resolves.
 # --asked URL is the maintainer's request for documentation, which turns the
-# comment refusal into a check.
+# comment refusal into a check. --warning-log FILE is a build log of the
+# branch without its suppressions; it must name every warning id they suppress.
+# --aot-log FILE is the output of an AOT publish (dotnet publish
+# -p:PublishAot=true) of the branch, run and read.
 #
 # Exits 0 when nothing blocks, 1 on a refusal, 2 on a usage error.
 set -u
@@ -32,6 +41,8 @@ home="${HOUSEBROKEN_HOME:-$HOME/.housebroken}"
 clone="."
 base=""
 asked=""
+warnlog=""
+aotlog=""
 while [ "$#" -gt 0 ]; do
   case "$1" in
     --help|-h) usage; exit 0 ;;
@@ -47,6 +58,16 @@ while [ "$#" -gt 0 ]; do
       [ -n "$asked" ] || { echo "REFUSED: --asked needs the URL of the maintainer's ask" >&2; exit 2; }
       ;;
     --asked=*) asked="${1#--asked=}" ;;
+    --warning-log)
+      shift
+      warnlog="${1:-}"
+      [ -f "$warnlog" ] || { echo "REFUSED: --warning-log needs a build log file" >&2; exit 2; }
+      ;;
+    --aot-log)
+      shift
+      aotlog="${1:-}"
+      [ -f "$aotlog" ] || { echo "REFUSED: --aot-log needs an AOT publish log file" >&2; exit 2; }
+      ;;
     -*) echo "REFUSED: unknown option $1" >&2; exit 2 ;;
     *) clone="$1" ;;
   esac
@@ -161,6 +182,39 @@ case "$comment_rc" in
 esac
 printf '%s\n' "$comments" | grep -E '^CHECK: ' | sed 's/^/    /'
 
+# A suppression hides a warning from the maintainer too, so it has to be shown
+# that the warning exists. A suppression covering nothing usually covers code
+# that is wrong in a way the analyzer cannot see.
+added=$(git diff -U0 "$base..HEAD" -- . ':(exclude)*.md' ':(exclude)*.rst' ':(exclude)*.txt' 2>/dev/null \
+  | grep '^+' | grep -v '^+++' | sed 's/^+//')
+suppressions=$(printf '%s\n' "$added" | grep -E 'UnconditionalSuppressMessage|SuppressMessage\(|#pragma warning disable|@SuppressWarnings|@Suppress\(|#!?\[allow\(|nolint|NOLINT|noqa|eslint-disable|@ts-ignore|@ts-expect-error|type: *ignore|pylint: *disable|rubocop:disable|swiftlint:disable')
+if [ -n "$suppressions" ]; then
+  ids=$(printf '%s\n' "$suppressions" | grep -oE '\b[A-Z]{1,4}[0-9]{3,5}\b' | sort -u)
+  unshown=""
+  if [ -z "$warnlog" ]; then
+    unshown="no --warning-log given"
+  else
+    for id in $ids; do grep -q "$id" "$warnlog" || unshown="$unshown $id"; done
+  fi
+  if [ -n "$unshown" ]; then
+    block "the branch adds a warning suppression, and no build log shows the warning firing ($unshown)"
+    printf '%s\n' "$suppressions" | sed 's/^/    /'
+  fi
+fi
+
+# The trim analyzer does not flag object.GetType().GetProperty(...), so a clean
+# build proves nothing about reflection under Native AOT; only a publish does.
+aotdecl=$(git grep -lE '<(IsAotCompatible|IsTrimmable|PublishAot|EnableTrimAnalyzer|EnableAotAnalyzer)( [^>]*)?>[[:space:]]*true' HEAD -- '*.csproj' '*.props' '*.targets' 2>/dev/null \
+  | sed 's/^HEAD://' | tr '\n' ' ')
+if [ -n "$aotdecl" ]; then
+  reflection=$(git diff -U0 "$base..HEAD" -- '*.cs' 2>/dev/null | grep '^+' | grep -v '^+++' | sed 's/^+//' \
+    | grep -E '\.Get(Property|Properties|Method|Methods|Field|Fields|Member|Members|Interfaces)\(|Activator\.CreateInstance|MakeGenericType|MakeGenericMethod|Type\.GetType\(|\.InvokeMember\(')
+  if [ -n "$reflection" ] && ! { [ -n "$aotlog" ] && grep -q "Generating native code" "$aotlog"; }; then
+    block "the branch adds reflection to a project that declares AOT or trim support (${aotdecl% }), and no --aot-log shows an AOT publish"
+    printf '%s\n' "$reflection" | sed 's/^/    /'
+  fi
+fi
+
 # Absolutes in added prose are the claims a maintainer can falsify in one grep.
 claims=$(git diff -U0 "$base..HEAD" -- '*.md' '*.mdx' '*.rst' '*.txt' 2>/dev/null \
   | grep '^+' | grep -v '^+++' | sed 's/^+//' \

{housebroken_cli-0.6.8 → housebroken_cli-0.6.9}/scripts/review.sh

@@ -180,6 +180,11 @@ EOF
     printf -- '- context from the author, to attack rather than trust: %s\n' "$t"
   done
 
+  local blind="$home/reviews/blind-${repo%%/*}-${repo##*/}-$key.diff"
+  if [ -n "$clone" ]; then
+    printf '\n0. Before you read the diff, fix it yourself.\n'
+    printf '   Read only the problem: the issue or the description of the bug, and the code at %s. In a copy of the clone at that commit, write the fix you would send, with its test, and save it as a diff to %s. Only then read the change under review and compare. A design that differs from yours in where it fixes the problem, what it recomputes or what it can break is a finding: SHOULD FIX when yours is better, with both versions side by side. The point is the design you reach without the author'"'"'s anchoring it; a maintainer reads the bug, not our diff, and writes their own.\n' "${mb:-the base}" "$blind"
+  fi
   printf '\nAttack at least\n'
   printf '1. Every claim the text makes, re-derived now against the exact revision it names.\n'
   for t in ${texts[@]+"${texts[@]}"}; do
@@ -194,9 +199,15 @@ EOF
 6. Prior art: nothing duplicates an open pull request or argues with a ruling in a closed issue.
 7. The text: it leads with the fact; no verdict on the reviewer, no thanks, apology or offer of help; a reply runs one to three sentences and a body stays under 120 words; no footer, trailer or typographic dash; every sentence is true as literally worded.
 8. Anything else that would embarrass the author in front of this maintainer.
-
-Report
 EOF
+  if [ -n "$clone" ]; then
+    cat <<'EOF'
+9. Where the information is lost: trace every value the change uses back to the last place its type, comparer or source was known. A change that recomputes what a caller already had (a second lookup, a second enumeration, reflection to recover a type the generic code knew, a default comparer standing in for the caller's) fixes the symptom where it surfaced, not where it began. That is SHOULD FIX, with the version that carries the caller's result forward.
+10. Inputs the project already tests: list the input shapes the test files beside the changed code use, such as custom comparers, culture, single-use or lazy sequences, null, empty, very large, concurrent callers. Every shape the changed code can receive that the new tests leave out is a finding; run the change on it.
+11. What the project promises to run on: read the manifests and CI matrix for AOT, trimming, no_std, wasm, minimum language or runtime versions, and every platform leg. Run the changed path in each mode the project promises, not only the default build; a clean build is not a run. A suppression the change adds has to be shown covering a warning that fires.
+EOF
+  fi
+  printf '\nReport\n'
   printf 'Write it to %s. It must start with exactly these lines, with the verdict filled in:\n\n' "$report"
   printf 'review-of: %s\n' "$repo"
   [ -n "$head" ] && printf 'head: %s\n' "$head"
@@ -204,6 +215,7 @@ EOF
     printf 'text: sha256:%s %s\n' "$(sha256 "$t")" "$(basename "$t")"
   done
   printf 'author-model: %s\nreviewer-model: %s\n' "$author" "$reviewer"
+  [ -n "$head" ] && printf 'blind-fix: %s\n' "$blind"
   printf 'verdict: POST AS IS | POST WITH CHANGES | DO NOT POST\n\n'
   cat <<'EOF'
 POST AS IS means nothing BLOCKING or SHOULD FIX remains. POST WITH CHANGES means the author fixes what you found and the fixed version comes back for another review. DO NOT POST means it should not go at all. After the header, number your findings, each with a severity (BLOCKING, SHOULD FIX or NIT), the evidence, and the exact fix, with replacement text in full for any wording. A report with no findings says what was checked and how.
@@ -242,6 +254,15 @@ cmd_check() {
   [ "$verdict" = "POST AS IS" ] ||
     refuse "the verdict is '${verdict:-missing}' and only POST AS IS clears the gate: fix what the review found and review the new version"
 
+  # A reviewer that read our diff first critiques our design; shouldly #1335
+  # went out with a fix the maintainer replaced, because nobody wrote another.
+  if [ -n "$head" ]; then
+    local blind
+    blind=$(field blind-fix)
+    [ -n "$blind" ] || refuse "$report reviews code at ${head:0:12} and names no blind-fix: the reviewer's own fix, written before reading ours"
+    [ -f "$blind" ] || refuse "the blind fix $blind named in $report does not exist"
+  fi
+
   if [ -n "$clone" ]; then
     now=$(git -C "$clone" rev-parse HEAD 2>/dev/null) || bad_usage "$clone is not a git clone"
     [ -n "$head" ] || refuse "$report records no head, so it cannot clear a branch"

{housebroken_cli-0.6.8 → housebroken_cli-0.6.9}/skills/housebroken/SKILL.md

@@ -157,8 +157,11 @@ report it in one line and do not proceed to the next step.
    whose mode disagrees with its own siblings, a file the branch adds that the
    repository ignores, a commit carrying a tool trailer, a session link or a
    tool identity, a sign-off that names a username, a branch that is not on
-   top of its base, and any comment added to code (`--asked <URL>` when the
-   maintainer asked for it); it prints every absolute claim your added prose
+   top of its base, any comment added to code (`--asked <URL>` when the
+   maintainer asked for it), a warning suppression the branch adds until
+   `--warning-log` shows each suppressed warning firing, and reflection added
+   to a .NET project that declares AOT or trim support until `--aot-log`
+   shows an AOT publish you ran the changed path under; it prints every absolute claim your added prose
    makes so you can falsify each one against the code, and it stamps the
    head it passed, which the filing requires. Then the adversarial review:
    `housebroken review brief --author <your model> --repo owner/repo --clone <clone> --text <body file>`
@@ -166,7 +169,14 @@ report it in one line and do not proceed to the next step.
    that wrote the change: one tier down, Fable to Opus and Opus to Sonnet,
    and never below Sonnet, so Sonnet's work goes to Opus. Hand the brief to a
    fresh agent running that model; anything of yours it reads is for it to
-   attack, not to trust. It attacks the form as well as the facts: it writes
+   attack, not to trust. Before it reads the diff, it reads only the bug and
+   the code at the base and writes the fix it would send, saved where the
+   brief says; the report names that file, and the gate refuses a code review
+   without it. A maintainer reads the bug, not our diff, and writes their own
+   fix; the reviewer does the same first. It then traces every value the change
+   uses to where its type or comparer was last known, covers the input shapes
+   the neighbouring tests use, and runs the changed path in every mode the
+   project promises to run on. It attacks the form as well as the facts: it writes
    the changed block the way the strongest engineer in that language would,
    and a smaller or clearer version is a finding you fix before filing. It
    writes its report where the brief says, with its own evidence behind

housebroken_cli-0.6.9/src/housebroken/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.6.9"

housebroken_cli-0.6.8/src/housebroken/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.6.8"