🛡️ Sentinel: [MEDIUM] 입력 검증 강화로 정수 오버플로 취약점 수정

[seonghobae]

🚨 심각도: MEDIUM
💡 취약점: aFIPC.R에서 사용자의 입력(readline())을 검증할 때 경계가 없는 정규 표현식(^[0-9]+$)을 사용하여, 지나치게 큰 숫자를 입력할 경우 as.integer()에서 NA로 강제 변환되어 프로그램 크래시나 예상치 못한 예외가 발생할 수 있는 취약점이 존재했습니다.
🎯 영향: 악의적인 사용자가 입력값을 조작하여 DoS나 프로그램 다운을 유발할 수 있습니다.
🔧 수정 사항: 검증 정규 표현식을 ^[12]$로 변경하여 입력값이 정확히 '1' 또는 '2'인지 확인하도록 개선했습니다.
✅ 확인 방법: 패키지 빌드 및 testthat 테스트가 성공적으로 통과되었으며, 매우 큰 숫자가 입력되는 상황을 mockery로 모킹하여 테스트 검증을 완료했습니다.

---

PR created automatically by Jules for task 16022151920352919716 started by @seonghobae

Summary by CodeRabbit

• 버그 수정

  • 대화형 확인 입력이 1 또는 2로만 정확히 제한되어 잘못된 값과 초대형 숫자를 안전하게 처리합니다.

• 테스트

  • 대규모 입력과 다양한 잘못된 입력에 대한 검증 테스트를 추가했습니다.
  • 유효한 입력이 올바르게 처리되는지 자동으로 확인합니다.

• 문서

  • 보안 취약점 예방 및 R 최적화 관련 기록을 최신 내용으로 정리했습니다.

[google-labs-jules]

👋 Jules, reporting for duty! I'm here to lend a hand with this pull request.

When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down.

I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job!

For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with @jules. You can find this option in the Pull Request section of your global Jules UI settings. You can always switch back!

New to Jules? Learn more at jules.google/docs.

---

For security, I will only act on instructions from the user who triggered this task.

[coderabbitai]

📝 Walkthrough

Walkthrough

대화형 확인 입력을 1 또는 2로 제한하고 관련 검증 테스트를 추가했습니다. mockery를 Suggests에 추가하고 테스트 파일을 빌드에서 제외했습니다. 최적화, Palette, 보안 저널 기록도 갱신했습니다.

Changes

입력 검증 및 저널 정리

Layer / File(s)	Summary
대화형 입력 검증 R/aFIPC.R, tests/testthat/test-sentinel-validation.R, DESCRIPTION, .Rbuildignore, .jules/sentinel.md	공통 확인과 BILOG-MG 사전 확인 입력을 1 또는 2로 제한했습니다. 대규모 숫자와 잘못된 입력의 재시도 동작을 테스트했습니다.
R 최적화 저널 갱신 .jules/bolt.md	열 선택, 인덱스 캐싱, 벡터화, 고유값 계산, 논리 인덱싱, mirt 데이터 재사용에 대한 기록을 갱신했습니다.
Palette 저널 갱신 .Jules/palette.md, .jules/palette.md	aFIPC에 프론트엔드 UI가 없다는 내용을 기록하고 Palette 최적화를 건너뛰는 결과를 반영했습니다.

Estimated code review effort: 3 (Moderate) | ~20 minutes

Sequence Diagram(s)

sequenceDiagram
  participant autoFIPC
  participant readline
  participant mirt
  autoFIPC->>readline: 확인 입력 요청
  readline-->>autoFIPC: 입력값 반환
  autoFIPC->>autoFIPC: 1 또는 2 검증
  autoFIPC->>readline: 잘못된 입력이면 재요청
  autoFIPC->>mirt: 유효한 입력으로 모델 처리

Loading

Possibly related PRs

• ContextualWisdomLab/aFIPC#176: 동일한 R/aFIPC.R 입력 검증 취약점 수정과 관련됩니다.
• ContextualWisdomLab/aFIPC#182: readline() 입력을 1 또는 2로 제한하는 변경과 관련됩니다.
• ContextualWisdomLab/aFIPC#202: 동일한 입력 검증 수정과 Sentinel 테스트 범위를 포함합니다.

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	제목은 사용자 입력 검증 강화와 정수 오버플로 취약점 수정이라는 주요 변경 사항을 정확히 설명합니다.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch jules-16022151920352919716-e7a20e97

---

_{Comment @coderabbitai help to get the list of available commands.}

[coderabbitai]

Actionable comments posted: 6

🧹 Nitpick comments (2)

.jules/bolt.md (1)

54-62: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

캐시 재사용의 불변 조건을 명시하세요.

모든 반복에서 동일한 원본 데이터와 동일한 행·열 선택을 사용하는 경우에만 부분집합을 한 번 캐시할 수 있습니다. 반복마다 데이터, 행 필터, 열 목록이 달라지면 캐시된 data frame이 잘못된 mirt 입력을 만듭니다.

다음 조건을 학습 내용에 추가하세요.

수정 예시

-서브셋팅된 데이터프레임을 `mirt::mirt` 호출 전 한 번 변수에 캐시하여 재사용함으로써,
+모든 반복에서 동일한 데이터와 행·열 집합을 사용할 때, 서브셋팅된 데이터프레임을
+`mirt::mirt` 호출 전 한 번 변수에 캐시하여 재사용함으로써,

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In @.jules/bolt.md around lines 54 - 62, Update the “Learning” section to state
that caching and reusing the subset data frame is valid only when every
iteration uses the same source data and identical row and column selections; if
any of these vary, recompute the subset for that iteration to avoid passing
incorrect input to mirt::mirt.

tests/testthat/test-sentinel-validation.R (1)

67-72: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

BILOG-MG 사전 확인 경로를 별도로 테스트하세요.

현재 mod1과 mod2는 mirt 모델 객체입니다. 따라서 autoFIPC()는 데이터프레임 또는 행렬 분기를 건너뛰고 R/aFIPC.R의 checkoldformBILOGprior()와 checknewformBILOGprior()를 실행하지 않습니다. 이 테스트는 사실상 R/aFIPC.R의 Line 144만 검증합니다. itemtype = "3PL"과 두 데이터프레임 입력을 사용하고 두 BILOG prior 인자를 NULL로 둔 테스트를 추가하세요. 초대형 문자열, 비정상 문자열, 유효한 1과 2 입력을 각각 검증해야 합니다. 이 판단은 현재 테스트의 Lines 67-72와 R/aFIPC.R의 Lines 157-186 및 376-405에 근거합니다.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/testthat/test-sentinel-validation.R` around lines 67 - 72, 현재 mirt 객체를
사용하는 테스트는 BILOG prior 검증 경로를 실행하지 않으므로, autoFIPC 테스트에 itemtype이 "3PL"인 두 데이터프레임
입력과 두 BILOG prior 인자를 NULL로 둔 별도 검증을 추가하세요. checkoldformBILOGprior()와
checknewformBILOGprior() 각각에 대해 초대형 문자열, 비정상 문자열, 유효한 1 및 2 입력을 검증하고, 기존 mirt 객체
테스트는 그대로 유지하세요.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In @.jules/bolt.md:
- Around line 1-12: Update the Bolt Journal entry describing intersect(cols,
colnames(df)) to document its duplicate-removal behavior. State that repeated
names in cols produce fewer selected columns than df[cols]; either document that
cols must not contain duplicates or record cols[cols %in% colnames(df)] as the
alternative when duplicates are allowed.
- Around line 44-53: Update the R subsetting guidance to explicitly document the
NA behavior: direct logical indexing and which() are equivalent only when the
condition contains no NA values. State that callers must use which(condition) or
explicit is.na() handling when NA rows must be excluded.
- Around line 34-43: Update the R guidance to distinguish observed non-missing
unique values from factor level counts: use length(na.omit(unique(x))) only for
observed values, and retain nlevels(x) or length(levels(x)) when unused factor
levels must be counted. Clarify that the optimization applies only where these
semantics are equivalent.
- Around line 24-33: Update the complexity explanation in the 2024-07-08
optimization entry to avoid claiming that vectorizing match() universally
guarantees O(N + M). Qualify the statement by input type, data size, and R
version or benchmark results, noting that length-one lookups and list matching
may differ; describe the reliable benefit as reducing repeated scans and
interpreter overhead.
- Around line 13-23: Update the optimization note in the dated entry to remove
the guaranteed O(1) claim for split-based lookups. Describe the upfront cache
construction cost and state that repeated which() scans are avoided afterward;
document the key-conversion behavior and that NA groups are excluded by default,
with [[ lookup returning NULL for NA or missing keys.

In `@tests/testthat/test-sentinel-validation.R`:
- Around line 42-53: Update the test setup around mock_readline to call
testthat::skip_if_not_installed for the optional mockery dependency at the start
of the test. Since mirt is an imported dependency, remove the surrounding
requireNamespace("mirt") conditional and keep the test running directly.

---

Nitpick comments:
In @.jules/bolt.md:
- Around line 54-62: Update the “Learning” section to state that caching and
reusing the subset data frame is valid only when every iteration uses the same
source data and identical row and column selections; if any of these vary,
recompute the subset for that iteration to avoid passing incorrect input to
mirt::mirt.

In `@tests/testthat/test-sentinel-validation.R`:
- Around line 67-72: 현재 mirt 객체를 사용하는 테스트는 BILOG prior 검증 경로를 실행하지 않으므로,
autoFIPC 테스트에 itemtype이 "3PL"인 두 데이터프레임 입력과 두 BILOG prior 인자를 NULL로 둔 별도 검증을
추가하세요. checkoldformBILOGprior()와 checknewformBILOGprior() 각각에 대해 초대형 문자열, 비정상
문자열, 유효한 1 및 2 입력을 검증하고, 기존 mirt 객체 테스트는 그대로 유지하세요.

🪄 Autofix

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro Plus

Run ID: c32cae06-3e9e-46c1-a354-af909e192c1d

📥 Commits

Reviewing files that changed from the base of the PR and between 35e4498 and 8b6e3e5.

📒 Files selected for processing (10)

• .Jules/palette.md
• .Rbuildignore
• .jules/bolt.md
• .jules/palette.md
• .jules/sentinel.md
• DESCRIPTION
• R/aFIPC.R
• test_dummy.R
• test_validation.R
• tests/testthat/test-sentinel-validation.R

💤 Files with no reviewable changes (2)

• test_dummy.R
• test_validation.R

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -eu
cat -n .jules/bolt.md | sed -n '1,20p'
if command -v R >/dev/null 2>&1; then
  R --vanilla --quiet <<'RS'
cols <- c("a", "a", "b", "missing")
names <- c("a", "b")
print(intersect(cols, names))
print(cols[cols %in% names])
df <- data.frame(a = 1:2, b = 3:4, check.names = FALSE)
print(df[cols])
print(ncol(df[cols]))
RS
else
  echo "R not available"
fi

Repository: ContextualWisdomLab/aFIPC

Length of output: 854

---

🌐 Web query:

R base intersect documentation duplicate removal order data frame duplicate column selection semantics

💡 Result:

In R, the base intersect(x, y) function is designed for vector-like objects and operates with specific semantics regarding duplicate removal and element ordering [1][2]. Duplicate Removal: The intersect function implicitly removes all duplicate values from both input vectors before performing the intersection [3][2]. Consequently, the returned vector contains only unique elements that are present in both x and y [3][4]. Order of Results: The order of the elements in the output is determined by their appearance in the first argument, x [3]. The function effectively preserves the relative ordering of common elements as they appear in x [3]. Data Frame Semantics: Base R's intersect is not designed to operate directly on data frames in the way users often expect (i.e., row-wise intersection) [5]. When applied to data frames, it may coerce them or produce unexpected results depending on R version-specific vector-like behavior [1][2]. To perform intersection on data frames based on row equality, you should use the dplyr::intersect function, which specifically expects data frames and performs row-wise intersection with duplicate removal [6][5]. Column Selection Semantics: The intersect function is also used within R's base merge function to determine the columns on which to merge [7]. By default, merge uses intersect(names(x), names(y)) to identify common column names to join by [7]. This usage relates only to column name identification, not the values within the data frame [7]. When merging, if columns not used for merging share names, R automatically appends suffixes (defaulting to.x and.y) to ensure unique column names in the resulting data frame [7]. Summary of Behavior: 1. Base intersect(x, y) acts on vectors, removing duplicates and returning unique common elements in the order of x [1][3]. 2. For data frame row-wise intersection, use dplyr::intersect [5]. 3. The name intersect is also used in merge logic to find common column names, where distinct column names are managed via suffixes to prevent duplicates [7].

Citations:

• 1: https://stat.ethz.ch/R-manual/R-devel/library/base/html/sets.html
• 2: https://rdrr.io/r/base/sets.html
• 3: https://rguides.dev/reference/base-functions/intersect/
• 4: https://runebook.dev/en/docs/r/library/base/html/sets
• 5: https://r-statistics.co/dplyr-intersect-in-R.html
• 6: https://github.com/tidyverse/dplyr/blob/main/R/sets.R
• 7: https://search.r-project.org/R/refmans/base/html/merge.html

---

intersect()의 중복 제거 조건을 문서에 명시하세요.

intersect(cols, colnames(df))는 중복 항목을 제거합니다. 따라서 cols에 동일한 열 이름이 반복되면 df[cols]와 선택되는 열 개수가 달라집니다.

중복 선택을 허용하면 cols[cols %in% colnames(df)]를 사용한다고 기록하세요. 중복을 금지하면 해당 전제를 문서에 추가하세요.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In @.jules/bolt.md around lines 1 - 12, Update the Bolt Journal entry describing
intersect(cols, colnames(df)) to document its duplicate-removal behavior. State
that repeated names in cols produce fewer selected columns than df[cols]; either
document that cols must not contain duplicates or record cols[cols %in%
colnames(df)] as the alternative when duplicates are allowed.

[coderabbitai]

🚀 Performance & Scalability | 🟡 Minor | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -eu
printf '%s\n' '--- file ---'
cat -n .jules/bolt.md | sed -n '1,35p'
printf '%s\n' '--- R availability ---'
if command -v R >/dev/null 2>&1; then
  R --version | head -n 1
else
  echo 'R is not available'
fi
printf '%s\n' '--- split references ---'
rg -n -C 2 'split\\(|which\\(|O\\(1\\)|O\\(N\\)' .jules README.md 2>/dev/null || true

Repository: ContextualWisdomLab/aFIPC

Length of output: 1448

---

🌐 Web query:

R base split documentation split.default factor levels names list lookup complexity named list

💡 Result:

In R, the split function (specifically split.default) divides a vector x into groups based on a factor f [1][2]. The resulting object is a named list where the component names correspond to the levels of the grouping factor [1][2]. Complexity and Implementation Details: The implementation of split.default relies on R's internal.Internal(split(...)) function [3][4][5]. For atomic vectors (where x lacks a class attribute),.Internal(split(x, f)) performs the grouping directly in compiled code [3][5]. This is highly optimized and efficient. For objects with a class attribute, the function uses.Internal(split(seq_along(x), f)) to generate a list of integer indices for each group, followed by lapply(ind, function(i) x[i]) to extract the elements [3][4][5]. The lapply approach generally operates with O(N) complexity relative to the number of elements in x, as it performs indexed subsetting for each group [5]. Named List Lookup: The returned list is named by the levels of the factor f [1][2]. When accessing these components by name (e.g., result[["level_name"]]), R uses its internal hash table lookup for list names, which typically provides average-case O(1) time complexity for individual lookups. Documentation and Behavior: Official documentation specifies that if f is a list, it is converted via interaction [1][6]. If drop is set to TRUE, unused factor levels are removed from the result [1][2]. Because the names of the resulting list are derived directly from the factor levels, users should be aware that if levels contain the separator character (default is "."), it may affect the resulting names or groupings, especially when using lists of factors [1][6]. Top Results: [3], [1], [5], [6], [7]

Citations:

• 1: https://stat.ethz.ch/R-manual/R-devel/library/base/html/split.html
• 2: https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/split
• 3: https://svn.r-project.org/R/trunk/src/library/base/R/split.R
• 4: https://svn.r-project.org/R/branches/R-defs/src/library/base/R/split.R
• 5: https://stackoverflow.com/questions/52158589/what-is-the-algorithm-behind-r-cores-split-function
• 6: https://search.r-project.org/R/refmans/base/html/split.html
• 7: wch/r-source@e687f5b

---

🌐 Web query:

site:stat.ethz.ch/R-manual R split NA values named list [[ NA_character_ NULL

💡 Result:

In R, the behavior of NA values and NULL in named lists depends on the operation being performed. Subsetting with NA: When extracting elements from a list using the [[ operator with an NA index (such as NA_character_), R returns NULL [1]. This is because NA indices do not match any names in the list [1]. Conversely, when using the [ operator, an NA index results in an NA in the corresponding position of the result (for atomic vectors) or NULL for a list [1]. Splitting data: If you are using the split function, any missing values (NA) in the factor used to define the groups are dropped by default, along with the corresponding values in the data being split [2]. NULL objects: NULL is a reserved keyword representing the null object [3]. It is distinct from NA. If you need to set list elements to NULL, remember that assigning NULL to a list index (e.g., x[i] <- NULL) removes the element from the list entirely [1][4]. To set an element to the NULL object while keeping the index, you must assign it as a list: x[i] <- list(NULL) [1][4]. Summary of Key Differences: - NA_character_: A specific type of missing value [5][6]. It is not the same as the string "NA" [4][6]. - NULL: A reserved object representing the absence of a value or an empty pairlist [3]. - Indexing behavior: Using NA as an index in [[ returns NULL [1]. Using NULL as an index is generally not allowed or results in NULL [1][3].

Citations:

• 1: https://stat.ethz.ch/R-manual/R-patched/library/base/html/Extract.html
• 2: https://stat.ethz.ch/R-manual/R-devel/library/base/html/split.html
• 3: https://stat.ethz.ch/R-manual/R-devel/library/base/html/NULL.html
• 4: https://stat.ethz.ch/R-manual/R-patched/doc/manual/R-FAQ.html
• 5: https://stat.ethz.ch/R-manual/R-devel/RHOME/library/base/html/NA.html
• 6: https://www.stat.ethz.ch/R-manual/R-devel/library/base/html/NA.html

---

split() 조회 복잡도의 표현을 수정하세요.

split()은 전체 행을 처리하는 초기 캐시 비용이 있습니다. 이름 기반 list 조회의 O(1) 복잡도는 R 문서가 보장하지 않습니다. 초기 캐시 구축 후 반복적인 which() 선형 검색을 제거한다로 기록하세요. 조회 키의 변환 규칙과 NA 또는 존재하지 않는 키의 동작도 기록하세요. NA 그룹은 기본적으로 제외되며, [[ 조회 결과는 NULL입니다.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In @.jules/bolt.md around lines 13 - 23, Update the optimization note in the
dated entry to remove the guaranteed O(1) claim for split-based lookups.
Describe the upfront cache construction cost and state that repeated which()
scans are avoided afterward; document the key-conversion behavior and that NA
groups are excluded by default, with [[ lookup returning NULL for NA or missing
keys.

[coderabbitai]

🚀 Performance & Scalability | 🟡 Minor | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -eu
printf '%s\n' '--- target file ---'
sed -n '1,80p' .jules/bolt.md
printf '%s\n' '--- R availability ---'
if command -v R >/dev/null 2>&1; then
  R --version | head -n 1
  Rscript -e 'print(match)'
else
  echo 'R is not available'
fi
printf '%s\n' '--- repository references to match complexity guidance ---'
rg -n -i 'match\\(|O\\(N|O\\(N \\+ M|vectoriz' --glob '!node_modules' --glob '!dist' .

Repository: ContextualWisdomLab/aFIPC

Length of output: 2130

---

🌐 Web query:

R base match documentation algorithm complexity list matching slow vectorized match

💡 Result:

The R match function is implemented in C and uses a hashing-based algorithm to perform lookups [1]. By constructing a hash table from the table argument, it achieves efficient lookups, typically with an average time complexity of O(N + M), where N is the length of the table and M is the length of the vector being matched [1]. Why it may seem slow: 1. Hash Table Overhead: Constructing the hash table is a costly upfront operation [2]. If you are performing many small or single-item matches, the time spent building this table can dominate the execution time [3][2]. In newer versions of R, if the vector x in match(x, table) is of length 1, R may optimize by using a simple linear search to avoid the overhead of building the hash table [2]. 2. List Matching: Matching against a list is documented as potentially very slow and should be avoided [4][5]. R will attempt to coerce the list and the target vector to a common type (e.g., character) before matching, which adds significant overhead [4]. 3. Repeated Lookups: The standard match function rebuilds the hash table every time it is called. If you need to perform multiple lookups against the same table, this repeated overhead becomes a performance bottleneck [6]. Tips for improving performance: - Reuse Hash Tables: For repeated matches against the same large table, use the fastmatch package, which provides fmatch. It caches the hash table as an attribute on the table object, making subsequent lookups essentially instantaneous [6]. - Specialized Operators: For character matching, especially when working with data frames, the data.table package offers the %chin% operator, which is highly optimized and often faster than standard matching methods [7]. - Vectorization: match is already vectorized. Avoid writing explicit R-level loops to match elements; let the internal C implementation handle the vector processing [1]. - Joins: If the goal is to associate data rather than just finding indices, consider using joins (e.g., left_join from dplyr or data.table merges), which are often more performant and readable for complex data relationships [7].

Citations:

• 1: https://stat.ethz.ch/pipermail/r-help/2001-November/016670.html
• 2: https://stackoverflow.com/questions/31090075/different-execution-times-for-matching-element
• 3: https://stackoverflow.com/questions/24923071/why-is-the-r-match-function-so-slow
• 4: https://stat.ethz.ch/R-manual/R-devel/RHOME/library/base/html/match.html
• 5: https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/match
• 6: https://search.r-project.org/CRAN/refmans/fastmatch/html/fmatch.html
• 7: https://runebook.dev/en/docs/r/library/base/html/mtfrm

---

🌐 Web query:

site:stat.ethz.ch/R-manual/R-devel/library/base/html/match.html match lists potentially very slow hashing algorithm

💡 Result:

The statement that "match lists [are] potentially very slow" is not a reference to a hashing algorithm, but rather a warning from the R programming language documentation [1]. Specifically, the R manual for the match function notes that performing matching operations on lists can be computationally expensive and recommends avoiding it in complex scenarios [1]. In the context of computer science and cybersecurity, hashing algorithms used for password storage (such as Argon2, bcrypt, or scrypt) are intentionally designed to be "slow" to compute. This deliberate slowness, often referred to as being "work-factor" or "cost-factor" intensive, is intended to defend against brute-force and dictionary attacks by making each individual password verification computationally expensive for an attacker. These are entirely distinct from the list-matching operations found in data processing languages like R [1].

Citations:

• 1: https://stat.ethz.ch/R-manual/R-devel/library/base/html/match.html

---

match()의 복잡도 설명을 조건부로 수정하세요.

match()는 x 벡터를 한 번에 처리하므로 루프 내부의 반복 호출을 제거할 수 있습니다. 그러나 모든 입력에서 O(N + M)을 보장하지는 않습니다. 길이 1 조회는 선형 검색을 사용할 수 있고, list 매칭은 느릴 수 있습니다. 복잡도 주장을 실제 입력 유형, 데이터 크기, R 버전의 벤치마크 결과로 제한하고, 반복 호출과 인터프리터 오버헤드를 줄인다고 표현하세요.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In @.jules/bolt.md around lines 24 - 33, Update the complexity explanation in
the 2024-07-08 optimization entry to avoid claiming that vectorizing match()
universally guarantees O(N + M). Qualify the statement by input type, data size,
and R version or benchmark results, noting that length-one lookups and list
matching may differ; describe the reliable benefit as reducing repeated scans
and interpreter overhead.

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -eu
printf '%s\n' '--- target file ---'
cat -n .jules/bolt.md | sed -n '25,50p'
printf '%s\n' '--- related R expressions and documentation references ---'
rg -n -C 2 'levels\(as\.factor|unique\(na\.omit|nlevels|관측된|고유값' . --glob '!node_modules' --glob '!dist' --glob '!build' || true
printf '%s\n' '--- available R runtime ---'
if command -v R >/dev/null 2>&1; then
  R --version | head -n 1
  R --vanilla --slave <<'RS'
x <- factor(c("a", "a", NA), levels = c("a", "b"))
cat("factor levels:", length(levels(as.factor(x))), "\n")
cat("observed non-NA unique values:", length(unique(na.omit(x))), "\n")
cat("nlevels:", nlevels(x), "\n")
RS
else
  echo 'R is not available'
fi

Repository: ContextualWisdomLab/aFIPC

Length of output: 2682

---

🏁 Script executed:

#!/bin/bash
set -eu
printf '%s\n' '--- audited equivalence test ---'
cat -n tests/testthat/test-optimization-equivalence.R | sed -n '1,75p'
printf '%s\n' '--- calibration documentation context ---'
cat -n docs/fixed-parameter-item-calibration.md | sed -n '45,70p'
printf '%s\n' '--- all usages of the legacy and replacement idioms ---'
rg -n -C 4 'length\(levels\(as\.factor|length\((na\.omit\(unique|unique\(na\.omit)' . --glob '!node_modules' --glob '!dist' --glob '!build'

Repository: ContextualWisdomLab/aFIPC

Length of output: 8682

---

팩터 level 수와 관측된 고유값 수를 구분하세요.

x가 사용되지 않은 level을 가진 factor일 수 있으면 두 표현식의 결과가 다릅니다. 현재 동등성 검사는 숫자형 벡터만 포함합니다. 관측된 비결측 고유값 수가 필요할 때만 length(na.omit(unique(x)))를 사용하고, factor level 수가 필요하면 nlevels(x) 또는 length(levels(x))를 유지하세요.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In @.jules/bolt.md around lines 34 - 43, Update the R guidance to distinguish
observed non-missing unique values from factor level counts: use
length(na.omit(unique(x))) only for observed values, and retain nlevels(x) or
length(levels(x)) when unused factor levels must be counted. Clarify that the
optimization applies only where these semantics are equivalent.

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

sed -n '35,60p' .jules/bolt.md
command -v R || true

Repository: ContextualWisdomLab/aFIPC

Length of output: 841

---

🌐 Web query:

R data frame logical indexing NA rows which NA behavior official documentation

💡 Result:

In R, the behavior of NA values during logical indexing depends on whether you use the standard extraction operator [ or the subset() function [1][2]. 1. Standard Logical Indexing ([): When you use a logical vector to subset a data frame (e.g., df[df$col > 5, ]), any NA values in the logical vector result in an NA row being returned [3][4]. Specifically, for every position where the index is NA, R returns a row containing NAs for all columns [3][5]. This occurs because NA in an index is treated as an "unknown" element, and R preserves that unknown status by returning NA in the output [3][4]. 2. The subset() Function: In contrast, the subset() function treats missing values in the logical condition as FALSE [1][6]. Consequently, rows corresponding to NA values in the condition are excluded from the output rather than resulting in rows of NA values [1][2]. Official documentation clarifies that for standard extraction, NA indices pick an "unknown element" and return NA in the result [3][5]. If you wish to achieve the subset() behavior using the [ operator, you must explicitly exclude missing values, for example by using df[!is.na(df$col) & df$col > 5, ] [1].

Citations:

• 1: https://stat.ethz.ch/R-manual/R-devel/library/base/html/subset.html
• 2: https://stat.ethz.ch/pipermail/r-help/2022-February/473861.html
• 3: https://stat.ethz.ch/R-manual/R-devel/RHOME/library/base/html/Extract.html
• 4: https://adv-r.hadley.nz/subsetting
• 5: https://rdrr.io/r/base/Extract.html
• 6: https://rdrr.io/r/base/subset.html

---

NA 처리 조건을 명시하세요.

조건 벡터에 NA가 없을 때만 논리 인덱싱과 which()의 결과가 동일합니다. which()는 NA를 제외하지만, df[조건, ]은 해당 위치에 NA 행을 반환할 수 있습니다. NA를 제외해야 하면 which(조건) 또는 명시적인 is.na() 처리를 사용한다고 기록하세요.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In @.jules/bolt.md around lines 44 - 53, Update the R subsetting guidance to
explicitly document the NA behavior: direct logical indexing and which() are
equivalent only when the condition contains no NA values. State that callers
must use which(condition) or explicit is.na() handling when NA rows must be
excluded.

[coderabbitai]

📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -eu

printf '%s\n' '--- candidate files ---'
git ls-files | rg '(^|/)(DESCRIPTION|test-sentinel-validation\.R|test-package-api\.R|aFIPC\.R)$'

printf '%s\n' '--- DESCRIPTION dependencies ---'
desc=$(git ls-files | rg '(^|/)DESCRIPTION$' | head -n1)
cat -n "$desc" | sed -n '1,80p'

printf '%s\n' '--- sentinel test ---'
test_file=$(git ls-files | rg '(^|/)test-sentinel-validation\.R$' | head -n1)
cat -n "$test_file" | sed -n '1,150p'

printf '%s\n' '--- optional-dependency test patterns ---'
api_file=$(git ls-files | rg '(^|/)test-package-api\.R$' | head -n1)
rg -n -C 4 'skip_if_not_installed|requireNamespace|mockery|mirt' "$api_file" "$test_file"

printf '%s\n' '--- relevant production call sites ---'
r_file=$(git ls-files | rg '(^|/)aFIPC\.R$' | head -n1)
rg -n -C 8 'readline|interactive|mirt|data\.frame|dataframe' "$r_file"

Repository: ContextualWisdomLab/aFIPC

Length of output: 38402

---

🏁 Script executed:

#!/bin/bash
set -eu

test_file=$(git ls-files | rg '(^|/)test-sentinel-validation\.R$' | head -n1)
r_file=$(git ls-files | rg '(^|/)aFIPC\.R$' | head -n1)

printf '%s\n' '--- test structure and assertions ---'
ast-grep outline "$test_file" --lang r 2>/dev/null || true
rg -n -C 6 'test_that|expect_|skip|autoFIPC|mirt' "$test_file"

printf '%s\n' '--- complete relevant production function regions ---'
cat -n "$r_file" | sed -n '130,215p'
cat -n "$r_file" | sed -n '360,420p'

printf '%s\n' '--- all testthat skip patterns ---'
rg -n -C 3 'skip_if_not_installed|requireNamespace\(' tests 2>/dev/null || true

printf '%s\n' '--- CI dependency installation ---'
git ls-files | rg '(^|/)(\.github/|.*CI.*|.*[Cc]i.*|.*[Ww]orkflow.*)' | head -80
rg -n -C 4 'RSPM|r-lib/actions|install2|install_deps|dependencies|Suggests|mockery|mirt' .github DESCRIPTION 2>/dev/null || true

Repository: ContextualWisdomLab/aFIPC

Length of output: 14540

---

🏁 Script executed:

#!/bin/bash
set -eu

printf '%s\n' '--- R workflow ---'
cat -n .github/workflows/r.yml | sed -n '1,80p'

printf '%s\n' '--- read-only invariant check for the reviewed test ---'
python3 - <<'PY'
from pathlib import Path
p = Path("tests/testthat/test-sentinel-validation.R")
s = p.read_text()
start = s.index('test_that("autoFIPC handles extremely large inputs')
end = s.index('\n})', start) + 3
block = s[start:end]
checks = {
    "mockery is used before any skip guard": (
        block.find("mockery::mock(") >= 0
        and (block.find("mockery::mock(") < block.find("skip_if_not_installed"))
    ),
    "mirt is conditionally guarded rather than skipped": (
        'if (requireNamespace("mirt", quietly = TRUE))' in block
        and "skip_if_not_installed" not in block
    ),
    "the assertion is nested in the mirt condition": (
        block.find("expect_equal(length(mockery::mock_calls") >
        block.find('if (requireNamespace("mirt", quietly = TRUE))')
    ),
}
for name, value in checks.items():
    print(f"{name}: {value}")
if not all(checks.values()):
    raise SystemExit("unexpected test shape")
PY

printf '%s\n' '--- dependency declarations and workflow dependency mode ---'
python3 - <<'PY'
from pathlib import Path
desc = Path("DESCRIPTION").read_text()
workflow = Path(".github/workflows/r.yml").read_text()
print("mockery in Suggests:", "mockery" in desc.split("Suggests:", 1)[1].splitlines()[0])
print("mirt in Imports:", "mirt" in desc.split("Imports:", 1)[1].splitlines()[0])
print("workflow uses setup-r-dependencies:", "setup-r-dependencies@" in workflow)
print("workflow sets needs: check:", "needs: check" in workflow)
PY

Repository: ContextualWisdomLab/aFIPC

Length of output: 1939

---

🌐 Web query:

r-lib/actions setup-r-dependencies needs check installs Suggests dependencies R CMD check

💡 Result:

The r-lib/actions/setup-r-dependencies action is designed to install dependencies for an R package, and its behavior regarding Suggests dependencies during R CMD check is controlled by the dependencies parameter and the R CMD check environment configuration [1][2]. 1. Default Behavior: By default, setup-r-dependencies installs all direct dependencies and their hard dependencies [1]. If you want to include Suggests dependencies, you should ensure the dependencies parameter is set to 'all' (which is the default) [1]. 2. Integration with R CMD check: When running R CMD check (via r-lib/actions/check-r-package), standard behavior is to require Suggests packages for a complete check [3][4]. If you do not want to install these suggested packages—or if you want to ensure your package passes checks without them—you must configure the environment variable _R_CHECK_FORCE_SUGGESTS_ to false [1][3][4]. Example workflow configuration: - uses: r-lib/actions/setup-r-dependencies@v2 with: needs: check - uses: r-lib/actions/check-r-package@v2 env: R_CHECK_FORCE_SUGGESTS: false In this setup, setup-r-dependencies with needs: check will prepare the environment for checking [5], and setting _R_CHECK_FORCE_SUGGESTS_: false ensures that the check does not fail if Suggests packages are missing [1][3]. If your tests or examples explicitly require a suggested package, you should make their execution conditional (e.g., using requireNamespace()) [6][4].

Citations:

• 1: https://github.com/r-lib/actions/tree/v2-branch/setup-r-dependencies
• 2: https://github.com/r-lib/actions/blob/v2-branch/NEWS.md
• 3: https://stat.ethz.ch/pipermail/r-devel/2016-April/072529.html
• 4: https://bookdown.dongzhuoer.com/hadley/r-pkgs/r-cmd-check
• 5: https://github.com/r-lib/actions/blob/v2/examples/README.md
• 6: https://stackoverflow.com/questions/79067855/r-cmd-check-cannot-find-packages-during-package-build-with-r-check-depends-only

---

mockery만 선택적 의존성으로 건너뛰세요.

mockery는 Suggests에 있으므로 이 테스트 시작 부분에 testthat::skip_if_not_installed("mockery")를 추가하세요. mirt는 Imports에 있으므로 별도로 건너뛰지 말고 현재 requireNamespace("mirt") 조건을 제거하세요.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/testthat/test-sentinel-validation.R` around lines 42 - 53, Update the
test setup around mock_readline to call testthat::skip_if_not_installed for the
optional mockery dependency at the start of the test. Since mirt is an imported
dependency, remove the surrounding requireNamespace("mirt") conditional and keep
the test running directly.