Upload reports, review AI-assisted updates, and export revised documents.
+ ++ Reuse commonly referenced standards without re-uploading them for every session. +
+ + +Loading presets...
} + {isError &&Failed to load presets: {(error as Error).message}
} + {!isLoading && !presets.length &&No presets created yet.
} + {presets.length > 0 && ( ++ {preset.document_count} file{preset.document_count === 1 ? "" : "s"} · Updated{" "} + {new Date(preset.updated_at).toLocaleString()} +
+ {preset.description &&{preset.description}
} ++ Currently processing document {nextDoc} of {totalDocs}. +
+Processing pipeline... refreshing every 2s.
+ {pipelineProgress?.total ? ( ++ Pipeline stages:{" "} + {Math.min(pipelineProgress.current_index ?? 0, pipelineProgress.total)} /{" "} + {pipelineProgress.total} + {pipelineStageLabel ? ` — ${pipelineStageLabel}` : ""} + {pipelineStageStatus ? ` (${pipelineStageStatus})` : ""} +
+ ) : null} + {standardsProgressTotal !== undefined ? ( ++ Standards PDFs: {standardsProgressProcessed ?? 0} / {standardsProgressTotal} + {standardsProgressFile ? ` — ${standardsProgressFile}` : ""} + {standardsCachedCount !== undefined || standardsParsedCount !== undefined ? ( + <> + {" "}(cached {standardsCachedCount ?? 0}, parsed {standardsParsedCount ?? 0}) + + ) : null} +
+ ) : null} ++ Last error: {latest.last_error} +
+ )} +No activity recorded yet.
+ )} ++ Analysed {docSummary?.paragraph_count ?? docParse.paragraphs.length} paragraphs and{" "} + {docSummary?.table_count ?? docParse.tables.length} tables. +
+{extractionResult.document_summary}
+ )} + {extractionResult.references && extractionResult.references.length ? ( ++ References detected: {extractionResult.references.slice(0, 20).join(", ")} + {extractionResult.references.length > 20 ? "..." : ""} +
+ ) : null} + {sectionsPreview.length ? ( +{extractionResult.notes}
} ++ Showing {mappingsToDisplay.length} of {mappings.length} mappings. +
++ {mappingResult.notes ?? "No mapping actions recorded."} +
+ )} ++ Showing {replacementsToDisplay.length} of {replacements.length} replacements. +
+{rewritePlan.notes ?? "No rewrite actions required."}
+ )} + {tableReplacements.length ? ( +{rewritePlan.notes}
+ ) : null} ++ Verdict: {validationReport.verdict} +
+ )} + {validationReport.issues?.length ? ( +No validation issues reported.
+ )} + {validationReport.notes &&{validationReport.notes}
} ++ {exportManifest.notes ?? "Converted document generated using rewrite plan."} +
+ {typeof exportManifest.replacement_count === "number" && ( ++ {exportManifest.replacement_count} paragraph replacements applied. +
+ )} + + Download DOCX + + + ) : ( +{exportManifest.notes ?? "Export not yet generated."}
+ )} +Auto-refreshing every 5s.
++ {session.target_standard} {"->"} {session.destination_standard} +
++ {dateFormatter.format(new Date(session.created_at))} {" · "} + {session.source_doc.split(/[/\\]/).pop() ?? session.source_doc} +
++ Visual map of key storage locations, services, and external dependencies. Nodes pulse when recent activity + is detected. +
+Loading topology...
+ ) : topologyError ? ( +Failed to load topology: {(topologyErrorDetails as Error).message}
+ ) : ( + + )} +Update preset metadata and manage the associated PDF files.
+Loading preset details...
} + {isError &&Failed to load preset: {(error as Error).message}
} + {preset && ( + <> + + ++ Status: {preset.status} + {preset.status === "processing" && ( + <> + {" "} + · {processedDocs}/{totalDocs} processed + + )} +
+ {preset.last_error &&Last error: {preset.last_error}
} ++ Currently parsing document {nextDoc} of {totalDocs}. +
+No documents attached yet.
+ )} + +Enter your OpenAI API key to launch both the backend (uvicorn) and the frontend (npm run dev) in dedicated consoles.
+ +Loading status...+ +
Collecting setup log...+
[A-Z]{2,}[\s-]?\d{2,}(?:\.\d+)*)")
+HEADING_PATTERN = re.compile(r"Heading\s+(\d+)", re.IGNORECASE)
+
+
+@dataclass
+class ParagraphBlock:
+ index: int
+ text: str
+ style: Optional[str] = None
+ heading_level: Optional[int] = None
+ references: list[str] = field(default_factory=list)
+
+
+@dataclass
+class TableBlock:
+ index: int
+ rows: list[list[str]]
+ references: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DocxParseResult:
+ path: Path
+ paragraphs: list[ParagraphBlock] = field(default_factory=list)
+ tables: list[TableBlock] = field(default_factory=list)
+
+
+def parse_docx(path: Path) -> DocxParseResult:
+ if not path.exists():
+ raise FileNotFoundError(path)
+
+ document = Document(path)
+ result = DocxParseResult(path=path)
+
+ for idx, paragraph in enumerate(_iter_paragraphs(document.paragraphs)):
+ text = paragraph.text.strip()
+ if not text:
+ continue
+ references = _extract_references(text)
+ style_name = paragraph.style.name if paragraph.style else None
+ heading_level = _resolve_heading_level(style_name)
+ result.paragraphs.append(
+ ParagraphBlock(
+ index=idx,
+ text=text,
+ style=style_name,
+ heading_level=heading_level,
+ references=references,
+ )
+ )
+
+ for idx, docx_table in enumerate(document.tables):
+ rows: list[list[str]] = []
+ references: list[str] = []
+ for row in docx_table.rows:
+ cells_text = [_normalise_text(cell) for cell in row.cells]
+ rows.append(cells_text)
+ for value in cells_text:
+ references.extend(_extract_references(value))
+ result.tables.append(
+ TableBlock(
+ index=idx,
+ rows=rows,
+ references=sorted(set(references)),
+ )
+ )
+
+ return result
+
+
+def _resolve_heading_level(style_name: Optional[str]) -> Optional[int]:
+ if not style_name:
+ return None
+ match = HEADING_PATTERN.search(style_name)
+ if match:
+ try:
+ return int(match.group(1))
+ except ValueError:
+ return None
+ return None
+
+
+def _iter_paragraphs(paragraphs: Sequence[DocxParagraph]) -> Iterable[DocxParagraph]:
+ yield from paragraphs
+
+
+def _normalise_text(cell: DocxCell) -> str:
+ value = cell.text.strip()
+ return re.sub(r"\s+", " ", value)
+
+
+def _extract_references(value: str) -> list[str]:
+ return sorted({match.group("code") for match in REFERENCE_PATTERN.finditer(value)})
diff --git a/workers/pdf_processing/__init__.py b/workers/pdf_processing/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e916881832d43bcb9220d6f061e4cf6506e554d6
--- /dev/null
+++ b/workers/pdf_processing/__init__.py
@@ -0,0 +1,7 @@
+from .parser import PdfParseResult, PdfPageChunk, parse_pdf
+
+__all__ = [
+ "PdfParseResult",
+ "PdfPageChunk",
+ "parse_pdf",
+]
diff --git a/workers/pdf_processing/parser.py b/workers/pdf_processing/parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..70922588add7d3a8734fac37975f5c9ce4deca5c
--- /dev/null
+++ b/workers/pdf_processing/parser.py
@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import difflib
+import logging
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable, List, Optional
+
+import pdfplumber
+
+try:
+ import pytesseract
+except ImportError: # pragma: no cover - optional dependency
+ pytesseract = None
+
+logger = logging.getLogger(__name__)
+
+OCR_AVAILABLE = pytesseract is not None
+
+REFERENCE_PATTERN = re.compile(
+ r"(?P[A-Z]{2,}[\s-]?\d{2,}(?:\.\d+)*)"
+)
+CLAUSE_PATTERN = re.compile(r"\b\d+(?:\.\d+){1,3}\b")
+
+
+@dataclass
+class PdfPageChunk:
+ page_number: int
+ chunk_index: int
+ text: str
+ heading: Optional[str] = None
+ clause_numbers: list[str] = field(default_factory=list)
+ references: list[str] = field(default_factory=list)
+ is_ocr: bool = False
+
+
+@dataclass
+class PdfParseResult:
+ path: Path
+ chunks: list[PdfPageChunk] = field(default_factory=list)
+ ocr_pages: list[int] = field(default_factory=list)
+
+
+def parse_pdf(path: Path, *, max_chunk_chars: int = 1200) -> PdfParseResult:
+ if not path.exists():
+ raise FileNotFoundError(path)
+
+ result = PdfParseResult(path=path)
+
+ with pdfplumber.open(path) as pdf:
+ for page_number, page in enumerate(pdf.pages, start=1):
+ base_text = page.extract_text() or ""
+ ocr_text = ""
+ ocr_additions: list[str] = []
+
+ if OCR_AVAILABLE:
+ try:
+ image = page.to_image(resolution=300).original
+ ocr_text = pytesseract.image_to_string(image) or ""
+ ocr_additions = _extract_ocr_additions(base_text, ocr_text)
+ except Exception as exc: # noqa: BLE001
+ logger.warning("OCR failed for %s page %s: %s", path, page_number, exc)
+ ocr_text = ocr_text or ""
+ ocr_additions = []
+
+ chunk_counter = 0
+ base_text_stripped = base_text.strip()
+ if base_text_stripped:
+ for chunk in _chunk_text(base_text_stripped, max_chunk_chars):
+ references = _extract_references(chunk)
+ heading = _detect_heading(chunk)
+ clause_numbers = sorted({match.group(0) for match in CLAUSE_PATTERN.finditer(chunk)})
+ result.chunks.append(
+ PdfPageChunk(
+ page_number=page_number,
+ chunk_index=chunk_counter,
+ text=chunk,
+ heading=heading,
+ clause_numbers=clause_numbers,
+ references=references,
+ is_ocr=False,
+ )
+ )
+ chunk_counter += 1
+
+ additions_text = "\n".join(ocr_additions).strip()
+ if additions_text:
+ if page_number not in result.ocr_pages:
+ result.ocr_pages.append(page_number)
+ for chunk in _chunk_text(additions_text, max_chunk_chars):
+ references = _extract_references(chunk)
+ heading = _detect_heading(chunk)
+ clause_numbers = sorted({match.group(0) for match in CLAUSE_PATTERN.finditer(chunk)})
+ result.chunks.append(
+ PdfPageChunk(
+ page_number=page_number,
+ chunk_index=chunk_counter,
+ text=chunk,
+ heading=heading,
+ clause_numbers=clause_numbers,
+ references=references,
+ is_ocr=True,
+ )
+ )
+ chunk_counter += 1
+
+ if not base_text_stripped and not additions_text:
+ logger.debug("Skipping empty page %s in %s", page_number, path)
+
+ return result
+
+
+def _chunk_text(text: str, max_chunk_chars: int) -> Iterable[str]:
+ cleaned = re.sub(r"\s+", " ", text).strip()
+ if len(cleaned) <= max_chunk_chars:
+ yield cleaned
+ return
+
+ sentences = re.split(r"(?<=[\.\?!])\s+", cleaned)
+ buffer: List[str] = []
+ buffer_len = 0
+ for sentence in sentences:
+ sentence_len = len(sentence)
+ if buffer_len + sentence_len + 1 > max_chunk_chars and buffer:
+ yield " ".join(buffer).strip()
+ buffer = [sentence]
+ buffer_len = sentence_len
+ else:
+ buffer.append(sentence)
+ buffer_len += sentence_len + 1
+ if buffer:
+ yield " ".join(buffer).strip()
+
+
+def _extract_references(value: str) -> list[str]:
+ return sorted({match.group("code") for match in REFERENCE_PATTERN.finditer(value)})
+
+
+def _detect_heading(text: str) -> Optional[str]:
+ lines = text.splitlines()
+ for line in lines:
+ stripped = line.strip()
+ if not stripped:
+ continue
+ if stripped.isupper() or stripped.endswith(":") or _looks_like_clause(stripped):
+ return stripped[:200]
+ if len(stripped.split()) <= 8 and stripped == stripped.title():
+ return stripped[:200]
+ break
+ return None
+
+
+def _looks_like_clause(line: str) -> bool:
+ return bool(re.match(r"^\d+(\.\d+)*", line))
+
+
+def _extract_ocr_additions(base_text: str, ocr_text: str) -> list[str]:
+ """Return OCR lines not already present in the base extraction."""
+ if not ocr_text.strip():
+ return []
+ ocr_lines = _normalise_lines(ocr_text)
+ if not base_text.strip():
+ return ocr_lines
+ base_lines = _normalise_lines(base_text)
+ matcher = difflib.SequenceMatcher(a=base_lines, b=ocr_lines)
+ additions: list[str] = []
+ for tag, _i1, _i2, j1, j2 in matcher.get_opcodes():
+ if tag in ("replace", "insert"):
+ additions.extend(ocr_lines[j1:j2])
+ return additions
+
+
+def _normalise_lines(text: str) -> list[str]:
+ return [line.strip() for line in text.splitlines() if line.strip()]
diff --git a/workers/pipelines/bootstrap.py b/workers/pipelines/bootstrap.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8973f06f8aaedd3d38e6aeb34eb939158eae063
--- /dev/null
+++ b/workers/pipelines/bootstrap.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Awaitable, Callable
+
+from agents import (
+ ExportAgent,
+ ExtractionAgent,
+ OrchestratorAgent,
+ RewriteAgent,
+ StandardsMappingAgent,
+ ValidationAgent,
+)
+from agents.shared.base import AgentContext
+
+AgentFactory = Callable[[], Awaitable[dict]]
+
+
+async def bootstrap_pipeline_runner(session_id: str) -> None:
+ """Demonstrate how the agent chain could be invoked asynchronously."""
+ context = AgentContext(session_id=session_id, payload={})
+ orchestrator = OrchestratorAgent()
+ extraction = ExtractionAgent()
+ standards = StandardsMappingAgent()
+ rewrite = RewriteAgent()
+ validation = ValidationAgent()
+ export = ExportAgent()
+
+ await orchestrator.emit_debug("Bootstrapping placeholder pipeline.")
+
+ stage_outputs = []
+ stage_outputs.append(await orchestrator.run(context))
+ stage_outputs.append(await extraction.run(context))
+ stage_outputs.append(await standards.run(context))
+ stage_outputs.append(await rewrite.run(context))
+ stage_outputs.append(await validation.run(context))
+ stage_outputs.append(await export.run(context))
+
+ await orchestrator.emit_debug(f"Pipeline completed with {len(stage_outputs)} stage outputs.")
diff --git a/workers/queue/runner.py b/workers/queue/runner.py
new file mode 100644
index 0000000000000000000000000000000000000000..de33fcba1f45c3d1e8dc42226d67fb30dbf439af
--- /dev/null
+++ b/workers/queue/runner.py
@@ -0,0 +1,20 @@
+import asyncio
+from typing import Callable
+
+from .types import TaskHandler
+
+
+class InMemoryQueue:
+ """Simple FIFO queue that simulates background processing."""
+
+ def __init__(self) -> None:
+ self._handlers: dict[str, TaskHandler] = {}
+
+ def register(self, name: str, handler: TaskHandler) -> None:
+ self._handlers[name] = handler
+
+ async def enqueue(self, name: str, **payload) -> None:
+ handler = self._handlers.get(name)
+ if not handler:
+ raise ValueError(f"Handler not registered for task `{name}`")
+ await handler(**payload)
diff --git a/workers/queue/types.py b/workers/queue/types.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8c9e4137ab95581ed61654ae6438a795b6ac293
--- /dev/null
+++ b/workers/queue/types.py
@@ -0,0 +1,3 @@
+from typing import Awaitable, Callable
+
+TaskHandler = Callable[..., Awaitable[None]]