#371

AGENTS.md

@@ -125,6 +125,64 @@ npm run preview
 - TypeScript and TSX use 4-space logical indentation.
 - In TypeScript and TSX only, replace every leading run of 8 spaces with a tab.
 - Tabs are only for leading indentation, never for spaces after non-space text.
+- TypeScript and TSX imports may stay on one line if they remain within the
+  line limit; do not expand short type-only imports mechanically.
+- In TypeScript and TSX, when a function takes one destructured object
+  argument plus an inline type, prefer this shape when it fits locally:
+
+```ts
+const helper = (
+    { value, flag }: { value: string
+		       flag:  boolean },
+): Result => {
+  // ...
+}
+```
+
+- In TypeScript and TSX, put `switch` case block braces on their own lines
+  when a case needs a lexical block:
+
+```ts
+case 'yes':
+case 'no':
+  {
+    const expected = valueFor (item)
+    return expected == null || expected === answer
+  }
+```
+
+- In TypeScript and TSX, use `value == null` and `value != null` as the
+  default nullish checks. Do not use `=== null`, `=== undefined`,
+  `!== null`, or `!== undefined`.
+- If code appears to need a distinction between `null` and `undefined`, treat
+  that as a design smell and revise the logic to avoid the distinction.
+  External library APIs that explicitly require distinguishing the two are the
+  only exception.
+- In TypeScript and TSX, keep short arrays on one line when they fit under the
+  line limit; break arrays only when readability or line length requires it.
+- In TypeScript and TSX, when a ternary expression is split across multiple
+  lines, align `?` and `:` with the condition expression. Do not indent `?` and
+  `:` one extra level under the condition.
+
+```ts
+const value =
+    condition
+    ? consequent
+    : alternate
+```
+
+- In TypeScript and TSX, keep short ternary expressions on one line when they
+  fit cleanly under the line limit.
+- In TypeScript and TSX, prefer ternary expressions for simple conditional
+  value selection. Do not replace a clear ternary with `if` statements, and do
+  not introduce immediately invoked functions just to avoid or reformat a
+  ternary expression.
+- In TypeScript and TSX, do not write `let` followed by later `if` assignments
+  when the value can be expressed as a single `const` initializer. Prefer
+  `const` because it prevents accidental later reassignment.
+- When fixing formatting, change formatting only. Do not change expression
+  structure, control flow, or variable mutability unless the requested style
+  explicitly requires it.
 - Do not add production dependencies without explicit approval.
 - Do not create, modify, or run tests unless the user explicitly asks for
   test work. When the user asks for tests, keep working and rerun them until

frontend/src/lib/gekanatorCandidateRecovery.ts

@@ -1,43 +1,33 @@
 import { expectedAnswerForQuestion } from '@/lib/gekanator'
 
-import type {
-    GekanatorAnswerLog,
-    GekanatorAnswerValue,
-    GekanatorQuestion,
-} from '@/lib/gekanator'
+import type { GekanatorAnswerLog, GekanatorAnswerValue, GekanatorQuestion } from '@/lib/gekanator'
 import type { Post } from '@/types'
 
-
 export type RecoveredCandidatePost = {
     postId:                number
     answerCountAtRecovery: number }
 
 
-const questionIsFactLikeForHardFiltering = (
-    question:  GekanatorQuestion,
-): boolean =>
+const questionIsFactLikeForHardFiltering = (question:  GekanatorQuestion): boolean =>
     !(question.kind === 'post_similarity'
-      || (
-	  question.kind === 'tag'
+      || (question.kind === 'tag'
 	  && question.condition.type === 'tag'
 	  && !(question.condition.key.startsWith ('nico:'))))
 
 
-export const candidatePostsFor = ({
-    posts,
-    questions,
-    answers,
-    softenedQuestionIds,
-    rejectedPostIds,
-    recoveredCandidatePosts,
-}: {
-    posts:                   Post[]
-    questions:               GekanatorQuestion[]
-    answers:                 GekanatorAnswerLog[]
-    softenedQuestionIds:     Set<string>
-    rejectedPostIds:         Set<number>
-    recoveredCandidatePosts: Map<number, number>
-}): Post[] => {
+export const candidatePostsFor = (
+    { posts,
+      questions,
+      answers,
+      softenedQuestionIds,
+      rejectedPostIds,
+      recoveredCandidatePosts }: { posts:                   Post[]
+				   questions:               GekanatorQuestion[]
+				   answers:                 GekanatorAnswerLog[]
+				   softenedQuestionIds:     Set<string>
+				   rejectedPostIds:         Set<number>
+				   recoveredCandidatePosts: Map<number, number> },
+): Post[] => {
   const questionById = new Map (questions.map (question => [question.id, question]))
 
   return posts.filter (post => {
@@ -47,7 +37,7 @@ export const candidatePostsFor = ({
     const answerCountAtRecovery = recoveredCandidatePosts.get (post.id)
 
     return answers.every ((answer, index) => {
-      if (answerCountAtRecovery !== undefined && index < answerCountAtRecovery)
+      if (answerCountAtRecovery != null && index < answerCountAtRecovery)
 	return true
 
       if (softenedQuestionIds.has (answer.questionId))
@@ -62,10 +52,11 @@ export const candidatePostsFor = ({
       switch (answer.answer)
       {
       case 'yes':
-      case 'no': {
-	const expected = expectedAnswerForQuestion (question, post)
-	return expected === null || expected === 'unknown' || expected === answer.answer
-      }
+      case 'no':
+	{
+	  const expected = expectedAnswerForQuestion (question, post)
+	  return expected === null || expected === 'unknown' || expected === answer.answer
+	}
       default:
 	return true
       }
@@ -74,15 +65,11 @@ export const candidatePostsFor = ({
 }
 
 
-export const hardFilteredPostsForAnswer = ({
-    posts,
-    question,
-    answer,
-}: {
-    posts:     Post[]
-    question:  GekanatorQuestion
-    answer:    GekanatorAnswerValue
-}): Post[] => {
+export const hardFilteredPostsForAnswer = (
+    { posts, question, answer }: { posts:     Post[]
+				   question:  GekanatorQuestion
+				   answer:    GekanatorAnswerValue },
+): Post[] => {
   if (!(questionIsFactLikeForHardFiltering (question)))
     return posts
 
@@ -91,16 +78,12 @@ export const hardFilteredPostsForAnswer = ({
 
   return posts.filter (post => {
     const expected = expectedAnswerForQuestion (question, post)
-    return expected === null || expected === 'unknown' || expected === answer
+    return expected == null || expected === 'unknown' || expected === answer
   })
 }
 
 
-const concreteAnswerOptions: GekanatorAnswerValue[] = [
-    'yes',
-    'no',
-    'partial',
-    'probably_no']
+const concreteAnswerOptions: GekanatorAnswerValue[] = ['yes', 'no', 'partial', 'probably_no']
 
 
 export const allConcreteAnswerOptionsExhausted = (
@@ -119,45 +102,39 @@ const nextRecoveryTargetSize = (recoveryStepCount: number): number =>
     6 * (2 ** recoveryStepCount)
 
 
-export const recoverCandidatePosts = ({
-    posts,
-    scores,
-    rejectedPostIds,
-    recoveredCandidatePosts,
-    eligiblePostIds,
-    answerCountAtRecovery,
-    recoveryStepCount,
-}: {
-    posts:                   Post[]
-    scores:                  Map<number, number>
-    rejectedPostIds:         Set<number>
-    recoveredCandidatePosts: Map<number, number>
-    eligiblePostIds:         Set<number>
-    answerCountAtRecovery:   number
-    recoveryStepCount:       number
-}): {
-    recoveredCandidatePosts: Map<number, number>
-    recoveryStepCount:       number
-} | null => {
+export const recoverCandidatePosts = (
+    { posts,
+      scores,
+      rejectedPostIds,
+      recoveredCandidatePosts,
+      eligiblePostIds,
+      answerCountAtRecovery,
+      recoveryStepCount }: { posts:                   Post[]
+			     scores:                  Map<number, number>
+			     rejectedPostIds:         Set<number>
+			     recoveredCandidatePosts: Map<number, number>
+			     eligiblePostIds:         Set<number>
+			     answerCountAtRecovery:   number
+			     recoveryStepCount:       number },
+): { recoveredCandidatePosts: Map<number, number>
+     recoveryStepCount:       number } | null => {
   const recovered = new Map (recoveredCandidatePosts)
   const targetSize = nextRecoveryTargetSize (recoveryStepCount)
-  const countedPostIds = new Set ([
-      ...eligiblePostIds,
-      ...recovered.keys ()])
+  const countedPostIds = new Set ([...eligiblePostIds, ...recovered.keys ()])
   const addCount = targetSize - countedPostIds.size
   if (addCount <= 0)
-    return {
-	recoveredCandidatePosts: recovered,
-	recoveryStepCount: recoveryStepCount + 1 }
+    {
+      return { recoveredCandidatePosts: recovered,
+	       recoveryStepCount: recoveryStepCount + 1 }
+    }
 
-  const candidates = posts
-      .filter (post =>
-	  !(rejectedPostIds.has (post.id))
-	  && !(eligiblePostIds.has (post.id))
-	  && !(recovered.has (post.id)))
-      .sort ((a, b) =>
-	  (scores.get (b.id) ?? Number.NEGATIVE_INFINITY)
-	      - (scores.get (a.id) ?? Number.NEGATIVE_INFINITY))
+  const candidates =
+      posts
+      .filter (post => (!(rejectedPostIds.has (post.id))
+			&& !(eligiblePostIds.has (post.id))
+			&& !(recovered.has (post.id))))
+      .sort ((a, b) => ((scores.get (b.id) ?? Number.NEGATIVE_INFINITY)
+			- (scores.get (a.id) ?? Number.NEGATIVE_INFINITY)))
       .slice (0, addCount)
 
   if (candidates.length === 0)
@@ -165,7 +142,6 @@ export const recoverCandidatePosts = ({
 
   candidates.forEach (post => recovered.set (post.id, answerCountAtRecovery))
 
-  return {
-      recoveredCandidatePosts: recovered,
-      recoveryStepCount: recoveryStepCount + 1 }
+  return { recoveredCandidatePosts: recovered,
+	   recoveryStepCount: recoveryStepCount + 1 }
 }