@tduyng/pi-harness-loop 0.0.0-stage → 0.0.1

package/src/apply.ts

@@ -0,0 +1,257 @@
+import { createHash } from 'node:crypto'
+import {
+    existsSync,
+    mkdirSync,
+    readdirSync,
+    readFileSync,
+    rmSync,
+    rmdirSync,
+    writeFileSync,
+    type Dirent
+} from 'node:fs'
+import { basename, dirname, join, relative, resolve } from 'node:path'
+
+import { readSettings } from './store.js'
+import type { InstalledFile } from './types.js'
+
+export interface AppliedFile extends InstalledFile {
+    after: string
+    block: string
+}
+
+export interface InstallTarget {
+    to: string
+    mode: 'replace' | 'append'
+}
+
+export interface OwnedFile {
+    after?: string
+    blocks: string[]
+}
+
+export interface InstallContext {
+    cwd: string
+    agentDir: string
+    homeSkills: string
+    live: Map<string, string>
+    owned: Map<string, OwnedFile>
+}
+
+export interface Proposal {
+    skills: { name: string; files: string[] }[]
+    profiles: { name: string; file: string }[]
+    rule: string | null
+}
+
+const RESERVED = new Set(['RULE.md', 'BRIEF.md', 'CONFIRM.md', 'REPLY.txt'])
+const GLOBAL = 'global'
+const CONTEXT_NAMES = ['AGENTS.override.md', 'AGENTS.md', 'AGENTS.MD', 'CLAUDE.md', 'CLAUDE.MD']
+
+function contextFile(dir: string): string {
+    for (const name of CONTEXT_NAMES) {
+        const path = join(dir, name)
+        if (existsSync(path)) return path
+    }
+    return join(dir, 'AGENTS.md')
+}
+
+function firstHeading(text: string): string | null {
+    for (const line of text.split('\n')) {
+        const match = /^(#+)\s+\S/.exec(line)
+        if (match?.[1] !== undefined) return line.trim()
+    }
+    return null
+}
+
+/**
+ * A rule that is revised replaces the rule it revises, because a second copy
+ * of the same heading is the same rule said twice, and the context file pays
+ * for both.
+ */
+export function appendRule(before: string, content: string): string {
+    const heading = firstHeading(content)
+    if (heading === null) return `${before.trimEnd()}\n\n${content.trim()}\n`
+    const lines = before.split('\n')
+    const start = lines.findIndex((line) => line.trim() === heading)
+    if (start === -1) return `${before.trimEnd()}\n\n${content.trim()}\n`
+    const level = heading.match(/^(#+)/)?.[1]?.length ?? 2
+    let end = lines.length
+    for (let index = start + 1; index < lines.length; index += 1) {
+        const match = /^(#+)\s/.exec(lines[index] ?? '')
+        if (match?.[1] !== undefined && match[1].length <= level) {
+            end = index
+            break
+        }
+    }
+    return [...lines.slice(0, start), ...content.trim().split('\n'), '', ...lines.slice(end)]
+        .join('\n')
+        .trimEnd()
+        .concat('\n')
+}
+
+export function filesUnder(dir: string): string[] {
+    const out: string[] = []
+    let entries: Dirent[]
+    try {
+        entries = readdirSync(dir, { withFileTypes: true })
+    } catch {
+        return out
+    }
+    for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+        const full = join(dir, entry.name)
+        if (entry.isDirectory()) out.push(...filesUnder(full))
+        else if (entry.isFile()) out.push(full)
+    }
+    return out
+}
+
+export function readProposal(dir: string): Proposal {
+    const skills: { name: string; files: string[] }[] = []
+    const profiles: { name: string; file: string }[] = []
+    let rule: string | null = null
+    for (const file of filesUnder(dir)) {
+        const parts = relative(dir, file).split('/')
+        const root = parts[0] ?? ''
+        if (parts.length === 1 && RESERVED.has(root)) {
+            if (root === 'RULE.md') rule = file
+            continue
+        }
+        if (parts.length === 1 && root.endsWith('.md')) {
+            profiles.push({ name: basename(file, '.md'), file })
+            continue
+        }
+        const name = parts[0] === GLOBAL ? (parts[1] ?? '') : root
+        if (name === '') continue
+        const found = skills.find((skill) => skill.name === name)
+        if (found) found.files.push(file)
+        else skills.push({ name, files: [file] })
+    }
+    return { skills, profiles, rule }
+}
+
+export function liveTarget(file: string, dir: string, context: InstallContext): InstallTarget | null {
+    const parts = relative(dir, file).split('/')
+    const root = parts[0] ?? ''
+    const global = root === GLOBAL
+    const name = global ? (parts[1] ?? '') : root
+    if (parts.length === 1 && root === 'RULE.md') {
+        return { to: contextFile(context.cwd), mode: 'append' }
+    }
+    if (global && name === 'RULE.md') {
+        return { to: contextFile(context.agentDir), mode: 'append' }
+    }
+    if (RESERVED.has(root)) return null
+    if (parts.length === 1 && root.endsWith('.md')) {
+        return { to: join(context.cwd, '.pi', 'agents', root), mode: 'replace' }
+    }
+    if (name === '') return null
+    const livePath = context.live.get(name)
+    if (livePath !== undefined) return { to: join(dirname(livePath), ...parts.slice(global ? 2 : 1)), mode: 'replace' }
+    if (global) return { to: join(context.homeSkills, ...parts.slice(1)), mode: 'replace' }
+    return { to: join(context.cwd, '.agents', 'skills', ...parts), mode: 'replace' }
+}
+
+/**
+ * The loop writes into files a person also writes in. It replaces a file it wrote itself, and
+ * it refuses the ones it did not write, because a rule the loop did not author is not the
+ * loop's to overwrite.
+ */
+function refusal(
+    target: InstallTarget,
+    existed: boolean,
+    before: string,
+    block: string,
+    context: InstallContext
+): string | null {
+    if (!existed) return null
+    const claim = context.owned.get(target.to)
+    if (target.mode === 'replace') {
+        if (claim === undefined) return 'the loop did not write it'
+        if (claim.after !== undefined && claim.after !== before) return 'it changed since the loop wrote it'
+        return null
+    }
+    const heading = firstHeading(block)
+    if (heading === null || !before.includes(heading)) return null
+    const mine = claim?.blocks.some((entry) => firstHeading(entry) === heading && before.includes(entry)) ?? false
+    return mine ? null : `the rule ${heading} was not written by the loop`
+}
+
+export function applyProposal(dir: string, context: InstallContext) {
+    const applied: AppliedFile[] = []
+    const refused: string[] = []
+    const settings = readSettings(context.cwd)
+    const project = resolve(context.cwd)
+    for (const file of filesUnder(dir)) {
+        const target = liveTarget(file, dir, context)
+        if (target === null) continue
+        if (!settings.global && !resolve(target.to).startsWith(`${project}/`)) {
+            refused.push(
+                `${target.to}: the part reaches outside the project, set global in .pi/harness.json to allow it`
+            )
+            continue
+        }
+        const existed = existsSync(target.to)
+        const before = existed ? readFileSync(target.to, 'utf8') : ''
+        const content = readFileSync(file, 'utf8')
+        const block = target.mode === 'append' ? content.trim() : ''
+        const reason = refusal(target, existed, before, block, context)
+        if (reason !== null) {
+            refused.push(`${target.to}: ${reason}`)
+            continue
+        }
+        const next =
+            target.mode === 'append'
+                ? before.trim() === ''
+                    ? `${content.trim()}\n`
+                    : appendRule(before, content)
+                : content
+        mkdirSync(dirname(target.to), { recursive: true })
+        writeFileSync(target.to, next, 'utf8')
+        applied.push({ to: target.to, existed, before, after: next, afterHash: hashOf(next), block, mode: target.mode })
+    }
+    return { applied, refused }
+}
+
+export function hashOf(text: string): string {
+    return createHash('sha256').update(text).digest('hex')
+}
+
+export function revertApplied(applied: InstalledFile[], roots: string[] = [], force = false) {
+    const restored: string[] = []
+    const refused: string[] = []
+    for (const file of applied.toReversed()) {
+        if (!force && file.afterHash !== undefined && existsSync(file.to)) {
+            if (hashOf(readFileSync(file.to, 'utf8')) !== file.afterHash) {
+                refused.push(file.to)
+                continue
+            }
+        }
+        if (file.existed) {
+            mkdirSync(dirname(file.to), { recursive: true })
+            writeFileSync(file.to, file.before, 'utf8')
+        } else {
+            rmSync(file.to, { force: true })
+            removeEmptyParents(file.to, roots)
+        }
+        restored.push(file.to)
+    }
+    return { restored, refused }
+}
+
+/** The directories an install created go with it, so a reverted part leaves nothing behind. */
+function removeEmptyParents(path: string, roots: string[]): void {
+    for (const root of roots) {
+        if (!path.startsWith(root)) continue
+        let dir = dirname(path)
+        while (dir.length > root.length) {
+            try {
+                if (readdirSync(dir).length > 0) break
+                rmdirSync(dir)
+            } catch {
+                break
+            }
+            dir = dirname(dir)
+        }
+        return
+    }
+}

package/src/atomic.ts

@@ -0,0 +1,7 @@
+import { renameSync, writeFileSync } from 'node:fs'
+
+export function writeFileAtomic(path: string, data: string): void {
+    const temporary = `${path}.${process.pid}.tmp`
+    writeFileSync(temporary, data, 'utf8')
+    renameSync(temporary, path)
+}