@innofeight/global-workflow 0.0.1 → 0.0.2

package/scripts/lib/clickup-task-comments.mjs

@@ -0,0 +1,65 @@
+import { URL } from 'node:url'
+
+const PAGE_SIZE = 25
+
+function fail(reason) {
+  throw new Error(`clickup-comments.${reason}`)
+}
+
+function normalizeComment(comment) {
+  if (!comment || typeof comment !== 'object' || Array.isArray(comment))
+    fail('invalid-comment')
+  const id = String(comment.id ?? '')
+  const date = String(comment.date ?? '')
+  if (!id || !/^\d+$/u.test(date)) fail('invalid-comment-cursor')
+  if (typeof comment.comment_text !== 'string') fail('invalid-comment-text')
+  return { date, id, text: comment.comment_text }
+}
+
+async function page(fetchImpl, token, taskId, cursor) {
+  const url = new URL(`https://api.clickup.com/api/v2/task/${taskId}/comment`)
+  if (cursor) {
+    url.searchParams.set('start', cursor.start)
+    url.searchParams.set('start_id', cursor.startId)
+  }
+  let response
+  try {
+    response = await fetchImpl(url.toString(), {
+      headers: { Authorization: token }
+    })
+  } catch (error) {
+    fail(
+      `request-failed:${error instanceof Error ? error.message : String(error)}`
+    )
+  }
+  if (!response.ok) fail(`request-failed:${response.status}`)
+  const body = await response.json()
+  if (!body || !Array.isArray(body.comments)) fail('invalid-response')
+  return body.comments.map(normalizeComment)
+}
+
+export async function readAllTaskComments({ fetchImpl, taskId, token }) {
+  const byId = new Map()
+  const cursors = new Set()
+  let cursor
+  for (;;) {
+    const comments = await page(fetchImpl, token, taskId, cursor)
+    for (const comment of comments) {
+      const existing = byId.get(comment.id)
+      if (existing && JSON.stringify(existing) !== JSON.stringify(comment))
+        fail(`conflicting-duplicate:${comment.id}`)
+      byId.set(comment.id, comment)
+    }
+    if (comments.length < PAGE_SIZE) break
+    const oldest = comments.at(-1)
+    if (!oldest) fail('missing-oldest-comment')
+    const next = `${oldest.date}:${oldest.id}`
+    if (cursors.has(next)) fail('repeating-cursor')
+    cursors.add(next)
+    cursor = { start: oldest.date, startId: oldest.id }
+  }
+  return [...byId.values()].sort(
+    (left, right) =>
+      Number(right.date) - Number(left.date) || right.id.localeCompare(left.id)
+  )
+}

package/scripts/lib/post-merge-evidence.mjs

@@ -0,0 +1,114 @@
+import { createHash } from 'node:crypto'
+
+import { stableAetV2Json, validateAetV2Event } from './aet-v2.mjs'
+
+export const RECORD_PREFIXES = Object.freeze({
+  automaticEligibility: 'POST_MERGE_AUTOMATIC_ELIGIBILITY_V1 ',
+  authorized: 'POST_MERGE_RECONCILIATION_AUTHORIZED_V2 ',
+  calibration: 'POST_MERGE_CALIBRATION_EVIDENCE_V1 ',
+  durableReconciliation: 'POST_MERGE_DURABLE_RECONCILIATION_V1 ',
+  finalized: 'POST_MERGE_RECONCILIATION_FINALIZED_V2 ',
+  introducingRecovery: 'POST_MERGE_INTRODUCING_RECOVERY_V1 ',
+  introducingStaging: 'POST_MERGE_INTRODUCING_STAGING_EXCEPTION_V1 ',
+  skippedIdentityRecovery: 'POST_MERGE_SKIPPED_IDENTITY_RECOVERY_V1 ',
+  packet: 'POST_MERGE_COMPLETION_REQUEST_V2 ',
+  staging: 'POST_MERGE_STAGING_V1 '
+})
+
+export function fingerprint(value) {
+  return `sha256:${createHash('sha256').update(stableAetV2Json(value)).digest('hex')}`
+}
+
+export function formatDurableRecord(prefix, schema, payload) {
+  const envelope = { fingerprint: fingerprint(payload), payload, schema }
+  return `${prefix}${stableAetV2Json(envelope)}`
+}
+
+export function parseDurableRecord(text, prefix, schema) {
+  if (typeof text !== 'string' || !text.startsWith(prefix)) return null
+  let envelope
+  try {
+    envelope = JSON.parse(text.slice(prefix.length))
+  } catch {
+    throw new Error(`post-merge.invalid-durable-json:${prefix.trim()}`)
+  }
+  if (
+    !envelope ||
+    typeof envelope !== 'object' ||
+    Array.isArray(envelope) ||
+    Object.keys(envelope).sort().join(',') !== 'fingerprint,payload,schema' ||
+    envelope.schema !== schema ||
+    envelope.fingerprint !== fingerprint(envelope.payload)
+  )
+    throw new Error('post-merge.invalid-durable-envelope')
+  return envelope
+}
+
+export function commentsToTexts(comments) {
+  return comments.map((comment) => comment.text)
+}
+
+export function durableRecords(texts, prefix, schema) {
+  return texts
+    .map((text) => parseDurableRecord(text, prefix, schema))
+    .filter(Boolean)
+}
+
+export function durableAetEvents(texts) {
+  const events = []
+  for (const text of texts) {
+    if (typeof text !== 'string' || !text.trimStart().startsWith('{')) continue
+    try {
+      const event = JSON.parse(text)
+      if (event?.schema !== 'rn-launcher/aet-v2-event/v1') continue
+      events.push(validateAetV2Event(event))
+    } catch (error) {
+      if (text.includes('rn-launcher/aet-v2-event/v1')) throw error
+    }
+  }
+  return events
+}
+
+export function durableTaskAetEvents(texts, taskId) {
+  const events = durableAetEvents(texts).filter(
+    (event) => event.taskId === taskId
+  )
+  const ids = new Set()
+  for (const event of events) {
+    if (ids.has(event.eventId))
+      throw new Error(`post-merge.duplicate-durable-event: ${event.eventId}`)
+    ids.add(event.eventId)
+  }
+  return events
+}
+
+export function closedWorldLedger(events, eventIds, terminalEventIds = []) {
+  const seen = new Set()
+  for (const event of events) {
+    if (seen.has(event.eventId))
+      throw new Error(`post-merge.duplicate-durable-event: ${event.eventId}`)
+    seen.add(event.eventId)
+  }
+  const terminal = new Set(terminalEventIds)
+  const applicable = events.filter((event) => !terminal.has(event.eventId))
+  const expected = applicable.map((event) => event.eventId).sort()
+  const requested = [...eventIds].sort()
+  if (JSON.stringify(expected) !== JSON.stringify(requested))
+    throw new Error('post-merge.stale-or-incomplete-event-set')
+  return canonicalLedger(applicable, requested)
+}
+
+export function canonicalLedger(events, eventIds) {
+  const byId = new Map()
+  for (const event of events) {
+    if (byId.has(event.eventId))
+      throw new Error(`post-merge.duplicate-durable-event: ${event.eventId}`)
+    byId.set(event.eventId, event)
+  }
+  const selected = [...eventIds].sort().map((eventId) => {
+    const event = byId.get(eventId)
+    if (!event) throw new Error(`post-merge.missing-durable-event: ${eventId}`)
+    return event
+  })
+  return selected.map(stableAetV2Json).join('\n')
+}

package/scripts/lib/task-branch.mjs

@@ -0,0 +1,370 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { URL } from 'node:url'
+
+export const TASK_SLUG_MAX_LENGTH = 48
+
+export class TaskBranchStop extends Error {
+  constructor(reason, details = {}) {
+    super(reason)
+    this.name = 'TaskBranchStop'
+    this.details = sanitizeDiagnosticDetails(details)
+  }
+}
+
+function sanitizeDiagnosticDetails(value) {
+  if (typeof value === 'string') return redactGitDiagnostic(value)
+  if (Array.isArray(value)) return value.map(sanitizeDiagnosticDetails)
+  if (value && typeof value === 'object')
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        sanitizeDiagnosticDetails(entry)
+      ])
+    )
+  return value
+}
+
+export function normalizeTaskSlug(title) {
+  const slug = title
+    .normalize('NFKD')
+    .toLowerCase()
+    .replace(/[\u0300-\u036f]/gu, '')
+    .replace(/[^a-z0-9]+/gu, '-')
+    .replace(/-+/gu, '-')
+    .replace(/^-|-$/gu, '')
+    .slice(0, TASK_SLUG_MAX_LENGTH)
+    .replace(/-$/gu, '')
+  return slug || 'task'
+}
+
+export function validateTaskId(taskId) {
+  if (!/^[a-z0-9]+$/u.test(taskId))
+    throw new TaskBranchStop('INVALID CLICKUP TASK ID', { taskId })
+  return taskId
+}
+
+export function taskBranchName(taskId, title) {
+  return `codex/CU-${validateTaskId(taskId)}-${normalizeTaskSlug(title)}`
+}
+
+export function validatePredecessorBinding(predecessor) {
+  if (!predecessor || typeof predecessor !== 'object')
+    throw new TaskBranchStop('PREVIOUS GOVERNED TICKET REQUIRED')
+  const keys = Object.keys(predecessor).sort()
+  if (
+    JSON.stringify(keys) !==
+    JSON.stringify(['authority', 'status', 'taskId', 'title'])
+  )
+    throw new TaskBranchStop('PREDECESSOR BINDING IS INVALID')
+  if (predecessor.taskId === 'NONE') {
+    if (
+      predecessor.title !== 'NONE' ||
+      predecessor.status !== 'NONE' ||
+      predecessor.authority !== 'POSITIVELY_NO_PREDECESSOR'
+    )
+      throw new TaskBranchStop('NO-PREDECESSOR AUTHORITY IS INVALID')
+    return { result: 'NO PREDECESSOR — POSITIVELY PROVEN' }
+  }
+  validateTaskId(predecessor.taskId)
+  if (typeof predecessor.title !== 'string' || !predecessor.title.trim())
+    throw new TaskBranchStop('PREDECESSOR TITLE IS MISSING')
+  if (predecessor.authority !== 'FRESH_CLICKUP_GITHUB_REPOSITORY_READ')
+    throw new TaskBranchStop('PREDECESSOR AUTHORITY IS STALE OR UNKNOWN')
+  if (predecessor.status === 'COMPLETE')
+    return { result: 'PREDECESSOR COMPLETE', taskId: predecessor.taskId }
+  if (predecessor.status === 'AUTO_AFTER_MERGE_RESUMABLE')
+    throw new TaskBranchStop('PREDECESSOR MUST BE RECONCILED FIRST', {
+      taskId: predecessor.taskId
+    })
+  throw new TaskBranchStop('PREDECESSOR IS NOT COMPLETE', {
+    status: predecessor.status,
+    taskId: predecessor.taskId
+  })
+}
+
+export function normalizeRepositoryRemote(url) {
+  const trimmed = url.trim()
+  const match = trimmed
+    .replace(/\.git$/u, '')
+    .match(/(?:github\.com[/:])([^/]+\/[^/]+)$/u)
+  if (match) return match[1]
+
+  try {
+    const parsed = new URL(trimmed)
+    const pathname = parsed.pathname.replace(/\.git$/u, '')
+    if (parsed.protocol === 'file:') return pathname
+    return `unrecognized-remote:${parsed.hostname}${pathname}`
+  } catch {
+    const scpLike = trimmed.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/u)
+    if (scpLike)
+      return `unrecognized-remote:${scpLike[1]}/${scpLike[2].replace(
+        /\.git$/u,
+        ''
+      )}`
+    return `unrecognized-remote:${redactGitDiagnostic(trimmed).replace(
+      /\.git$/u,
+      ''
+    )}`
+  }
+}
+
+export function redactGitDiagnostic(value) {
+  return String(value).replace(
+    /([a-z][a-z0-9+.-]*:\/\/)[^/@\s]+@/giu,
+    '$1[REDACTED]@'
+  )
+}
+
+export function createGitRunner(cwd) {
+  return (args, options = {}) => {
+    const result = spawnSync('git', args, {
+      cwd,
+      encoding: 'utf8',
+      stdio: options.inherit ? 'inherit' : 'pipe'
+    })
+    if (result.error || result.status !== 0) {
+      if (options.allowFailure) return null
+      throw new TaskBranchStop(options.reason ?? 'GIT COMMAND FAILED', {
+        args,
+        cause: redactGitDiagnostic(
+          result.error?.message ??
+            result.stderr?.trim() ??
+            `git exited ${result.status}`
+        )
+      })
+    }
+    return options.inherit ? '' : result.stdout.trim()
+  }
+}
+
+function operationState(git, cwd) {
+  const gitDirectory = path.resolve(cwd, git(['rev-parse', '--git-dir']))
+  const commonDirectory = path.resolve(
+    cwd,
+    git(['rev-parse', '--git-common-dir'])
+  )
+  const checks = [
+    ['MERGE IN PROGRESS', path.join(gitDirectory, 'MERGE_HEAD')],
+    ['REBASE IN PROGRESS', path.join(gitDirectory, 'rebase-merge')],
+    ['REBASE IN PROGRESS', path.join(gitDirectory, 'rebase-apply')],
+    ['CHERRY-PICK IN PROGRESS', path.join(gitDirectory, 'CHERRY_PICK_HEAD')],
+    ['REVERT IN PROGRESS', path.join(gitDirectory, 'REVERT_HEAD')],
+    ['BISECT IN PROGRESS', path.join(commonDirectory, 'BISECT_LOG')]
+  ]
+  return checks.find(([, marker]) => existsSync(marker))?.[0] ?? null
+}
+
+export function inspectRepository({
+  cwd,
+  expectedRepository,
+  git = createGitRunner(cwd)
+}) {
+  const inside = git(['rev-parse', '--is-inside-work-tree'], {
+    allowFailure: true
+  })
+  if (inside !== 'true') throw new TaskBranchStop('WRONG REPOSITORY')
+
+  const originUrl = git(['remote', 'get-url', 'origin'], {
+    reason: 'REMOTE UNAVAILABLE'
+  })
+  const repository = normalizeRepositoryRemote(originUrl)
+  if (repository !== expectedRepository)
+    throw new TaskBranchStop('WRONG REPOSITORY', {
+      expected: expectedRepository,
+      observed: repository
+    })
+
+  const currentBranch = git(['symbolic-ref', '--quiet', '--short', 'HEAD'], {
+    allowFailure: true
+  })
+  if (!currentBranch) throw new TaskBranchStop('DETACHED HEAD')
+
+  const operation = operationState(git, cwd)
+  if (operation) throw new TaskBranchStop(operation)
+
+  const status = git(['status', '--porcelain=v2', '--untracked-files=all'])
+  const lines = status ? status.split(/\r?\n/u) : []
+  if (lines.some((line) => line.startsWith('u ')))
+    throw new TaskBranchStop('UNRESOLVED CONFLICTS')
+  if (lines.some((line) => /^[12] [^.]/u.test(line)))
+    throw new TaskBranchStop('STAGED CHANGES')
+  if (lines.some((line) => /^[12] .[^.]/u.test(line)))
+    throw new TaskBranchStop('TRACKED MODIFICATIONS')
+  if (lines.some((line) => line.startsWith('? ')))
+    throw new TaskBranchStop('UNTRACKED FILES')
+
+  return {
+    currentBranch,
+    head: git(['rev-parse', 'HEAD']),
+    repository,
+    clean: true
+  }
+}
+
+export function classifyMainRelation(git) {
+  const counts = git([
+    'rev-list',
+    '--left-right',
+    '--count',
+    'main...origin/main'
+  ])
+    .split(/\s+/u)
+    .map(Number)
+  const [ahead, behind] = counts
+  if (ahead === 0 && behind === 0) return 'equal'
+  if (ahead === 0 && Number(behind) > 0) return 'behind'
+  if (Number(ahead) > 0 && behind === 0) return 'ahead'
+  return 'divergent'
+}
+
+export function synchronizeMain(git) {
+  const relation = classifyMainRelation(git)
+  if (relation === 'ahead') throw new TaskBranchStop('LOCAL MAIN AHEAD')
+  if (relation === 'divergent') throw new TaskBranchStop('LOCAL MAIN DIVERGENT')
+  if (relation === 'behind')
+    git(['merge', '--ff-only', 'origin/main'], {
+      reason: 'MAIN FAST-FORWARD FAILED'
+    })
+  return relation
+}
+
+function remoteBranchSha(git, branch) {
+  const output = git(
+    ['ls-remote', '--heads', 'origin', `refs/heads/${branch}`],
+    {
+      reason: 'REMOTE UNAVAILABLE'
+    }
+  )
+  return output ? output.split(/\s+/u)[0] : null
+}
+
+export function pickupPlan({ cwd, expectedRepository, taskId, title }) {
+  const git = createGitRunner(cwd)
+  const state = inspectRepository({ cwd, expectedRepository, git })
+  const branch = taskBranchName(taskId, title)
+  const localCollision =
+    git(['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+      allowFailure: true
+    }) !== null
+  const remoteSha = remoteBranchSha(git, branch)
+  return {
+    mode: 'dry-run',
+    state,
+    branch,
+    localCollision,
+    remoteCollision: Boolean(remoteSha),
+    intendedActions: [
+      'fetch origin',
+      'switch to main',
+      'verify or fast-forward main with --ff-only',
+      `create ${branch} from verified main`,
+      `push --set-upstream origin ${branch}`,
+      'attempt ClickUp/GitHub linkage verification in the agent layer',
+      'stop for mandatory branch confirmed reply before Entry Review'
+    ],
+    mutationsPerformed: false
+  }
+}
+
+export function startPickup({
+  cwd,
+  expectedRepository,
+  predecessor,
+  taskId,
+  title
+}) {
+  validatePredecessorBinding(predecessor)
+  const git = createGitRunner(cwd)
+  inspectRepository({ cwd, expectedRepository, git })
+  const branch = taskBranchName(taskId, title)
+
+  git(['fetch', 'origin', '--prune'], { reason: 'REMOTE UNAVAILABLE' })
+  inspectRepository({ cwd, expectedRepository, git })
+  git(['switch', 'main'], { reason: 'CANNOT SWITCH TO MAIN SAFELY' })
+  inspectRepository({ cwd, expectedRepository, git })
+
+  synchronizeMain(git)
+  inspectRepository({ cwd, expectedRepository, git })
+
+  if (
+    git(['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+      allowFailure: true
+    }) !== null
+  )
+    throw new TaskBranchStop('LOCAL BRANCH COLLISION', { branch })
+  if (remoteBranchSha(git, branch))
+    throw new TaskBranchStop('REMOTE BRANCH COLLISION', { branch })
+
+  git(['switch', '-c', branch], { reason: 'BRANCH CREATION FAILED' })
+  git(['push', '--set-upstream', 'origin', branch], {
+    reason: 'BRANCH PUSH FAILED'
+  })
+  return {
+    result: 'BRANCH STARTED',
+    branch,
+    head: git(['rev-parse', 'HEAD']),
+    next: [
+      'attempt ClickUp/GitHub linkage verification',
+      'provide the readable task title/link and exact branch to the human',
+      'stop for mandatory branch confirmed reply before Entry Review'
+    ]
+  }
+}
+
+export function resumeCheck({ cwd, expectedRepository, taskId, title }) {
+  const git = createGitRunner(cwd)
+  const state = inspectRepository({ cwd, expectedRepository, git })
+  const branch = taskBranchName(taskId, title)
+  if (state.currentBranch !== branch)
+    throw new TaskBranchStop('TASK/BRANCH MISMATCH', {
+      expected: branch,
+      observed: state.currentBranch
+    })
+  if (!branch.startsWith(`codex/CU-${taskId}-`))
+    throw new TaskBranchStop('NAMESPACE VIOLATION', { branch })
+
+  const mainSha = git(['rev-parse', 'main'])
+  const remoteMain = git(
+    ['ls-remote', '--heads', 'origin', 'refs/heads/main'],
+    {
+      reason: 'REMOTE UNAVAILABLE'
+    }
+  )
+  const remoteMainSha = remoteMain ? remoteMain.split(/\s+/u)[0] : null
+  if (!remoteMainSha) throw new TaskBranchStop('REMOTE MAIN MISSING')
+  if (mainSha !== remoteMainSha)
+    throw new TaskBranchStop('MAIN BASELINE MISMATCH', {
+      local: mainSha,
+      remote: remoteMainSha
+    })
+  if (git(['merge-base', branch, 'main']) !== mainSha)
+    throw new TaskBranchStop('UNSAFE RESUME LINEAGE')
+  if (git(['rev-list', '--count', `main..${branch}`]) !== '0')
+    throw new TaskBranchStop('UNEXPECTED PICKUP COMMITS')
+
+  const remoteSha = remoteBranchSha(git, branch)
+  const upstream = git(
+    ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'],
+    { allowFailure: true }
+  )
+  if (remoteSha && remoteSha !== state.head)
+    throw new TaskBranchStop('REMOTE BRANCH DIVERGED')
+  if (remoteSha && upstream !== `origin/${branch}`)
+    throw new TaskBranchStop('UPSTREAM MISMATCH')
+  if (!remoteSha && upstream)
+    throw new TaskBranchStop('UPSTREAM WITHOUT REMOTE BRANCH')
+
+  return {
+    result: 'SAFE RESUME CANDIDATE',
+    branch,
+    head: state.head,
+    relationship: remoteSha ? 'remote-matching-with-upstream' : 'local-only',
+    stillRequires: [
+      'agent verification of the exact live ClickUp task',
+      'agent or human verification of task/branch/PR linkage',
+      'human review for any ambiguous collision'
+    ]
+  }
+}

package/hello-world.mjs

@@ -1 +0,0 @@
-export const helloWorld = 'hello world'