oh-my-opencode 4.4.0 → 4.5.1

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-5/without_skill/outputs/execution-plan.md

@@ -0,0 +1,127 @@
+# Execution Plan: Relax comment-checker hook false positives
+
+## Problem Analysis
+
+The comment-checker hook delegates to an external Go binary (`code-yeongyu/go-claude-code-comment-checker`). The binary:
+1. Detects ALL comments in written/edited code using tree-sitter
+2. Filters out only BDD markers, linter directives, and shebangs
+3. Flags every remaining comment as problematic (exit code 2)
+4. In the output formatter (`formatter.go`), uses `AgentMemoFilter` to categorize comments for display
+
+The `AgentMemoFilter` in `pkg/filters/agent_memo.go` contains the overly aggressive regex:
+```go
+regexp.MustCompile(`(?i)^[\s#/*-]*note:\s*\w`),
+```
+
+This matches ANY comment starting with `Note:` (case-insensitive) followed by a word character, causing legitimate comments like `// Note: Thread-safe implementation` or `// NOTE: See RFC 7231` to be classified as "AGENT MEMO" AI slop with an aggressive warning banner.
+
+Additionally, the binary flags ALL non-filtered comments (not just agent memos), so even without the `Note:` regex, `// Note: ...` comments would still be flagged as generic "COMMENT DETECTED."
+
+## Architecture Understanding
+
+```
+TypeScript (oh-my-opencode)              Go Binary (go-claude-code-comment-checker)
+─────────────────────────────             ──────────────────────────────────────────
+hook.ts                                   main.go
+ ├─ tool.execute.before                    ├─ Read JSON from stdin
+ │   └─ registerPendingCall()              ├─ Detect comments (tree-sitter)
+ └─ tool.execute.after                     ├─ applyFilters (BDD, Directive, Shebang)
+     └─ processWithCli()                   ├─ FormatHookMessage (uses AgentMemoFilter for display)
+         └─ runCommentChecker()            └─ exit 0 (clean) or exit 2 (comments found, message on stderr)
+             └─ spawn binary, pipe JSON
+             └─ read stderr → message
+             └─ append to output
+```
+
+Key files in oh-my-opencode:
+- `src/hooks/comment-checker/hook.ts` - Hook factory, registers before/after handlers
+- `src/hooks/comment-checker/cli-runner.ts` - Orchestrates CLI invocation, semaphore
+- `src/hooks/comment-checker/cli.ts` - Binary resolution, process spawning, timeout handling
+- `src/hooks/comment-checker/types.ts` - PendingCall, CommentInfo types
+- `src/config/schema/comment-checker.ts` - Config schema (currently only `custom_prompt`)
+
+Key files in Go binary:
+- `pkg/filters/agent_memo.go` - Contains the aggressive `note:\s*\w` regex (line 20)
+- `pkg/output/formatter.go` - Uses AgentMemoFilter to add "AGENT MEMO" warnings
+- `cmd/comment-checker/main.go` - Filter pipeline (BDD + Directive + Shebang only)
+
+## Step-by-Step Plan
+
+### Step 1: Create feature branch
+```bash
+git checkout dev
+git pull origin dev
+git checkout -b fix/comment-checker-note-false-positive
+```
+
+### Step 2: Extend CommentCheckerConfigSchema
+**File: `src/config/schema/comment-checker.ts`**
+
+Add `allowed_comment_prefixes` field with sensible defaults. This lets users configure which comment prefixes should be treated as legitimate (not AI slop).
+
+### Step 3: Add a post-processing filter in cli-runner.ts
+**File: `src/hooks/comment-checker/cli-runner.ts`**
+
+After the Go binary returns its result, parse the stderr message to identify and suppress comments that match allowed prefixes. The binary's output contains XML like:
+```xml
+<comments file="/path/to/file.ts">
+  <comment line-number="5">// Note: Thread-safe</comment>
+</comments>
+```
+
+Add a function `filterAllowedComments()` that:
+1. Extracts `<comment>` elements from the message
+2. Checks if the comment text matches any allowed prefix pattern
+3. If ALL flagged comments match allowed patterns, suppress the entire warning
+4. If some comments are legitimate and some aren't, rebuild the message without the legitimate ones
+
+### Step 4: Create dedicated filter module
+**File: `src/hooks/comment-checker/allowed-prefix-filter.ts`** (new)
+
+Extract the filtering logic into its own module per the 200 LOC / single-responsibility rule.
+
+### Step 5: Pass allowed_comment_prefixes through the hook chain
+**File: `src/hooks/comment-checker/hook.ts`**
+
+Thread the `allowed_comment_prefixes` config from `createCommentCheckerHooks()` down to `processWithCli()` and `processApplyPatchEditsWithCli()`.
+
+### Step 6: Add test cases
+**File: `src/hooks/comment-checker/allowed-prefix-filter.test.ts`** (new)
+
+Test cases covering:
+- `// Note: Thread-safe implementation` - should NOT be flagged (false positive)
+- `// NOTE: See RFC 7231 for details` - should NOT be flagged
+- `// Note: changed from X to Y` - SHOULD still be flagged (genuine AI slop)
+- `// TODO: implement caching` - should NOT be flagged
+- `// FIXME: race condition` - should NOT be flagged
+- `// HACK: workaround for upstream bug` - should NOT be flagged
+- `// Added new validation logic` - SHOULD be flagged
+- Custom allowed patterns from config
+
+**File: `src/hooks/comment-checker/cli-runner.test.ts`** (new or extend cli.test.ts)
+
+Integration-level tests for the post-processing pipeline.
+
+### Step 7: Verify
+```bash
+bun test src/hooks/comment-checker/
+bun run typecheck
+```
+
+### Step 8: Commit and push
+```bash
+git add -A
+git commit -m "fix(comment-checker): add allowed-prefix filter to reduce false positives on Note: comments"
+git push -u origin fix/comment-checker-note-false-positive
+```
+
+### Step 9: Create PR
+```bash
+gh pr create --title "fix(comment-checker): reduce false positives for legitimate Note: comments" --body-file /tmp/pr-body.md --base dev
+```
+
+### Step 10 (Follow-up): Upstream Go binary fix
+File an issue or PR on `code-yeongyu/go-claude-code-comment-checker` to:
+1. Relax `(?i)^[\s#/*-]*note:\s*\w` to be more specific (e.g., `note:\s*(changed|modified|updated|added|removed|implemented|refactored)`)
+2. Add a dedicated `LegitimateCommentFilter` to the filter pipeline in `main.go`
+3. Support `--allow-prefix` CLI flag for external configuration

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-5/without_skill/outputs/pr-description.md

@@ -0,0 +1,42 @@
+## Summary
+
+- Add `allowed_comment_prefixes` config to `CommentCheckerConfigSchema` with sensible defaults (Note:, TODO:, FIXME:, HACK:, WARNING:, etc.)
+- Add post-processing filter in `allowed-prefix-filter.ts` that suppresses false positives from the Go binary's output before appending to tool output
+- Add 11 test cases covering false positive scenarios (Note:, TODO:, FIXME:, case-insensitivity, mixed comments, agent memo header suppression)
+
+## Problem
+
+The comment-checker hook's upstream Go binary (`go-claude-code-comment-checker`) flags ALL non-filtered comments as problematic. Its `AgentMemoFilter` regex `(?i)^[\s#/*-]*note:\s*\w` classifies any `Note:` comment as AI-generated "agent memo" slop, triggering an aggressive warning banner.
+
+This causes false positives for legitimate, widely-used comment patterns:
+```typescript
+// Note: Thread-safe implementation required due to concurrent access
+// NOTE: See RFC 7231 section 6.5.4 for 404 semantics
+// Note: This timeout matches the upstream service SLA
+```
+
+These are standard engineering documentation patterns, not AI slop.
+
+## Solution
+
+Rather than waiting for an upstream binary fix, this PR adds a configurable **post-processing filter** on the TypeScript side:
+
+1. **Config**: `comment_checker.allowed_comment_prefixes` - array of case-insensitive prefixes (defaults: `note:`, `todo:`, `fixme:`, `hack:`, `warning:`, `important:`, `bug:`, etc.)
+2. **Filter**: After the Go binary returns flagged comments, `filterAllowedComments()` parses the XML output and suppresses comments matching allowed prefixes
+3. **Behavior**: If ALL flagged comments are legitimate → suppress entire warning. If mixed → remove only the legitimate entries from the XML, keep the warning for actual slop.
+
+Users can customize via config:
+```jsonc
+{
+  "comment_checker": {
+    "allowed_comment_prefixes": ["note:", "todo:", "fixme:", "custom-prefix:"]
+  }
+}
+```
+
+## Test Plan
+
+- 11 new test cases in `allowed-prefix-filter.test.ts`
+- Updated assertion in `hook.apply-patch.test.ts` for new parameter
+- `bun test src/hooks/comment-checker/` passes
+- `bun run typecheck` clean

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-5/without_skill/outputs/verification-strategy.md

@@ -0,0 +1,120 @@
+# Verification Strategy
+
+## 1. Unit Tests
+
+### New test file: `allowed-prefix-filter.test.ts`
+Run: `bun test src/hooks/comment-checker/allowed-prefix-filter.test.ts`
+
+| # | Scenario | Input | Expected |
+|---|----------|-------|----------|
+| 1 | Only Note: comments (default prefixes) | `// Note: Thread-safe`, `// NOTE: See RFC` | `hasRemainingComments: false`, empty message |
+| 2 | Only TODO/FIXME/HACK (default prefixes) | `// TODO: impl`, `// FIXME: race`, `# HACK: workaround` | Suppressed |
+| 3 | Only AI slop comments | `// Added validation`, `// Refactored for perf` | Full message preserved |
+| 4 | Mixed legitimate + slop | `// Note: Thread-safe`, `// Changed from old to new` | Message kept, Note: entry removed from XML |
+| 5 | Case-insensitive Note: | `// note: lowercase test` | Suppressed |
+| 6 | Hash-prefixed comments | `# Note: Python`, `# TODO: something` | Suppressed (prefix stripped before matching) |
+| 7 | Security: prefix | `// Security: validate input` | Suppressed |
+| 8 | Warning: prefix | `// WARNING: mutates input` | Suppressed |
+| 9 | Empty allowed prefixes | `// Note: should pass through` | Full message preserved (no filtering) |
+| 10 | Custom prefix | `// PERF: O(n log n)` with `["perf:"]` | Suppressed |
+| 11 | Agent memo header + Note: | Full agent memo banner + `// Note: Thread-safe` | Entire message suppressed including banner |
+
+### Existing test: `hook.apply-patch.test.ts`
+Run: `bun test src/hooks/comment-checker/hook.apply-patch.test.ts`
+
+Verify the updated mock assertion accepts the new `allowedPrefixes` array parameter.
+
+### Existing test: `cli.test.ts`
+Run: `bun test src/hooks/comment-checker/cli.test.ts`
+
+Verify no regressions in binary spawning, timeout, and semaphore logic.
+
+## 2. Type Checking
+
+```bash
+bun run typecheck
+```
+
+Verify:
+- `CommentCheckerConfigSchema` change propagates correctly to `CommentCheckerConfig` type
+- All call sites in `hook.ts` and `cli-runner.ts` pass the new parameter
+- `filterAllowedComments` return type matches usage in `cli-runner.ts`
+- No new type errors introduced
+
+## 3. LSP Diagnostics
+
+```bash
+# Check all changed files for errors
+lsp_diagnostics src/config/schema/comment-checker.ts
+lsp_diagnostics src/hooks/comment-checker/allowed-prefix-filter.ts
+lsp_diagnostics src/hooks/comment-checker/cli-runner.ts
+lsp_diagnostics src/hooks/comment-checker/hook.ts
+lsp_diagnostics src/hooks/comment-checker/allowed-prefix-filter.test.ts
+```
+
+## 4. Full Test Suite
+
+```bash
+bun test src/hooks/comment-checker/
+```
+
+All 4 test files should pass:
+- `cli.test.ts` (existing - no regressions)
+- `pending-calls.test.ts` (existing - no regressions)
+- `hook.apply-patch.test.ts` (modified assertion)
+- `allowed-prefix-filter.test.ts` (new - all 11 cases)
+
+## 5. Build Verification
+
+```bash
+bun run build
+```
+
+Ensure the new module is properly bundled and exported.
+
+## 6. Integration Verification (Manual)
+
+If binary is available locally:
+
+```bash
+# Test with a file containing Note: comment
+echo '{"session_id":"test","tool_name":"Write","transcript_path":"","cwd":"/tmp","hook_event_name":"PostToolUse","tool_input":{"file_path":"/tmp/test.ts","content":"// Note: Thread-safe implementation\nconst x = 1"}}' | ~/.cache/oh-my-opencode/bin/comment-checker check
+echo "Exit code: $?"
+```
+
+Expected: Binary returns exit 2 (comment detected), but the TypeScript post-filter should suppress it.
+
+## 7. Config Validation
+
+Test that config changes work:
+
+```jsonc
+// .opencode/oh-my-opencode.jsonc
+{
+  "comment_checker": {
+    // Override: only allow Note: and TODO:
+    "allowed_comment_prefixes": ["note:", "todo:"]
+  }
+}
+```
+
+Verify Zod schema accepts the config and defaults are applied when field is omitted.
+
+## 8. Regression Checks
+
+Verify the following still work correctly:
+- AI slop comments (`// Added new feature`, `// Refactored for performance`) are still flagged
+- BDD comments (`// given`, `// when`, `// then`) are still allowed (binary-side filter)
+- Linter directives (`// eslint-disable`, `// @ts-ignore`) are still allowed (binary-side filter)
+- Shebangs (`#!/usr/bin/env node`) are still allowed (binary-side filter)
+- `custom_prompt` config still works
+- Semaphore prevents concurrent comment-checker runs
+- Timeout handling (30s) still works
+
+## 9. Edge Cases to Watch
+
+- Empty message from binary (exit code 0) - filter should be no-op
+- Binary not available - hook gracefully degrades (existing behavior)
+- Message with no `<comment>` XML elements - filter passes through
+- Very long messages with many comments - regex performance
+- Comments containing XML-special characters (`<`, `>`, `&`) in text

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-5/without_skill/timing.json

@@ -0,0 +1 @@
+{"total_tokens": null, "duration_ms": 399000, "total_duration_seconds": 399}