@cyber-dash-tech/revela 0.9.0 → 0.11.0

package/lib/workspace-state/actions.ts

@@ -0,0 +1,71 @@
+import { createHash } from "crypto"
+import type { DecksState } from "../decks-state"
+import type { WorkspaceAction, WorkspaceActionType } from "./types"
+
+export const MAX_WORKSPACE_ACTIONS = 500
+
+export interface WorkspaceActionInput {
+  type: WorkspaceActionType
+  actor?: string
+  inputs?: Record<string, unknown>
+  outputs?: Record<string, unknown>
+  status?: WorkspaceAction["status"]
+  summary?: string
+  nodeIds?: string[]
+  timestamp?: string
+}
+
+export function recordWorkspaceAction(state: DecksState, input: WorkspaceActionInput): DecksState {
+  const actions = state.actions ?? []
+  const timestamp = input.timestamp ?? new Date().toISOString()
+  const action: WorkspaceAction = {
+    id: workspaceActionId(input.type, timestamp, actions.length, input),
+    type: input.type,
+    timestamp,
+    status: input.status ?? "success",
+    ...(input.actor ? { actor: input.actor } : {}),
+    ...(input.inputs ? { inputs: compactActionPayload(input.inputs) } : {}),
+    ...(input.outputs ? { outputs: compactActionPayload(input.outputs) } : {}),
+    ...(input.summary ? { summary: input.summary } : {}),
+    ...(input.nodeIds && input.nodeIds.length > 0 ? { nodeIds: [...new Set(input.nodeIds)].sort() } : {}),
+  }
+
+  state.actions = [...actions, action].slice(-MAX_WORKSPACE_ACTIONS)
+  return state
+}
+
+export function compactActionPayload(input: Record<string, unknown>): Record<string, unknown> {
+  const output: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(input)) {
+    const compacted = compactActionValue(value)
+    if (compacted !== undefined) output[key] = compacted
+  }
+  return output
+}
+
+export function workspaceActionId(type: WorkspaceActionType, timestamp: string, sequence: number, input: Omit<WorkspaceActionInput, "timestamp">): string {
+  return `action:${timestamp}:${type}:${stableHash(JSON.stringify({ sequence, input: compactActionPayload(input as Record<string, unknown>) }))}`
+}
+
+function compactActionValue(value: unknown): unknown {
+  if (value === undefined || value === null) return undefined
+  if (typeof value === "string") {
+    const trimmed = value.trim()
+    if (!trimmed) return undefined
+    return trimmed.length > 500 ? `${trimmed.slice(0, 500).trimEnd()}... [truncated]` : trimmed
+  }
+  if (typeof value === "number" || typeof value === "boolean") return value
+  if (Array.isArray(value)) {
+    const items = value.map(compactActionValue).filter((item) => item !== undefined)
+    return items.length > 0 ? items.slice(0, 50) : undefined
+  }
+  if (typeof value === "object") {
+    const compacted = compactActionPayload(value as Record<string, unknown>)
+    return Object.keys(compacted).length > 0 ? compacted : undefined
+  }
+  return undefined
+}
+
+function stableHash(value: string): string {
+  return createHash("sha1").update(value).digest("hex").slice(0, 10)
+}

package/lib/workspace-state/compat.ts

@@ -0,0 +1,10 @@
+import type { DecksState } from "../decks-state"
+import type { DecksStateV1Projection, WorkspaceState } from "./types"
+
+export function isDecksStateV1(state: WorkspaceState): state is DecksState {
+  return state.version === 1
+}
+
+export function asDecksStateV1Projection(state: DecksState): DecksStateV1Projection {
+  return state
+}

package/lib/workspace-state/evidence-status.ts

@@ -0,0 +1,267 @@
+import {
+  applyEvidenceCandidates,
+  hasDecksState,
+  readDecksState,
+  reviewDeckState,
+  writeDecksState,
+  type AppliedEvidenceCandidate,
+  type DecksState,
+  type EvidenceBindingCandidate,
+  type EvidenceCandidateSearchDiagnostic,
+  type EvidenceRef,
+  type ReadinessIssue,
+  type SkippedEvidenceCandidate,
+} from "../decks-state"
+import { compileInspectionContext, type InspectionEvidenceTrace, type InspectionGap } from "../inspection-context/compile"
+import { matchInspectionElement, type InspectionElementMatch, type InspectionElementSnapshot, type InspectionMatchConfidence } from "../inspection-context/match"
+import { recordWorkspaceAction } from "./actions"
+import type { WorkspaceAction } from "./types"
+
+export interface EvidenceStatusForSelection {
+  version: 1
+  selection: EvidenceStatusSelection
+  match: EvidenceStatusMatch
+  boundEvidence: EvidenceStatusEvidence[]
+  gaps: EvidenceStatusGap[]
+  candidateEvidence: EvidenceStatusCandidate[]
+  searchDiagnostics: EvidenceCandidateSearchDiagnostic[]
+  actionTrace: EvidenceStatusActionTrace[]
+}
+
+export interface EvidenceStatusSelection {
+  slideIndex?: number
+  selectedText?: string
+  scope?: InspectionElementSnapshot["scope"]
+}
+
+export interface EvidenceStatusMatch {
+  confidence: InspectionMatchConfidence
+  reason: string
+  slideIndex?: number
+  slideTitle?: string
+  claimId?: string
+  claimText?: string
+  claimEvidenceSensitive?: boolean
+  claimEvidenceSupport?: string
+}
+
+export interface EvidenceStatusEvidence extends EvidenceRef {
+  slideIndex: number
+  slideTitle: string
+  hasDetail: boolean
+}
+
+export interface EvidenceStatusGap {
+  type: InspectionGap["type"]
+  slideIndex: number
+  slideTitle: string
+  claimText: string
+  message: string
+}
+
+export interface EvidenceStatusCandidate extends EvidenceBindingCandidate {
+  relevant: boolean
+}
+
+export interface EvidenceStatusActionTrace {
+  id: string
+  type: WorkspaceAction["type"]
+  timestamp: string
+  actor?: string
+  status: WorkspaceAction["status"]
+  summary?: string
+  inputs?: Record<string, unknown>
+  outputs?: Record<string, unknown>
+  nodeIds?: string[]
+}
+
+export interface ApplyEvidenceBindingsResult {
+  applied: AppliedEvidenceCandidate[]
+  skipped: SkippedEvidenceCandidate[]
+  nextReviewNeeded: boolean
+}
+
+export function getEvidenceStatusForSelection(workspaceRoot: string, snapshot: InspectionElementSnapshot, options: { slug?: string } = {}): EvidenceStatusForSelection {
+  if (!hasDecksState(workspaceRoot)) throw new Error("DECKS.json is required before checking evidence status. Run /revela init first.")
+  const state = readDecksState(workspaceRoot)
+  return getEvidenceStatusInState(state, snapshot, { ...options, workspaceRoot })
+}
+
+export function getEvidenceStatusInState(
+  state: DecksState,
+  snapshot: InspectionElementSnapshot,
+  options: { workspaceRoot?: string; slug?: string } = {},
+): EvidenceStatusForSelection {
+  const normalizedSnapshot = normalizeEvidenceSnapshot(snapshot)
+  const context = compileInspectionContext(state, options.slug)
+  const match = matchInspectionElement(context, normalizedSnapshot)
+  const reviewed = reviewDeckState(state, context.slug, { workspaceRoot: options.workspaceRoot })
+  const candidates = relevantCandidates(reviewed.result.evidenceCandidates ?? [], match)
+  const diagnostics = relevantSearchDiagnostics(reviewed.result.issues, match)
+
+  return {
+    version: 1,
+    selection: {
+      slideIndex: normalizedSnapshot.slideIndex,
+      selectedText: normalizedSnapshot.selectedText || normalizedSnapshot.text,
+      scope: normalizedSnapshot.scope,
+    },
+    match: projectMatch(match),
+    boundEvidence: match.evidence.map(projectEvidence),
+    gaps: evidenceStatusGaps(match, reviewed.result.issues),
+    candidateEvidence: candidates,
+    searchDiagnostics: diagnostics,
+    actionTrace: actionTraceForMatch(state.actions ?? [], match),
+  }
+}
+
+export function applyEvidenceBindings(workspaceRoot: string, candidateIds: string[]): ApplyEvidenceBindingsResult {
+  if (!hasDecksState(workspaceRoot)) throw new Error("DECKS.json is required before applying evidence bindings. Run /revela init first.")
+  const ids = [...new Set(candidateIds.map((id) => id.trim()).filter(Boolean))]
+  if (ids.length === 0) throw new Error("candidateIds are required for evidence binding application.")
+
+  const state = readDecksState(workspaceRoot)
+  const applied = applyEvidenceCandidates(state, ids, { workspaceRoot })
+  recordEvidenceBindingAction(applied.state, ids, applied.result)
+  writeDecksState(workspaceRoot, applied.state)
+  return applied.result
+}
+
+export function recordEvidenceBindingAction(state: DecksState, candidateIds: string[], result: ApplyEvidenceBindingsResult): DecksState {
+  return recordWorkspaceAction(state, {
+    type: "evidence.binding_applied",
+    actor: "revela-decks",
+    inputs: { candidateIds },
+    outputs: {
+      applied: result.applied.map((item) => ({ candidateId: item.candidateId, slideIndex: item.slideIndex, evidence: item.evidence })),
+      skipped: result.skipped,
+      nextReviewNeeded: result.nextReviewNeeded,
+    },
+    status: result.applied.length > 0 ? "success" : "skipped",
+    summary: `Applied ${result.applied.length} evidence candidate${result.applied.length === 1 ? "" : "s"}.`,
+    nodeIds: result.applied.map((item) => `slide:${item.slideIndex}`),
+  })
+}
+
+function normalizeEvidenceSnapshot(snapshot: InspectionElementSnapshot): InspectionElementSnapshot {
+  const selectedText = snapshot.selectedText || snapshot.text
+  return {
+    ...snapshot,
+    text: snapshot.text || selectedText,
+    selectedText,
+  }
+}
+
+function projectMatch(match: InspectionElementMatch): EvidenceStatusMatch {
+  return {
+    confidence: match.confidence,
+    reason: match.reason,
+    slideIndex: match.slide?.index,
+    slideTitle: match.slide?.title,
+    claimId: match.claim?.id,
+    claimText: match.claim?.text,
+    claimEvidenceSensitive: match.claim?.evidenceSensitive,
+    claimEvidenceSupport: match.claim?.evidenceSupport,
+  }
+}
+
+function projectEvidence(trace: InspectionEvidenceTrace): EvidenceStatusEvidence {
+  return {
+    ...trace,
+    slideIndex: trace.slideIndex,
+    slideTitle: trace.slideTitle,
+    hasDetail: trace.hasDetail,
+  }
+}
+
+function projectGap(gap: InspectionGap): EvidenceStatusGap {
+  return {
+    type: gap.type,
+    slideIndex: gap.slideIndex,
+    slideTitle: gap.slideTitle,
+    claimText: gap.claimText,
+    message: gap.message,
+  }
+}
+
+function evidenceStatusGaps(match: InspectionElementMatch, issues: ReadinessIssue[]): EvidenceStatusGap[] {
+  const gaps = match.gaps.map(projectGap)
+  const slideIndex = match.slide?.index
+  for (const issue of issues) {
+    if (issue.slideIndex !== slideIndex) continue
+    if (typeof issue.slideIndex !== "number") continue
+    if (issue.type !== "missing_evidence" && issue.type !== "weak_evidence") continue
+    if (gaps.some((gap) => gap.type === issue.type && gap.claimText === issue.claimText)) continue
+    gaps.push({
+      type: issue.type,
+      slideIndex: issue.slideIndex,
+      slideTitle: issue.slideTitle ?? match.slide?.title ?? "",
+      claimText: issue.claimText ?? match.claim?.text ?? "",
+      message: issue.message,
+    })
+  }
+  return gaps
+}
+
+function relevantCandidates(candidates: EvidenceBindingCandidate[], match: InspectionElementMatch): EvidenceStatusCandidate[] {
+  const slideIndex = match.slide?.index
+  return candidates
+    .filter((candidate) => candidate.slideIndex === slideIndex)
+    .map((candidate) => ({
+      ...candidate,
+      relevant: candidateRelevantToMatch(candidate, match),
+    }))
+}
+
+function candidateRelevantToMatch(candidate: EvidenceBindingCandidate, match: InspectionElementMatch): boolean {
+  const claimText = normalizeText(match.claim?.text)
+  if (!claimText || !candidate.claimText) return true
+  const candidateClaim = normalizeText(candidate.claimText)
+  if (candidateClaim === claimText || candidateClaim.includes(claimText) || claimText.includes(candidateClaim)) return true
+  const quote = normalizeText(candidate.quote)
+  if (quote.includes(claimText)) return true
+  return (candidate.supportScope ?? []).some((scope) => {
+    const normalizedScope = normalizeText(scope)
+    return normalizedScope === claimText || normalizedScope.includes(claimText) || claimText.includes(normalizedScope)
+  })
+}
+
+function relevantSearchDiagnostics(issues: ReadinessIssue[], match: InspectionElementMatch): EvidenceCandidateSearchDiagnostic[] {
+  const slideIndex = match.slide?.index
+  return issues
+    .filter((issue) => issue.slideIndex === slideIndex && issue.evidenceCandidateSearch)
+    .map((issue) => issue.evidenceCandidateSearch!)
+}
+
+function actionTraceForMatch(actions: WorkspaceAction[], match: InspectionElementMatch): EvidenceStatusActionTrace[] {
+  const slideNodeId = match.slide ? `slide:${match.slide.index}` : undefined
+  const evidenceKeys = new Set(match.evidence.flatMap((item) => [item.source, item.sourcePath, item.findingsFile].filter((value): value is string => Boolean(value))))
+  return actions
+    .filter((action) => actionRelevantToMatch(action, slideNodeId, evidenceKeys))
+    .slice(-12)
+    .map((action) => ({
+      id: action.id,
+      type: action.type,
+      timestamp: action.timestamp,
+      actor: action.actor,
+      status: action.status,
+      summary: action.summary,
+      inputs: action.inputs,
+      outputs: action.outputs,
+      nodeIds: action.nodeIds,
+    }))
+}
+
+function actionRelevantToMatch(action: WorkspaceAction, slideNodeId: string | undefined, evidenceKeys: Set<string>): boolean {
+  if (slideNodeId && action.nodeIds?.includes(slideNodeId)) return true
+  if (action.type === "evidence.binding_applied" || action.type === "evidence.candidate_generated") return true
+  const text = JSON.stringify({ inputs: action.inputs, outputs: action.outputs, nodeIds: action.nodeIds })
+  for (const key of evidenceKeys) {
+    if (key && text.includes(key)) return true
+  }
+  return false
+}
+
+function normalizeText(value: string | undefined): string {
+  return String(value ?? "").replace(/\s+/g, " ").trim().toLowerCase()
+}