sp2react 0.1.0__py3-none-any.whl

sp2react/spec/coverage.py

@@ -0,0 +1,191 @@
+"""Stage 4 gate: the spec may only be approved when it accounts for every 'must' behaviour.
+
+Returns plain-language problems; the spec agent gets them back verbatim on retry.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from .model import NEEDS_FIELD, NEEDS_MESSAGE, RULE_PARAMS, Spec
+
+OPS = {"eq", "ne", "in", "nin", "gt", "gte", "lt", "lte", "empty", "notEmpty", "changed"}
+COMPARE_OPS = {"eq", "ne", "gt", "gte", "lt", "lte"}
+ENDPOINT_PATH = re.compile(r"^/api/[A-Za-z0-9_\-/{}.]+$")
+
+
+@dataclass
+class CoverageReport:
+    ok: bool
+    problems: list[str] = field(default_factory=list)
+    covered: int = 0
+    must: int = 0
+    not_carried: int = 0
+    matrix: list[dict] = field(default_factory=list)   # behavior -> what covers it
+
+    def summary(self) -> str:
+        return f"{self.covered}/{self.must} required behaviours covered ({self.not_carried} not carried, with reasons); {len(self.problems)} problem(s)"
+
+
+def _norm(msg: str) -> str:
+    m = re.sub(r"\{[^{}]*\}", "{}", msg or "")
+    return re.sub(r"\s+", " ", m).strip()
+
+
+def _condition_problems(cond: Any, fields: set[str], groups: set[str], where: str) -> list[str]:
+    out = []
+    if not isinstance(cond, dict) or not cond:
+        return [f"{where}: condition must be a non-empty object"]
+    keys = set(cond)
+    if keys & {"all", "any"}:
+        k = "all" if "all" in cond else "any"
+        if not isinstance(cond[k], list) or not cond[k]:
+            return [f"{where}: '{k}' needs a non-empty list"]
+        for i, c in enumerate(cond[k]):
+            out += _condition_problems(c, fields, groups, f"{where}.{k}[{i}]")
+        return out
+    if "not" in keys:
+        return _condition_problems(cond["not"], fields, groups, f"{where}.not")
+    if "role" in keys:
+        if cond["role"] not in groups:
+            out.append(f"{where}: role '{cond['role']}' is not one of the spec roles {sorted(groups)}")
+        return out
+    if "mode" in keys:
+        ms = cond["mode"] if isinstance(cond["mode"], list) else [cond["mode"]]
+        bad = [m for m in ms if m not in ("new", "edit", "display")]
+        return [f"{where}: unknown mode {bad}"] if bad else []
+    if "field" in keys:
+        f = str(cond["field"]).split(".")[0]
+        if f not in fields and f not in ("ID", "Author", "Editor", "Created", "Modified"):
+            out.append(f"{where}: field '{cond['field']}' does not exist")
+        ops = keys - {"field"}
+        if not ops or not ops <= OPS:
+            out.append(f"{where}: needs one operator from {sorted(OPS)}, got {sorted(ops)}")
+        return out
+    return [f"{where}: unknown condition shape {sorted(keys)} (use field/role/mode/all/any/not)"]
+
+
+def check(spec: Spec, inv: dict) -> CoverageReport:
+    problems: list[str] = []
+    behaviors = {b["id"]: b for b in inv["behaviors"]}
+    must = {k: b for k, b in behaviors.items() if b["level"] == "must"}
+    covers = spec.all_covers()
+
+    # 1. no invented ids
+    for cid, by in covers.items():
+        if cid not in behaviors:
+            problems.append(f"{by[0]} covers '{cid}', which is not in the inventory. Use ids exactly as listed.")
+
+    # 2. every must behaviour is accounted for
+    matrix = []
+    for bid, b in must.items():
+        by = covers.get(bid, [])
+        matrix.append({"behavior": bid, "kind": b["kind"], "covered_by": by})
+        if not by:
+            hint = f" message: \"{b['message']}\"" if b.get("message") else ""
+            problems.append(f"Not covered: {bid} ({b['kind']}, `{b.get('code', '')[:90]}`){hint}")
+
+    # 3. messages are carried verbatim by whatever covers the behaviour
+    texts: list[str] = []
+
+    def collect(v) -> None:
+        if isinstance(v, str):
+            texts.append(_norm(v))
+        elif isinstance(v, dict):
+            for x in v.values():
+                collect(x)
+        elif isinstance(v, list):
+            for x in v:
+                collect(x)
+
+    for r in spec.rules:
+        if r.message:
+            texts.append(_norm(r.message))
+        collect(r.params)
+    for c in spec.screen.components:
+        collect(c.props)
+    not_carried_ids = {c for n in spec.not_carried for c in n.covers}
+    for bid, b in must.items():
+        if bid in not_carried_ids:
+            continue
+        msgs = [b["message"]] if b.get("message") else list((b.get("detail") or {}).get("messages", []))
+        for m in msgs:
+            if _norm(m) and _norm(m) not in texts:
+                problems.append(f"Message from {bid} is not carried verbatim. Use exactly: \"{m}\" (placeholders like {{name}} may differ)")
+
+    # 4. rules are well formed
+    fields_by_list = {k: {f["name"] for f in v.fields} for k, v in spec.lists.items()}
+    groups = set(spec.roles)
+    ids = set()
+    for r in spec.rules:
+        where = f"rule {r.id}"
+        if r.id in ids:
+            problems.append(f"{where}: duplicate rule id")
+        ids.add(r.id)
+        lst = r.list or spec.screen.list
+        flds = fields_by_list.get(lst or "", set())
+        if r.kind in NEEDS_FIELD and not r.field:
+            problems.append(f"{where}: kind '{r.kind}' needs 'field'")
+        if r.field and r.field not in flds:
+            problems.append(f"{where}: field '{r.field}' is not in list {lst}")
+        for p in RULE_PARAMS.get(r.kind, ()):
+            if p not in r.params:
+                problems.append(f"{where}: kind '{r.kind}' needs params.{p}")
+        if r.kind in NEEDS_MESSAGE and not r.message:
+            problems.append(f"{where}: kind '{r.kind}' needs a message")
+        if r.kind in ("compare",) and r.params.get("other") and r.params["other"] not in flds:
+            problems.append(f"{where}: params.other '{r.params['other']}' is not in list {lst}")
+        if r.kind in ("compare", "length", "range") and r.params.get("op") not in COMPARE_OPS:
+            problems.append(f"{where}: params.op must be one of {sorted(COMPARE_OPS)}")
+        if r.kind == "derive":
+            src = r.params.get("from_field")
+            if src not in flds:
+                problems.append(f"{where}: params.from_field '{src}' is not in list {lst}")
+            else:
+                f = next(x for x in spec.lists[lst].fields if x["name"] == src)
+                target = (f.get("lookup") or {}).get("list")
+                if not target:
+                    problems.append(f"{where}: params.from_field '{src}' must be a lookup field")
+                elif target in spec.lists and r.params.get("column") not in fields_by_list[target]:
+                    problems.append(f"{where}: params.column '{r.params.get('column')}' is not a field of {target}")
+        if r.kind == "cascade":
+            for p in ("parent",):
+                if r.params.get(p) not in flds:
+                    problems.append(f"{where}: params.{p} '{r.params.get(p)}' is not in list {lst}")
+        if r.kind == "on_save":
+            act = r.params.get("action")
+            if not isinstance(act, dict) or act.get("type") not in ("create_item", "update_item", "custom"):
+                problems.append(f"{where}: params.action must be an object with type create_item | update_item | custom")
+            elif act.get("type") == "create_item" and act.get("list") not in spec.lists:
+                problems.append(f"{where}: params.action.list '{act.get('list')}' is not one of the spec lists")
+        if r.when is not None:
+            problems += _condition_problems(r.when, flds, groups, f"{where}.when")
+        if r.covers and not r.src and r.origin == "agent":
+            problems.append(f"{where}: covers behaviours but has no src (file:line)")
+
+    # 5. endpoints and components
+    eids = set()
+    for e in spec.endpoints:
+        if e.id in eids:
+            problems.append(f"endpoint {e.id}: duplicate id")
+        eids.add(e.id)
+        if not ENDPOINT_PATH.match(e.path):
+            problems.append(f"endpoint {e.id}: path '{e.path}' must start with /api/ and contain only path characters")
+        for g in e.roles:
+            if g not in groups:
+                problems.append(f"endpoint {e.id}: role '{g}' is not one of the spec roles")
+    for c in spec.screen.components:
+        for d in c.data:
+            if d not in eids:
+                problems.append(f"component {c.id}: data '{d}' is not an endpoint id")
+        for g in c.roles:
+            if g not in groups:
+                problems.append(f"component {c.id}: role '{g}' is not one of the spec roles")
+    for n in spec.not_carried:
+        if len(n.reason.strip()) < 15:
+            problems.append(f"not_carried {n.covers}: give a real reason (why the new app does not need it)")
+
+    covered = sum(1 for m in matrix if m["covered_by"] and m["covered_by"] != ["not_carried"])
+    nc = sum(1 for m in matrix if m["covered_by"] == ["not_carried"])
+    return CoverageReport(ok=not problems, problems=problems, covered=covered + nc, must=len(must), not_carried=nc, matrix=matrix)

sp2react/spec/model.py

@@ -0,0 +1,133 @@
+"""The screen spec: the single contract between analysis, agents, code generation and the runtime.
+
+The generated app interprets rules at runtime (same engine in TypeScript and Python), so a rule
+written once is enforced in the browser and again on the server.
+"""
+from __future__ import annotations
+
+import builtins
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+Mode = Literal["new", "edit", "display"]
+
+RULE_KINDS = (
+    "visible", "required", "readonly", "default", "derive", "cascade", "compare", "length", "range", "pattern",
+    "unique", "set_on_save", "lock_item", "on_save", "banner", "confirm", "navigate", "custom",
+)
+
+# params each rule kind must carry
+RULE_PARAMS: Dict[str, tuple[str, ...]] = {
+    "default": ("value",),
+    "derive": ("from_field", "column"),
+    "cascade": ("parent", "via"),
+    "compare": ("op", "other"),
+    "length": ("op", "value"),
+    "range": ("op", "value"),
+    "pattern": ("regex",),
+    "set_on_save": ("value",),
+    "on_save": ("action",),
+    "navigate": ("to",),
+    "custom": ("handler", "description"),
+}
+NEEDS_FIELD = {"visible", "required", "readonly", "default", "derive", "cascade", "compare", "length", "range", "pattern", "unique", "set_on_save"}
+NEEDS_MESSAGE = {"compare", "length", "range", "pattern", "unique", "lock_item", "banner", "confirm"}
+
+
+class Rule(BaseModel):
+    id: str
+    kind: Literal[RULE_KINDS]  # type: ignore[valid-type]
+    field: Optional[str] = None
+    list: Optional[str] = None                     # defaults to the screen's primary list
+    modes: List[Mode] = Field(default_factory=builtins.list)  # empty = every mode
+    when: Optional[Dict[str, Any]] = None
+    message: Optional[str] = None                  # verbatim legacy text; {field} placeholders allowed
+    presentation: Literal["inline", "alert", "banner", "confirm"] = "inline"
+    params: Dict[str, Any] = Field(default_factory=builtins.dict)
+    covers: List[str] = Field(default_factory=builtins.list)
+    src: List[str] = Field(default_factory=builtins.list)   # "file:line" references into the legacy source
+    origin: Literal["schema", "inventory", "agent"] = "agent"
+    note: Optional[str] = None
+
+
+class Endpoint(BaseModel):
+    id: str
+    method: Literal["GET", "POST", "PATCH", "DELETE"]
+    path: str
+    purpose: str
+    list: Optional[str] = None
+    query: Dict[str, Any] = Field(default_factory=builtins.dict)   # filter/select/expand/orderby/top in the API's OData subset
+    body: List[str] = Field(default_factory=builtins.list)
+    roles: List[str] = Field(default_factory=builtins.list)        # SharePoint group names allowed; empty = any signed-in user
+    custom: bool = False                                  # needs an agent-written handler (not the generic list API)
+    covers: List[str] = Field(default_factory=builtins.list)
+    src: List[str] = Field(default_factory=builtins.list)
+
+
+class Component(BaseModel):
+    id: str
+    kind: Literal["form", "tiles", "table", "list_view", "banner", "html", "actions", "custom"]
+    title: Optional[str] = None
+    region: Optional[str] = None                   # zone / column, to keep the legacy layout
+    order: int = 0
+    data: List[str] = Field(default_factory=builtins.list)  # endpoint ids this component reads/writes
+    props: Dict[str, Any] = Field(default_factory=builtins.dict)
+    roles: List[str] = Field(default_factory=builtins.list) # visible only to these SharePoint groups
+    covers: List[str] = Field(default_factory=builtins.list)
+    src: List[str] = Field(default_factory=builtins.list)
+
+
+class Screen(BaseModel):
+    id: str
+    kind: Literal["list-form", "page"]
+    title: str
+    route: str
+    legacy_urls: List[str] = Field(default_factory=builtins.list)
+    list: Optional[str] = None
+    modes: List[Mode] = Field(default_factory=builtins.list)
+    components: List[Component] = Field(default_factory=builtins.list)
+    stylesheets: List[str] = Field(default_factory=builtins.list)
+    covers: List[str] = Field(default_factory=builtins.list)
+
+
+class ListSpec(BaseModel):
+    title: str
+    primary: bool = False
+    fields: List[Dict[str, Any]]
+    attachments: bool = False
+    views: Dict[str, Any] = Field(default_factory=builtins.dict)
+
+
+class NotCarried(BaseModel):
+    covers: List[str]
+    reason: str
+
+
+class Spec(BaseModel):
+    version: int = 1
+    screen: Screen
+    lists: Dict[str, ListSpec]
+    rules: List[Rule] = Field(default_factory=builtins.list)
+    endpoints: List[Endpoint] = Field(default_factory=builtins.list)
+    roles: List[str] = Field(default_factory=builtins.list)       # SharePoint groups the screen checks
+    not_carried: List[NotCarried] = Field(default_factory=builtins.list)
+    open_questions: List[str] = Field(default_factory=builtins.list)
+
+    def all_covers(self) -> Dict[str, List[str]]:
+        out: Dict[str, List[str]] = {}
+        for r in self.rules:
+            for c in r.covers:
+                out.setdefault(c, []).append(f"rule:{r.id}")
+        for e in self.endpoints:
+            for c in e.covers:
+                out.setdefault(c, []).append(f"endpoint:{e.id}")
+        for comp in self.screen.components:
+            for c in comp.covers:
+                out.setdefault(c, []).append(f"component:{comp.id}")
+        for c in self.screen.covers:
+            out.setdefault(c, []).append("screen")
+        for n in self.not_carried:
+            for c in n.covers:
+                out.setdefault(c, []).append("not_carried")
+        return out

sp2react-0.1.0.dist-info/METADATA

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: sp2react
+Version: 0.1.0
+Summary: AI-agent pipeline that converts classic SharePoint ASPX/jQuery list forms and pages into a React + FastAPI app on your existing database
+Author: Karthikeyan Balasundaram
+License: MIT
+Project-URL: Homepage, https://github.com/karthikbd/sp2react
+Project-URL: Source Code, https://github.com/karthikbd/sp2react
+Project-URL: Repository, https://github.com/karthikbd/sp2react
+Project-URL: Bug Tracker, https://github.com/karthikbd/sp2react/issues
+Project-URL: Changelog, https://github.com/karthikbd/sp2react/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/karthikbd/sp2react#readme
+Keywords: sharepoint,sharepoint migration,react,fastapi,jquery,spservices,aspx,list forms,migration,code conversion,ai agents,claude
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.5
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: requests>=2.31
+Provides-Extra: ntlm
+Requires-Dist: requests-ntlm>=1.2; extra == "ntlm"
+Provides-Extra: db
+Requires-Dist: sqlalchemy>=2.0; extra == "db"
+Provides-Extra: mysql
+Requires-Dist: sqlalchemy>=2.0; extra == "mysql"
+Requires-Dist: pymysql>=1.1; extra == "mysql"
+Provides-Extra: mssql
+Requires-Dist: sqlalchemy>=2.0; extra == "mssql"
+Requires-Dist: pyodbc>=5.0; extra == "mssql"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: fastapi>=0.110; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Requires-Dist: uvicorn>=0.27; extra == "dev"
+Requires-Dist: sqlalchemy>=2.0; extra == "dev"
+Dynamic: license-file
+
+# sp2react
+
+[![PyPI version](https://badge.fury.io/py/sp2react.svg)](https://pypi.org/project/sp2react/)
+[![Python versions](https://img.shields.io/pypi/pyversions/sp2react.svg)](https://pypi.org/project/sp2react/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/karthikbd/sp2react/badge)](https://securityscorecards.dev/viewer/?uri=github.com/karthikbd/sp2react)
+
+Convert classic SharePoint (2013 / 2016 / 2019 / Subscription Edition) list forms and pages built with **ASPX, jQuery and SPServices** into a **React + FastAPI** app that runs on **your existing database**.
+
+Plain code does everything mechanical. AI agents (Claude through your GitHub Copilot **Bridger** by default) do the parts that need judgement. Nothing an agent writes is accepted until it passes automatic checks.
+
+**No business data over HTTP:** in the default `database` mode, list items, attachments and people are never read from SharePoint, and every request is checked against the hosts in your config.
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [The ten stages](#the-ten-stages)
+- [Your existing database](#your-existing-database)
+- [The generated app](#the-generated-app)
+- [Use it from your own tool](#use-it-from-your-own-tool)
+- [What converts and what does not](#what-converts-and-what-does-not)
+- [Running Tests](#running-tests)
+- [CI / CD](#ci--cd)
+- [Security](#security)
+- [Changelog](#changelog)
+- [License](#license)
+
+---
+
+## Installation
+
+```bash
+pip install "sp2react[mysql]"     # MySQL / MariaDB tables
+pip install "sp2react[mssql]"     # SQL Server tables
+pip install "sp2react[ntlm]"      # add for on-premises Windows authentication
+```
+
+Python 3.10+. Node.js 20+ is needed to build the generated React app.
+
+## Quick Start
+
+```bash
+sp2react init                                   # writes sp2react.yaml
+export SP_USERNAME='CORP\me' SP_PASSWORD='...'  # or SP_COOKIE / SP_TOKEN
+export BRIDGER_TOKEN='...'                      # only if Bridger needs one
+export SP2REACT_DB_URL='mysql+pymysql://user:password@db-host:3306/sea'
+
+sp2react doctor                                 # checks SharePoint, lists Bridger's Claude models
+sp2react run --page /sites/SEA/SitePages/Dashboard.aspx --until spec
+#   review sp2react-work/specs/<screen>.coverage.md, then:
+sp2react approve Dashboard
+sp2react map-db                                 # drafts db-mapping.json; review db-mapping.md
+sp2react run --page /sites/SEA/SitePages/Dashboard.aspx --offline
+sp2react status
+```
+
+## Configuration
+
+```yaml
+sharepoint:
+  site_url: https://sharepoint.example.com/sites/SEA
+  auth: ntlm                 # ntlm | cookie | bearer | none ; secrets come from environment variables
+llm:
+  provider: bridger          # bridger | anthropic | openai | azure_openai
+  api_format: anthropic      # how Bridger serves Claude: anthropic (/v1/messages) or openai (/v1/chat/completions)
+  base_url: http://localhost:4141
+  model: claude-sonnet-4     # exact id from `sp2react doctor`
+  api_key_env: BRIDGER_TOKEN
+pipeline:
+  data_source: database      # database | sqlite | sharepoint
+  max_concurrency: 4
+  max_fix_iterations: 5
+database:
+  url_env: SP2REACT_DB_URL
+  mapping: ./db-mapping.json
+security:
+  allowed_hosts: []
+```
+
+## The ten stages
+
+Each stage starts only after the previous one has finished.
+
+| # | Stage | Who | What happens | Checked by |
+|---|---|---|---|---|
+| 1 | inputs | code | config and connectivity | |
+| 2 | extract | code | `.aspx` source, browser-added web parts, Script Editor / Content Editor content, JSLink, custom JS/CSS, list schemas, views, forms, group names, navigation. GET only | manifest of fetched files and errors |
+| 3 | inventory | code | groups each list's New/Edit/Display forms into one screen and finds every jQuery behaviour and data call, with file:line | deterministic |
+| 4 | spec | **agent** | builds the base spec from the schema, then the agent adds the rules that need interpretation | **coverage gate**: every required behaviour covered, legacy texts verbatim, rules valid |
+| 5 | approve_spec | you | read `specs/<screen>.coverage.md` | |
+| 6 | convert | code + **agents** | writes the fixed scaffold in seconds. List forms are rendered by the shared form engine from the spec; agents write only page components and custom handlers, in parallel | import whitelist, no fetch/jQuery/innerHTML, legacy texts present, `tsc` |
+| 7 | review | **agent** | independent parity review | findings fed to fix |
+| 8 | test | code | generated API tests, rule vectors (browser and API engines must agree), `tsc` + `vite build`, data reconciliation | |
+| 9 | fix | **agent** | gets the real compiler and test output and edits only agent-owned files; up to N rounds | re-test |
+| 10 | approve | you | | |
+
+## Your existing database
+
+If your team has already moved the list data into MySQL or SQL Server, the generated FastAPI app reads and writes those tables directly.
+
+1. `sp2react map-db` reads the database **schema only** (tables, columns, types, keys).
+2. It drafts the mapping: each list to a table, each field to a column, lookups to foreign keys, people to a users table or login column, plus created/modified/author/editor/version columns and attachments.
+3. The `dbmap` agent resolves what the draft could not, for example `Countries.Title` migrated as `countries.country_name`.
+4. Validation blocks code generation until every table and column exists and every required field is mapped.
+5. You review `db-mapping.md`, and can edit `db-mapping.json` directly.
+
+At runtime, OData-style queries from the forms and pages (`$filter`, `$orderby`, `$top`, lookup paths such as `Country/Title`) are translated to SQL. Optimistic concurrency uses your version column if you have one, otherwise the modified timestamp.
+
+To check the earlier migration, set `security.sharepoint_item_reads: true`. `reconciliation.md` then compares every list item with its row, field by field, including orphaned lookups and attachment checksums.
+
+## The generated app
+
+```bash
+cd converted-app/backend && pip install -r requirements.txt pymysql && cp .env.example .env && uvicorn app.main:app
+cd converted-app/frontend && npm install && npm run dev
+```
+
+- Behaviour comes from the spec at runtime. `runtime/rules.ts` (browser) and `app/rules.py` (API) interpret the same rules, and shared vectors keep them in agreement, so a direct API call cannot bypass a rule.
+- The form uses SharePoint's layout, labels and control titles, the legacy site CSS is carried over, and old URLs (`/Lists/X/EditForm.aspx?ID=3&Source=...`) redirect to the new routes.
+- SharePoint groups become roles. Membership comes from your users/groups tables or `data/roles.json`.
+- Authentication: `AUTH_MODE=dev` for local work; `header` behind your gateway, or Entra ID in `app/auth.py`.
+
+## Use it from your own tool
+
+```python
+from sp2react import Pipeline, load_config
+
+p = Pipeline(load_config("sp2react.yaml"), progress=print)
+p.stage_inputs(offline=False)
+p.stage_extract(pages=["SitePages/Dashboard.aspx"], offline=False)
+screens = [s["id"] for s in p.stage_inventory(["SitePages/Dashboard.aspx"])]
+p.stage_spec(screens)
+p.approve("Dashboard", "spec", by="reviewer")
+p.stage_map_db([p.load_spec(s) for s in p.approved_sids()])
+p.stage_convert(screens)
+p.stage_review(screens)
+p.stage_test_and_fix(screens)
+p.state            # also written to sp2react-work/state.json
+```
+
+## What converts and what does not
+
+| Converts | Needs your input, or is not converted yet |
+|---|---|
+| List forms (New/Edit/Display) and their jQuery/SPServices behaviour | Workflows, event receivers, compiled solutions: their code is not reachable over REST. They are flagged; export the definitions or source to convert them |
+| Web part pages (SitePages) with Script Editor / Content Editor JavaScript | InfoPath and Power Apps forms: reported, not converted |
+| Basic list views (columns, sort, row limit) | Views with filters and grouping, document libraries, custom master-page branding, rich grids (sort/search/select/export), modal dialogs: planned |
+| SharePoint groups as roles, old URL redirects | Calculated columns are shown but not recomputed; managed metadata, item-level permissions, alert emails |
+
+Run the inventory on your site first. It shows which pages and scripts were found and what each one does, before you commit to a conversion.
+
+## Running Tests
+
+```bash
+pip install -e ".[dev]"
+python -m pytest tests/ -v
+```
+
+The suite runs against `tests/fixtures/legacy-site`, a fictional Contoso procurement site with jQuery 1.12 / SPServices list forms and a REST-driven dashboard. It covers:
+- a mock SharePoint server that rejects writes,
+- a scripted stand-in for the model, including retry-on-feedback and give-up,
+- a renamed-schema database standing in for an earlier migration,
+- the network policy,
+- all ten stages including the fix loop,
+- a real `npm install` + `tsc` + `vite build` of the generated app.
+
+## CI / CD
+
+- `tests.yml`: runs the test suite on Python 3.10–3.13 on every push and pull request.
+- `python-publish.yml`: on a `v*` tag or a published release, tests, builds and publishes to PyPI through **Trusted Publishing** (OIDC, no stored token).
+- `scorecard.yml`: runs the OpenSSF Scorecard weekly and on every push to `main`.
+
+## Security
+
+See [SECURITY.md](SECURITY.md). In short:
+- Requests go only to the configured SharePoint and model hosts, and SharePoint is read-only.
+- In database mode no list data is read over HTTP and no business data is sent to the model.
+- Secrets come from environment variables only.
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

sp2react-0.1.0.dist-info/RECORD

@@ -0,0 +1,79 @@
+sp2react/__init__.py,sha256=FDxCRQtOt-rap-xgysEsnr_vDa7wnlZLrosQdTUJLWA,532
+sp2react/checks.py,sha256=tAMN1E1zeLs43UVHx_gXbPlx3R3Q_iaVinibYvM-IoI,4449
+sp2react/cli.py,sha256=_6LWDY6RuM9UG-Rgvhrbd96_OgBD721nZLz0CZePDXc,7807
+sp2react/config.py,sha256=JzKJYv9vu5qu0L30cKkMKG3CNl_Xn5zi-m7meHY0mTY,8231
+sp2react/dbmap.py,sha256=ePbC6SqIw23QLQV-FaLKfbeBsRQidIOc4mGC1Mqc668,13008
+sp2react/migrate.py,sha256=Hwz6FEJOz4STgZL5t0ZNFSdoMNdJF1enmkJVZQC1Tm8,12965
+sp2react/net.py,sha256=AXb_KYGObXqFMGMho3ujUXRqky3ce0U6mLQ9iUlnSJg,2173
+sp2react/pipeline.py,sha256=-9dFY2X6rew_PsiGOxayJ6cL3v9JZS9wHXOcSCVwb48,32489
+sp2react/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sp2react/agents/core.py,sha256=I5aXzWZ_P0JKz8F_FdgS7eznGfed4PGU6QHB19t9_1Y,6491
+sp2react/agents/tasks.py,sha256=jskE3DHZYyYsbihTTDD91LfcxWqPcFo7H5sBH5lW4LI,18957
+sp2react/agents/prompts/dbmap.md,sha256=ueAf3oF1-aCy6R0o9nCb2wGlYFF-tmZm4aA8BMSKoQk,2196
+sp2react/agents/prompts/fix.md,sha256=quMBtSHJBNN1yrV9zu1DVNt0St5p3wJk_C2LxzawRJc,1052
+sp2react/agents/prompts/handler.md,sha256=MfkEBI_tlgsHG9mxd6FhzJDg58bQcydatbcV0AnoZ5A,1595
+sp2react/agents/prompts/page.md,sha256=KpsgI16t89VwC1PBX2p2EWKuwkTT_FsuvinO2KBqfbk,3941
+sp2react/agents/prompts/review.md,sha256=Wz8DQ39Py3CNEiunlS14XVHjdvREbZVZqpQ-ZCnR6ok,1527
+sp2react/agents/prompts/spec.md,sha256=y4LHQ3qkF3zXuRXsdHdxMc6pk4DLBcw8QDVnxjmHy3g,8076
+sp2react/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sp2react/analysis/aspx.py,sha256=ru70jioqpjU63I5M_UpQPHQnM1CrQ-OLaBbhJRrqvC0,11633
+sp2react/analysis/behaviors.py,sha256=EJhq631aik0siqLCX1rAQ6iqJwcw-7shLcQ7o0oNBWo,17577
+sp2react/analysis/fields.py,sha256=khJB3aV-KDCJBaRG-Zlj69rk_aj7dMfZBHoEck_KODE,8001
+sp2react/analysis/inventory.py,sha256=EhFRiDWwps39jvmDO8X8FPMT8kcoC5g34hoZcwgH1DI,16976
+sp2react/analysis/jsscan.py,sha256=y2ziAQb6Oy-U-MknNtxp8YfGpFq0D3HX2pVaSnqFS6I,12064
+sp2react/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sp2react/llm/providers.py,sha256=u7w3hw1xSJdPSv_ESWChagk1bWbsWoN6pmo-3WNHDIQ,9557
+sp2react/scaffold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sp2react/scaffold/generate.py,sha256=m29FjkidbI1iQdt_kCP6bU5XwOJwno4BpwMR2N10IKc,13752
+sp2react/scaffold/rule_vectors.json,sha256=wc6qbyH-01hXlwLwInuPhvnsaxkjRr6znEeZZF8O__U,65256
+sp2react/scaffold/templates/backend/requirements.txt,sha256=Hyyb3onxzWHnfJdrZoBg2vgxijxjFXnPeFPARuXG2Ew,338
+sp2react/scaffold/templates/backend/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sp2react/scaffold/templates/backend/app/api.py,sha256=6EiiBRu-NHxs37jBf_hh2h37NZNoDsrAStbBhwqpc14,14509
+sp2react/scaffold/templates/backend/app/auth.py,sha256=Cm7y47iANYeYUPRTljD-YDUczcILwyMTmJWxxT5mqg8,1594
+sp2react/scaffold/templates/backend/app/main.py,sha256=yZoj_SGFw9zeVd1ttcfKN5B5XlBp9-uAxfZ1E3apNU8,1805
+sp2react/scaffold/templates/backend/app/odata.py,sha256=kUR5Dmp8bIV10NV6gmW2zmQSpCFsIp8qvTXr15lVIes,6469
+sp2react/scaffold/templates/backend/app/rules.py,sha256=cf8528TJgqIkg8inW7585Z1vYIJp0rEKz5hAUikaDM0,11093
+sp2react/scaffold/templates/backend/app/sp_repo.py,sha256=U9jKo45uTCpopb5Rj9R3Gl27iQjVOUoUEgrK6yMz8WQ,8103
+sp2react/scaffold/templates/backend/app/sql_repo.py,sha256=KG_fau-o69FthBvQeQwH5a2S0nAJIwnXsroYzJ7NU04,20247
+sp2react/scaffold/templates/backend/app/store.py,sha256=JJGSpgwdmvop1n9UCoeUz6pgnWSZ3LeE_oHuVx5NTnY,11081
+sp2react/scaffold/templates/backend/app/custom/__init__.py,sha256=TC05h9ehKDLJhkVyN1wnYAEke_cBsMNQ7_n8D2Hd8vs,820
+sp2react/scaffold/templates/backend/tests/conftest.py,sha256=6WLrWWAgC4uzdKx0-Hh4qQH_U2zo7vu5ir4lWBWYKlo,250
+sp2react/scaffold/templates/backend/tests/test_rule_vectors.py,sha256=eYVbk6Umm7RRTfpHXyS4rR-IIogdX9UKfrq9DqT4lpQ,1553
+sp2react/scaffold/templates/frontend/index.html,sha256=hIgnzooYwTxIWRVCRA8BIeyLxM1mBK498aUqKtBMB-Y,301
+sp2react/scaffold/templates/frontend/package.json,sha256=UvxQzmf0vZRSrdg06KYE2sTnEeJLlwFDTCkSVt7N9UQ,541
+sp2react/scaffold/templates/frontend/tsconfig.json,sha256=wQo9WmOb56jFINECi85gir9AzEF5rutk6Lh0MOfbgbQ,434
+sp2react/scaffold/templates/frontend/vite.config.ts,sha256=rMa1S-svNgrZ21HH9W9FHhwt3p7yBhU58gG2BhEstHc,206
+sp2react/scaffold/templates/frontend/scripts/check-rules.ts,sha256=x5lo3ljK9Lo4rcVugHeZzBNLw9GBNkVPPeLTl8lh46w,1767
+sp2react/scaffold/templates/frontend/src/api.ts,sha256=U3BJjMq0allELxdP7TBD2QuwA4ZkV-9QPDSqAiuZp2s,4107
+sp2react/scaffold/templates/frontend/src/main.tsx,sha256=vumNKICXxEFIkTRVYdd_XIN9nZYR_t5jsnjVINr46t0,363
+sp2react/scaffold/templates/frontend/src/vite-env.d.ts,sha256=ZZlpNvuwQpFfe3SiAPzd5-QQ8ypmmxq5WXz6pLD63bU,38
+sp2react/scaffold/templates/frontend/src/components/sp/Banner.tsx,sha256=5KMNGO2tdh8rfVP_WGRojBRc5OlTLBnLIIVctiR6R8c,252
+sp2react/scaffold/templates/frontend/src/components/sp/DataTable.tsx,sha256=VQaEsqgjkYwjKBRB9aSi3kQQYUQK7EJup-Fgb-wspnc,1106
+sp2react/scaffold/templates/frontend/src/components/sp/Form.tsx,sha256=8QaTVlXdZep2Oa5Ykg3IQ13OrkZkbhzK60nte752Q0M,12560
+sp2react/scaffold/templates/frontend/src/components/sp/GenericPage.tsx,sha256=r4jD45g4j06xxT3gwcOMJWG9xJGcmEWF4Ki5pElnI8k,1350
+sp2react/scaffold/templates/frontend/src/components/sp/Layout.tsx,sha256=2ZKUp0v83o0t_uvXYc8pxxqi_uIKMbn3DzbcgAlEAow,2301
+sp2react/scaffold/templates/frontend/src/components/sp/LegacyHtml.tsx,sha256=BgbDXCSri_TXvoXmDYaDFWtjtlEgSbivUr7RW-nFeIU,569
+sp2react/scaffold/templates/frontend/src/components/sp/ListView.tsx,sha256=womt8IiNIWnsTIJLyb5ug4px9VSAvhKiq_2sOwa0nj0,3060
+sp2react/scaffold/templates/frontend/src/components/sp/Tiles.tsx,sha256=0LFWzZRgDhJFjeYEH6ygZ-oouG7h6o_JWW-xq3Ig0zY,517
+sp2react/scaffold/templates/frontend/src/components/sp/fields.tsx,sha256=SX4f3K8_uz_LIJgCYAjkXpc7NddIn6gx5uD8Fwc9URI,5825
+sp2react/scaffold/templates/frontend/src/custom/types.ts,sha256=EGUCGkK2vhvntJnv2KDYSXT7VSbAD_9wblHDI6s_ei4,399
+sp2react/scaffold/templates/frontend/src/runtime/format.ts,sha256=BUVjOPWUXQmDrfDGYRuU7TfyPQz3tGlu-XcgdpdesMg,1550
+sp2react/scaffold/templates/frontend/src/runtime/rules.ts,sha256=g4WqMMoykZ_CGkaLmHI68YRFI2a5nFyqbXKmwyFbouA,10413
+sp2react/scaffold/templates/frontend/src/runtime/spec.ts,sha256=0SGKcuz5kc8jloLQlz8Utw6vRYaBxe0OpyQcdj9Vqm0,2582
+sp2react/scaffold/templates/frontend/src/runtime/user.tsx,sha256=5RnkR-txQZXotBYCk7GESTXL3r2YCC3eQMyR1om0g98,913
+sp2react/scaffold/templates/frontend/src/screens/LegacyRedirect.tsx,sha256=S5O29r9XEnkxpsoWV8BeU8E1yLkZs0FwRhejfqb1EXU,1478
+sp2react/scaffold/templates/frontend/src/screens/ListFormScreen.tsx,sha256=ymOuMZZb37YLpXTEyyEPoCCP8qUSaMHYaBRfKUEpEQ0,1679
+sp2react/scaffold/templates/frontend/src/styles/sp.css,sha256=pvJpMrRDt6LbGGZ7D0rnDZUnDlDkIvZzv2FR_VTuw_Q,5846
+sp2react/sharepoint/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sp2react/sharepoint/client.py,sha256=86WzL05rM4wKadNKjXv4OAuNy-Ob-l7JZ6CIZpPv51w,9956
+sp2react/sharepoint/extract.py,sha256=mnONIJnnz8xqoprGTS1Q30vS2oCLJwjWqvwMThZ8ESI,11145
+sp2react/spec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sp2react/spec/base.py,sha256=V2zJEsUVgCv8ZsYNG4C2taEMFNkowj1WyPL3IMYDf-U,4318
+sp2react/spec/coverage.py,sha256=T0OVvjsHd3W8uzu89tOhJnDzu-FrN2QUyUA9LvrplgM,8940
+sp2react/spec/model.py,sha256=k1KJ-4PlauNdO6Mp8bF9f-nmyZB_nIOHgI7pINorL4E,5513
+sp2react-0.1.0.dist-info/licenses/LICENSE,sha256=nLfpXwI9bP5mzI3n2TobXSQt1XKbWbvaxB-qhq18Qug,1081
+sp2react-0.1.0.dist-info/METADATA,sha256=su2JD9pqmNkgwV0GZ155vspkX2wwOtX0Y_gvgFjCtK4,11967
+sp2react-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+sp2react-0.1.0.dist-info/entry_points.txt,sha256=48Bk0upTdoLUd8sn4KG5l1peCWUIA2nHUVuQmwwS-Sc,47
+sp2react-0.1.0.dist-info/top_level.txt,sha256=vMnbbD0OZPkMRiU6LKseJhEUlMgfx9HSJRdQvyPAlWg,9
+sp2react-0.1.0.dist-info/RECORD,,

sp2react-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sp2react-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sp2react = sp2react.cli:main