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
deleted file mode 100644
index e916881832d43bcb9220d6f061e4cf6506e554d6..0000000000000000000000000000000000000000
--- a/workers/pdf_processing/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-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
deleted file mode 100644
index 70922588add7d3a8734fac37975f5c9ce4deca5c..0000000000000000000000000000000000000000
--- a/workers/pdf_processing/parser.py
+++ /dev/null
@@ -1,175 +0,0 @@
-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
deleted file mode 100644
index d8973f06f8aaedd3d38e6aeb34eb939158eae063..0000000000000000000000000000000000000000
--- a/workers/pipelines/bootstrap.py
+++ /dev/null
@@ -1,39 +0,0 @@
-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
deleted file mode 100644
index de33fcba1f45c3d1e8dc42226d67fb30dbf439af..0000000000000000000000000000000000000000
--- a/workers/queue/runner.py
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index e8c9e4137ab95581ed61654ae6438a795b6ac293..0000000000000000000000000000000000000000
--- a/workers/queue/types.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from typing import Awaitable, Callable
-
-TaskHandler = Callable[..., Awaitable[None]]