spexcode 0.6.2 → 0.6.6

package/spec-forge/src/drivers.ts

@@ -1,73 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import type { ForgeDriver } from './port.js'
-import { githubDriver } from './drivers/github.js'
-import { gitlabDriver } from './drivers/gitlab.js'
-
-export const FORGE_DRIVERS: ForgeDriver[] = [githubDriver, gitlabDriver]
-export const DEFAULT_FORGE_HOST = 'github'
-
-export function forgeDriverFor(host: string): ForgeDriver | undefined {
-  return FORGE_DRIVERS.find((d) => d.host === host)
-}
-
-export function forgeIssueStores(): { id: string; label: string; kind: 'forge' }[] {
-  const driver = forgeDriverFor(resolveForgeHost())
-  return driver ? [{ id: driver.host, label: driver.host, kind: 'forge' }] : []
-}
-
-function gitEnv(): NodeJS.ProcessEnv {
-  const env = { ...process.env }
-  delete env.GIT_DIR; delete env.GIT_WORK_TREE; delete env.GIT_INDEX_FILE; delete env.GIT_OBJECT_DIRECTORY
-  return env
-}
-
-function gitOut(args: string[]): string | null {
-  try {
-    return execFileSync('git', args, { env: gitEnv(), encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || null
-  } catch { return null }
-}
-
-function configuredHost(): string | null {
-  const root = gitOut(['rev-parse', '--show-toplevel'])
-  if (!root) return null
-  for (const name of ['spexcode.local.json', 'spexcode.json']) {
-    const p = join(root, name)
-    if (!existsSync(p)) continue
-    let parsed: any
-    try { parsed = JSON.parse(readFileSync(p, 'utf8')) }
-    catch (e) { throw new Error(`${p} is not valid JSON: ${(e as Error).message}`) }
-    const host = parsed?.forge?.host
-    if (typeof host === 'string' && host.trim()) return host.trim()
-  }
-  return null
-}
-
-function remoteHostname(url: string): string | null {
-  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) {
-    try { return new URL(url).hostname || null } catch { return null }
-  }
-  const scp = /^(?:[^@\s/]+@)?([^:/\s]+):./.exec(url)
-  return scp ? scp[1] : null
-}
-
-function hostFor(hostname: string): string {
-  const h = hostname.toLowerCase()
-  if (h.includes('github')) return 'github'
-  if (h.includes('bitbucket')) return 'bitbucket'
-  return 'gitlab'
-}
-
-let cached: { host: string; at: number } | null = null
-const RESOLVE_TTL_MS = 30_000
-
-export function resolveForgeHost(): string {
-  const now = Date.now()
-  if (cached && now - cached.at < RESOLVE_TTL_MS) return cached.host
-  const url = gitOut(['remote', 'get-url', 'origin'])
-  const hostname = url ? remoteHostname(url) : null
-  const host = configuredHost() ?? (hostname ? hostFor(hostname) : DEFAULT_FORGE_HOST)
-  cached = { host, at: now }
-  return host
-}

package/spec-forge/src/links.ts

@@ -1,72 +0,0 @@
-import type { ForgeIssue, ForgePR } from './port.js'
-
-export type LinkedIssue = ForgeIssue & { via: 'marker' | 'pr' }
-export type LinkedPR = ForgePR & { via: 'branch' }
-export type NodeLinks = { node: string; issues: LinkedIssue[]; prs: LinkedPR[] }
-
-export function parseSpecMarkers(body: string): string[] {
-  const ids: string[] = []
-  for (const m of (body || '').matchAll(/^\s*spec:\s*(.+)$/gim)) {
-    for (const part of m[1].split(',')) {
-      const id = part.trim()
-      if (id) ids.push(id)
-    }
-  }
-  return ids
-}
-
-export function branchToNode(branch: string, nodeIds: string[]): string | null {
-  if (!branch?.startsWith('node/')) return null
-  const rest = branch.slice('node/'.length)
-  let best: string | null = null
-  for (const id of nodeIds) {
-    if (rest === id || rest.startsWith(id + '-')) {
-      if (!best || id.length > best.length) best = id
-    }
-  }
-  return best
-}
-
-export function resolveLinks(
-  issues: ForgeIssue[],
-  prs: ForgePR[],
-  nodeIds: string[],
-): NodeLinks[] {
-  const known = new Set(nodeIds)
-  const byNode = new Map<string, { issues: Map<number, LinkedIssue>; prs: Map<number, LinkedPR> }>()
-  const slot = (node: string) => {
-    let s = byNode.get(node)
-    if (!s) { s = { issues: new Map(), prs: new Map() }; byNode.set(node, s) }
-    return s
-  }
-
-  const prNode = new Map<number, string>()
-  for (const pr of prs) {
-    const node = branchToNode(pr.headRefName, nodeIds)
-    if (!node) continue
-    prNode.set(pr.number, node)
-    slot(node).prs.set(pr.number, { ...pr, via: 'branch' })
-  }
-
-  const issueByNumber = new Map(issues.map((i) => [i.number, i]))
-  for (const issue of issues) {
-    for (const id of parseSpecMarkers(issue.body)) {
-      if (known.has(id)) slot(id).issues.set(issue.number, { ...issue, via: 'marker' })
-    }
-  }
-
-  for (const pr of prs) {
-    const node = prNode.get(pr.number)
-    if (!node) continue
-    for (const num of pr.closesIssues) {
-      const issue = issueByNumber.get(num)
-      if (issue && !slot(node).issues.has(num)) {
-        slot(node).issues.set(num, { ...issue, via: 'pr' })
-      }
-    }
-  }
-
-  return [...byNode.entries()]
-    .map(([node, s]) => ({ node, issues: [...s.issues.values()], prs: [...s.prs.values()] }))
-    .sort((a, b) => a.node.localeCompare(b.node))
-}

package/spec-forge/src/needs-eval.ts

@@ -1,29 +0,0 @@
-import type { ForgeIssue, ForgePR } from './port.js'
-import { resolveLinks, type LinkedIssue } from './links.js'
-
-export const NEEDS_EVAL = 'needs-eval'
-
-const BODY_MARKER = new RegExp(`^\\s*${NEEDS_EVAL}\\s*:?\\s*$`, 'im')
-
-export function isNeedsEval(issue: ForgeIssue): boolean {
-  if (issue.labels.some((l) => l.trim().toLowerCase() === NEEDS_EVAL)) return true
-  return BODY_MARKER.test(issue.body || '')
-}
-
-export type EvalPending = LinkedIssue
-export type NodeEvalPending = { node: string; pending: EvalPending[] }
-
-export function resolveEvalPending(
-  issues: ForgeIssue[],
-  prs: ForgePR[],
-  nodeIds: string[],
-): NodeEvalPending[] {
-  const flagged = new Set(issues.filter(isNeedsEval).map((i) => i.number))
-  if (!flagged.size) return []
-  const out: NodeEvalPending[] = []
-  for (const { node, issues: linked } of resolveLinks(issues, prs, nodeIds)) {
-    const pending = linked.filter((i) => i.state === 'open' && flagged.has(i.number))
-    if (pending.length) out.push({ node, pending })
-  }
-  return out
-}

package/spec-forge/src/port.ts

@@ -1,36 +0,0 @@
-export type ForgeComment = {
-  author: string
-  createdAt: string
-  body: string
-}
-
-export type ForgeIssue = {
-  number: number
-  title: string
-  body: string
-  url: string
-  state: string
-  labels: string[]
-  author: string
-  createdAt: string
-  comments: ForgeComment[]
-}
-
-export type ForgePR = {
-  number: number
-  title: string
-  url: string
-  state: string
-  headRefName: string
-  closesIssues: number[]
-}
-
-export interface ForgeDriver {
-  readonly host: string
-  listIssues(): Promise<ForgeIssue[]>
-  listPRs(): Promise<ForgePR[]>
-  createIssue(input: { title: string; body: string }): Promise<{ number: number; url: string }>
-  createComment(input: { number: number; body: string }): Promise<{ url: string }>
-  closeIssue(input: { number: number }): Promise<{ url: string }>
-  listIssuesSince?(sinceISO: string): Promise<ForgeIssue[]>
-}

package/spec-forge/src/resident.ts

@@ -1,46 +0,0 @@
-import { ForgeCache } from './cache.js'
-import { forgeDriverFor, resolveForgeHost } from './drivers.js'
-import type { ForgeIssue, ForgePR } from './port.js'
-
-const cache = new ForgeCache()
-let inFlight: Promise<void> | null = null
-let lastAttempt = 0
-const TTL_MS = 20_000
-let lastIssueSync: string | null = null
-let lastFull = 0
-const FULL_MS = 30 * 60_000
-
-function refreshIfStale(now: number): void {
-  if (inFlight || (lastAttempt && now - lastAttempt < TTL_MS)) return
-  const driver = forgeDriverFor(resolveForgeHost())
-  if (!driver) return
-  lastAttempt = now
-  const startISO = new Date(now).toISOString()   // stamped at fetch START so an update during the fetch lands in the next window
-  const incremental = lastIssueSync && driver.listIssuesSince && now - lastFull < FULL_MS
-  inFlight = (incremental
-    ? Promise.all([
-        driver.listIssuesSince!(lastIssueSync!).then((delta) => cache.applyIssues(delta)),
-        driver.listPRs().then((prs) => cache.setPRs(prs)),
-      ]).then(() => { lastIssueSync = startISO })
-    : cache.reconcile(driver).then(() => { lastFull = now; lastIssueSync = startISO })
-  )
-    .catch(() => {})
-    .finally(() => { inFlight = null })
-}
-
-export function residentForgeState(): { issues: ForgeIssue[]; prs: ForgePR[] } {
-  refreshIfStale(Date.now())
-  return cache.state()
-}
-
-export function residentForgeRevision(): number {
-  return cache.stateRevision()
-}
-
-export async function refreshForgeNow(): Promise<void> {
-  if (inFlight) await inFlight
-  lastAttempt = 0
-  lastFull = 0
-  refreshIfStale(Date.now())
-  if (inFlight) await inFlight
-}