@tduyng/pi-harness-loop 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tduyng/pi-harness-loop",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Reads what the session repeated, proposes the harness part that would have prevented it, and records the lesson that transfers.",
   "keywords": [
     "pi",

package/src/check.ts

@@ -1,13 +1,10 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 
-import { createLocalBashOperations } from '@earendil-works/pi-coding-agent'
+import { createLocalBashOperations, truncateTail } from '@earendil-works/pi-coding-agent'
 import { Validator } from 'ata-validator'
 import { t } from 'ata-validator/t'
 
-
-import { runCheck as runSharedCheck, type ExecFn } from '../../pi-goal/src/check.js'
-
 export interface CheckResult {
     command: string
     ok: boolean
@@ -22,6 +19,13 @@ const PackageJson = t.object({
 })
 const isPackageJson = new Validator(PackageJson).isValidObject
 
+const TEST_BY_LOCKFILE = [
+    ['bun.lock', 'bun run test'],
+    ['bun.lockb', 'bun run test'],
+    ['pnpm-lock.yaml', 'pnpm test'],
+    ['yarn.lock', 'yarn test']
+] as const satisfies readonly (readonly [string, string])[]
+
 function packageTest(cwd: string): string {
     const path = join(cwd, 'package.json')
     if (!existsSync(path)) return ''
@@ -33,7 +37,8 @@ function packageTest(cwd: string): string {
     }
     if (!isPackageJson(parsed)) return ''
     if (parsed.scripts?.['test'] === undefined) return ''
-    return existsSync(join(cwd, 'pnpm-lock.yaml')) ? 'pnpm test' : 'npm test'
+    const lockfile = TEST_BY_LOCKFILE.find(([file]) => existsSync(join(cwd, file)))
+    return lockfile?.[1] ?? 'npm test'
 }
 
 function justTest(cwd: string): string {
@@ -54,14 +59,59 @@ export function failedCount(output: string): number | null {
     return generic?.[1] === undefined ? null : Number(generic[1])
 }
 
-const localExec: ExecFn = (command, cwd, options) => createLocalBashOperations().exec(command, cwd, options)
+export function failureNames(output: string): string[] | null {
+    const names = [...output.matchAll(/^\s*(?:\(fail\)|✕|×|✗)\s+(.+)$/gm)]
+        .map((match) => (match[1] ?? '').trim())
+        .filter((name) => name !== '')
+    if (names.length > 0) return names.toSorted()
+    return failedCount(output) === 0 ? [] : null
+}
+
+const MAX_CHECK_OUTPUT_BYTES = 1500
+const DEFAULT_CHECK_TIMEOUT_MS = 300_000
+
+async function runSharedCheck(
+    cwd: string,
+    command: string,
+    options: { timeoutMs?: number } = {}
+): Promise<{ ok: boolean; exitCode: number | null; durationMs: number; output: string }> {
+    const timeoutMs = options.timeoutMs && options.timeoutMs > 0 ? options.timeoutMs : DEFAULT_CHECK_TIMEOUT_MS
+    let captured = Buffer.alloc(0)
+    const started = Date.now()
+    const finish = (exitCode: number | null, error?: string) => {
+        const durationMs = Date.now() - started
+        const output = captured.toString('utf8')
+        const body = error ? `${output}${output ? '\n' : ''}${error}` : output
+        const tail = truncateTail(body, { maxBytes: MAX_CHECK_OUTPUT_BYTES })
+        return {
+            ok: exitCode === 0,
+            exitCode,
+            durationMs,
+            output: tail.content.trim()
+        }
+    }
+    let exitCode: number | null
+    try {
+        ;({ exitCode } = await createLocalBashOperations().exec(command, cwd, {
+            onData: (data) => {
+                const combined = Buffer.concat([captured, data])
+                captured = combined.subarray(Math.max(0, combined.length - MAX_CHECK_OUTPUT_BYTES))
+            },
+            timeout: timeoutMs / 1000
+        }))
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        return finish(null, message)
+    }
+    return finish(exitCode)
+}
 
 export async function runCheck(
     cwd: string,
     command: string,
     options: { timeoutMs?: number } = {}
 ): Promise<CheckResult> {
-    const result = await runSharedCheck(localExec, cwd, command, options)
+    const result = await runSharedCheck(cwd, command, options)
     return {
         command,
         ok: result.ok,

package/src/diversity.ts

@@ -9,7 +9,7 @@ export interface ProposalText {
 export function proposalTexts(harnessDir: string): ProposalText[] {
     if (!existsSync(harnessDir)) return []
     const out: ProposalText[] = []
-    for (const name of readdirSync(harnessDir)) {
+    for (const name of readdirSync(harnessDir).toSorted()) {
         const dir = join(harnessDir, name)
         let entries: string[]
         try {

package/src/install.ts

@@ -4,7 +4,7 @@ import { dirname, join } from 'node:path'
 
 import { applyProposal, readProposal, revertApplied } from './apply.js'
 import { readScan } from './auto.js'
-import { discoverCheck, runCheck } from './check.js'
+import { discoverCheck, failureNames, runCheck } from './check.js'
 import { runReplay } from './replay.js'
 import { acquireLock, appendInstall, readInstalls, readSettings } from './store.js'
 import { loadHarness } from './tree.js'
@@ -270,15 +270,26 @@ async function installLocked(
         key: options.key,
         cost: advertisedChars(applied)
     }
-    if (check === '') return finalize(cwd, dir, install, context, `${refusal}, installed without a check`, options.command)
+    if (check === '')
+        return finalize(cwd, dir, install, context, `${refusal}, installed without a check`, options.command)
 
     const result = await runCheck(cwd, check)
     if (result.ok) return finalize(cwd, dir, install, context, refusal, options.command)
 
     revertApplied(applied, installRoots(context), true)
     const baseline = await runCheck(cwd, check)
+    const resultNames = failureNames(result.output)
+    const baselineNames = failureNames(baseline.output)
+    const sameFailure =
+        result.output === baseline.output ||
+        (resultNames !== null && baselineNames !== null && resultNames.every((name) => baselineNames.includes(name)))
     const innocent =
-        !baseline.ok && baseline.failures !== null && result.failures !== null && result.failures <= baseline.failures
+        !baseline.ok &&
+        result.failures !== null &&
+        result.failures > 0 &&
+        baseline.failures !== null &&
+        result.failures <= baseline.failures &&
+        sameFailure
     if (innocent) {
         for (const file of applied) {
             mkdirSync(dirname(file.to), { recursive: true })

package/src/store.ts

@@ -1,10 +1,10 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { randomUUID } from 'node:crypto'
 import { dirname, join } from 'node:path'
 
 import { Validator } from 'ata-validator'
 import { t } from 'ata-validator/t'
 
-
 import { writeFileAtomic } from './atomic.js'
 import type { HarnessSettings, Install, Lesson } from './types.js'
 
@@ -243,9 +243,10 @@ const LOCK_STALE_MS = 5 * 60_000
 export function acquireLock(cwd: string): (() => void) | null {
     const path = join(harnessDir(cwd), 'lock')
     mkdirSync(dirname(path), { recursive: true })
+    const token = `${process.pid} ${Date.now()} ${randomUUID()}\n`
     const take = (): boolean => {
         try {
-            writeFileSync(path, `${process.pid} ${Date.now()}\n`, { encoding: 'utf8', flag: 'wx' })
+            writeFileSync(path, token, { encoding: 'utf8', flag: 'wx' })
             return true
         } catch {
             return false
@@ -253,12 +254,17 @@ export function acquireLock(cwd: string): (() => void) | null {
     }
     if (!take()) {
         try {
-            const at = Number(readFileSync(path, 'utf8').split(' ')[1])
+            const existing = readFileSync(path, 'utf8')
+            const at = Number(existing.split(' ')[1])
             if (Number.isFinite(at) && Date.now() - at > LOCK_STALE_MS) rmSync(path, { force: true })
         } catch {}
         if (!take()) return null
     }
-    return () => rmSync(path, { force: true })
+    return () => {
+        try {
+            if (readFileSync(path, 'utf8') === token) rmSync(path, { force: true })
+        } catch {}
+    }
 }
 
 export function recordLessonUse(cwd: string, id: string): void {