@prestack/thread 0.0.1 → 0.0.2

package/dist/core/condition.ts

@@ -0,0 +1,227 @@
+import { ENVIRONMENT, type Actor } from './actor.ts'
+
+export const COMPARE_OPS = ['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in', 'has'] as const
+export type CompareOp = (typeof COMPARE_OPS)[number]
+
+export const AGGREGATIONS = ['count', 'sum', 'min', 'max', 'avg'] as const
+
+export const ACTOR_FACTS = ['id', 'roles', 'entitlements', ...ENVIRONMENT.map(([fact]) => fact)] as const satisfies readonly (keyof Actor)[]
+
+export const AGO = /^[1-9][0-9]*[smhd]$/
+
+export type Operand =
+  | { readonly value: string | number | boolean | null }
+  | { readonly field: string }
+  | { readonly was: string }
+  | { readonly outer: string }
+  | { readonly actor: (typeof ACTOR_FACTS)[number] }
+  | { readonly now: true }
+  | { readonly ago: string }
+  | {
+      readonly agg: {
+        readonly of: string
+        readonly how: (typeof AGGREGATIONS)[number]
+        readonly field?: string
+        readonly where?: Condition
+      }
+    }
+
+export type Condition =
+  | { readonly all: readonly Condition[] }
+  | { readonly any: readonly Condition[] }
+  | { readonly not: Condition }
+  | { readonly is: Operand; readonly op: CompareOp; readonly than: Operand }
+
+export function walkOperands(condition: Condition, take: (one: Operand) => void): void {
+  if ('all' in condition) {
+    for (const one of condition.all) walkOperands(one, take)
+    return
+  }
+  if ('any' in condition) {
+    for (const one of condition.any) walkOperands(one, take)
+    return
+  }
+  if ('not' in condition) {
+    walkOperands(condition.not, take)
+    return
+  }
+  for (const side of [condition.is, condition.than]) {
+    take(side)
+    if ('agg' in side && side.agg.where !== undefined) walkOperands(side.agg.where, take)
+  }
+}
+
+export function mentionsActor(condition: Condition): boolean {
+  let found = false
+  walkOperands(condition, (one) => {
+    if ('actor' in one) found = true
+  })
+  return found
+}
+
+export function agoSeconds(ago: string): number | undefined {
+  if (!AGO.test(ago)) return undefined
+  const size = Number(ago.slice(0, -1))
+  const unit = ago.slice(-1)
+  return size * (unit === 's' ? 1 : unit === 'm' ? 60 : unit === 'h' ? 3_600 : 86_400)
+}
+
+export function satisfies(condition: Condition, actor: Actor): boolean {
+  if ('all' in condition) return condition.all.every((one) => satisfies(one, actor))
+  if ('any' in condition) return condition.any.some((one) => satisfies(one, actor))
+  if ('not' in condition) return !satisfies(condition.not, actor)
+
+  const reads = (one: Operand): unknown => {
+    if ('value' in one) return one.value
+    if ('actor' in one) return actor[one.actor]
+    return undefined
+  }
+
+  const left = reads(condition.is)
+  const right = reads(condition.than)
+  if (left === undefined || right === undefined) return false
+
+  const op = condition.op
+  if (op === 'in') return Array.isArray(right) && right.includes(left)
+  if (op === 'has') return Array.isArray(left) && left.includes(right)
+  if (op === 'eq') return left === right
+  if (op === 'neq') return left !== right
+  if (typeof left !== typeof right) return false
+  if (typeof left !== 'number' && typeof left !== 'string') return false
+  const other = right as number | string
+  if (op === 'lt') return left < other
+  if (op === 'lte') return left <= other
+  if (op === 'gt') return left > other
+  return left >= other
+}
+
+type Asked = {
+  readonly id: string
+  readonly fields: readonly string[]
+}
+
+export const CONDITION_ANSWERS = ['is', 'than', 'field', 'value', 'actor', 'ago', 'of', 'how', 'over', 'op', 'when', 'joins'] as const
+
+const OPERAND_WORDS = ['field', 'value', 'actor', 'now', 'ago', 'agg'] as const
+
+async function sided(
+  ask: (key: string, question: string) => Promise<string>,
+  say: (line: string) => void,
+  subject: Asked,
+  all: readonly Asked[],
+  which: string,
+): Promise<Operand> {
+  for (;;) {
+    const kind = await ask(which, `  ${which} — ${OPERAND_WORDS.join(', ')}: `)
+    if (kind === 'field') {
+      const id = await ask('field', `    which field — ${subject.fields.join(', ')}: `)
+      if (!subject.fields.includes(id)) {
+        say(`    "${subject.id}" declares no \`${id}\`.\n`)
+        continue
+      }
+      return { field: id }
+    }
+    if (kind === 'value') {
+      const raw = await ask('value', '    the value (text, a number, true, false, null): ')
+      if (raw === 'null') return { value: null }
+      if (raw === 'true' || raw === 'false') return { value: raw === 'true' }
+      const asNumber = Number(raw)
+      return { value: raw !== '' && Number.isFinite(asNumber) ? asNumber : raw }
+    }
+    if (kind === 'actor') {
+      const fact = await ask('actor', `    which — ${ACTOR_FACTS.join(', ')}: `)
+      if (!(ACTOR_FACTS as readonly string[]).includes(fact)) {
+        say(`    an actor has ${ACTOR_FACTS.join(', ')} and nothing else.\n`)
+        continue
+      }
+      return { actor: fact as (typeof ACTOR_FACTS)[number] }
+    }
+    if (kind === 'now') return { now: true }
+    if (kind === 'ago') {
+      const span = await ask('ago', '    how long — e.g. 30d, 12h, 15m, 45s: ')
+      if (!AGO.test(span)) {
+        say('    a span is a number and one of s, m, h, d.\n')
+        continue
+      }
+      return { ago: span }
+    }
+    if (kind === 'agg') {
+      const of = await ask('of', `    over which entity — ${all.map((one) => one.id).join(', ')}: `)
+      const target = all.find((one) => one.id === of)
+      if (target === undefined) {
+        say(`    nothing declares \`${of}\`.\n`)
+        continue
+      }
+      const how = await ask('how', `    how — ${AGGREGATIONS.join(', ')}: `)
+      if (!(AGGREGATIONS as readonly string[]).includes(how)) {
+        say(`    an aggregation is ${AGGREGATIONS.join(', ')}.\n`)
+        continue
+      }
+      if (how === 'count') return { agg: { of, how: 'count' } }
+      const over = await ask('over', `    over which field of ${of} — ${target.fields.join(', ')}: `)
+      if (!target.fields.includes(over)) {
+        say(`    "${of}" declares no \`${over}\`.\n`)
+        continue
+      }
+      return { agg: { of, how: how as 'sum' | 'min' | 'max' | 'avg', field: over } }
+    }
+    say(`  there is no side called "${kind}".\n`)
+  }
+}
+
+async function compared(
+  ask: (key: string, question: string) => Promise<string>,
+  say: (line: string) => void,
+  subject: Asked,
+  all: readonly Asked[],
+): Promise<Condition> {
+  for (;;) {
+    const is = await sided(ask, say, subject, all, 'is')
+    const op = await ask('op', `  op — ${COMPARE_OPS.join(', ')}: `)
+    if (!(COMPARE_OPS as readonly string[]).includes(op)) {
+      say(`  \`${op}\` is not a comparison this provider carries.\n`)
+      continue
+    }
+    const than = await sided(ask, say, subject, all, 'than')
+    return { is, op: op as (typeof COMPARE_OPS)[number], than }
+  }
+}
+
+export async function conditioned(
+  ask: (key: string, question: string) => Promise<string>,
+  say: (line: string) => void,
+  subject: { readonly id: string; readonly fields: readonly string[] },
+  all: readonly { readonly id: string; readonly fields: readonly string[] }[],
+): Promise<Condition | undefined> {
+  const held: Condition[] = []
+  let joiner: 'all' | 'any' = 'all'
+  for (;;) {
+    if (held.length === 0) {
+      const wanted = await ask('when', '  state a condition — y/n: ')
+      if (!wanted.toLowerCase().startsWith('y')) return undefined
+    }
+    held.push(await compared(ask, say, subject, all))
+    const next = await ask('joins', '  and, or, done: ')
+    if (next === 'done' || next === '') break
+    if (next === 'and') joiner = 'all'
+    else if (next === 'or') joiner = 'any'
+    else {
+      say('  say and, or, or done.\n')
+      break
+    }
+  }
+  if (held.length === 0) return undefined
+  const first = held[0] as Condition
+  return held.length === 1 ? first : joiner === 'all' ? { all: held } : { any: held }
+}
+
+import { quoted } from './rows.ts'
+
+export function said(one: unknown): string {
+  if (typeof one === 'string') return quoted(one)
+  if (one === null) return 'null'
+  if (typeof one === 'boolean' || typeof one === 'number') return String(one)
+  if (Array.isArray(one)) return `[${one.map((each) => said(each)).join(', ')}]`
+  if (typeof one === 'object') return `{ ${Object.entries(one).map(([key, held]) => `${key}: ${said(held)}`).join(', ')} }`
+  return String(one)
+}

package/dist/core/descend.d.ts

@@ -3,6 +3,7 @@ import type { Finding } from './finding.ts';
 export declare const ROOT: string;
 export declare const TREE: string;
 export declare const THREAD_AT: string;
+export declare function unkept(at: string): boolean;
 export declare const LISTS: readonly ["declares", "derives", "seeds"];
 export interface Row {
     readonly at?: string;

package/dist/core/descend.js

@@ -1,3 +1,4 @@
+import { spawnSync } from 'node:child_process';
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import ts from 'typescript';
@@ -25,6 +26,33 @@ function rooted() {
 export const ROOT = TREE_AT?.at ?? NOWHERE;
 export const TREE = `${TREE_AT?.name ?? NOWHERE}/`;
 export const THREAD_AT = `${TREE_AT?.name ?? NOWHERE}/thread.ts`;
+const OWN_IGNORES = (() => {
+    if (spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: ROOT, stdio: 'ignore' }).status === 0) {
+        return undefined;
+    }
+    try {
+        return readFileSync(join(ROOT, '.gitignore'), 'utf8')
+            .split('\n')
+            .map((one) => one.trim())
+            .filter((one) => one !== '' && !one.startsWith('#') && !one.startsWith('!'))
+            .map((one) => one.replace(/^\/+|\/+$/g, ''))
+            .filter((one) => one !== '' && !one.includes('*'));
+    }
+    catch {
+        return [];
+    }
+})();
+const asked = new Map();
+export function unkept(at) {
+    const held = asked.get(at);
+    if (held !== undefined)
+        return held;
+    const found = OWN_IGNORES === undefined
+        ? spawnSync('git', ['check-ignore', '-q', '--', at], { cwd: ROOT, stdio: 'ignore' }).status === 0
+        : OWN_IGNORES.some((one) => at === one || at.startsWith(`${one}/`) || at.split('/').includes(one));
+    asked.set(at, found);
+    return found;
+}
 export const LISTS = ['declares', 'derives', 'seeds'];
 const SOURCE = /\.(ts|tsx|mts|cts)$/;
 const RUNNER = /^(?:pnpm|npm|yarn) (?:run )?([\w:.-]+)/;
@@ -663,6 +691,14 @@ export function descend() {
             return;
         }
         const target = resolve(ROOT, row.at);
+        if (unkept(row.at)) {
+            findings.push({
+                file: at,
+                detail: `\`${names(row)}\` names \`${row.at}\`, which git ignores, so it is on this machine and in no clone of it`,
+                instead: 'name a file this repository carries, or stop ignoring it. A row naming an ignored path is answered here and nowhere else, so the descent passes on the disk that wrote it and breaks everywhere the work actually runs',
+            });
+            return;
+        }
         if (!existsSync(target)) {
             const derived = list === 'derives' || row.by !== undefined;
             const said = absent.get(row.at);