filemaker-patchwork 0.1.0__py3-none-any.whl

patchwork/ops.py

@@ -0,0 +1,249 @@
+"""Every workspace operation, shared by the CLI and the MCP server. Each returns plain text."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Callable
+
+from patchwork import PatchworkError, objects, place, script
+from patchwork.build import FIELD_TYPES, add_field_action, field_xml, image_calc, layouts_patch, palette as theme_palette, theme_replace
+from patchwork.export import Export, unescape
+from patchwork.uses import find_uses
+from patchwork.workspace import Result, Workspace
+
+LISTABLE = ("layouts", "scripts", "value-lists", "custom-functions", "themes", "tables", "table-occurrences", "fields")
+
+
+def open_file(source: str, account: str, no_password: bool = False, project: str | None = None, force: bool = False) -> str:
+    ws = Workspace.create(Path(source), account, no_password, Path(project) if project else None, force)
+    return f"Opened {Path(source).name} as v000 in {ws.root}\n" + status(ws)
+
+
+def status(ws: Workspace) -> str:
+    export = ws.export
+    counts = ", ".join(f"{len(objects.items(export, k))} {k}" for k in ("layouts", "scripts", "value-lists", "custom-functions"))
+    tables = objects.items(export, "tables")
+    last = ws.log()[-1]
+    return (
+        f"source   {ws.state['source']}\n"
+        f"version  v{ws.version:03d}  ({last['message']}, {last['time']})\n"
+        f"account  {ws.state['account']}\n"
+        f"contents {len(tables)} tables, {counts}"
+    )
+
+
+def list_objects(ws: Workspace, kind: str = "", table: str = "") -> str:
+    export = ws.export
+    if kind in ("", "all"):
+        return "\n".join(f"{k}: {len(objects.items(export, k))}" for k in LISTABLE if k != "fields") + "\nfields: use `ls fields TABLE`"
+    if kind in ("fields", "field"):
+        if not table:
+            raise PatchworkError("Name the table: ls fields TABLE")
+        _, _, catalog = export.field_catalog(table)
+        rows = re.findall(r'<Field id="\d+" name="([^"]*)" fieldtype="([^"]*)" datatype="([^"]*)"', catalog)
+        label = {"Binary": "Container", "TimeStamp": "Timestamp"}
+        return "\n".join(f"{unescape(name)}\t{label.get(datatype, datatype)}{' (calc)' if ftype == 'Calculated' else ''}"
+                         for name, ftype, datatype in rows)
+    return "\n".join(item.name for item in objects.items(export, kind))
+
+
+def show(ws: Workspace, kind: str, name: str, xml: bool = False) -> str:
+    if kind == "script" and not xml:
+        return script.to_text(objects.script_steps(ws.export, name)[1]) or f"{name} has no steps."
+    return objects.show(ws.export, kind, name)
+
+
+def describe(result: Result) -> str:
+    lines = [f"v{result.version:03d}  {result.message}"] + [f"  {c}" for c in result.changes[:40]]
+    if len(result.changes) > 40:
+        lines.append(f"  ... and {len(result.changes) - 40} more")
+    return "\n".join(lines)
+
+
+def run(ws: Workspace, actions, message: str, dry_run: bool, expect: str | None = None,
+        check: Callable[[Export], str | None] | None = None) -> str:
+    result = ws.apply(actions, message, dry_run=dry_run)
+    if dry_run:
+        return f"Dry run: patch written to {result.patch}"
+    if expect and not any(c.startswith(expect) for c in result.changes):
+        ws.undo()
+        raise PatchworkError(f"FMUpgradeTool reported success but `{expect}` is missing from the result. Version dropped.")
+    problem = check(ws.export) if check else None
+    if problem:
+        ws.undo()
+        raise PatchworkError(f"FMUpgradeTool applied the patch but {problem}. Version dropped.")
+    return describe(result)
+
+
+def lines(text: str) -> list[str]:
+    return re.split(r"\r\n|\r|\n", text)
+
+
+def check_value_list(name: str, values: list[str]) -> Callable[[Export], str | None]:
+    def check(export: Export) -> str | None:
+        found = re.search(r"<CustomValues>\s*<Text><!\[CDATA\[([\s\S]*?)\]\]>", objects.find(export, "value-list", name).xml)
+        stored = lines(found.group(1)) if found else []
+        return None if stored == values else f"the value list holds {stored} instead of {values}"
+    return check
+
+
+def check_custom_function(name: str, calc: str, params: list[str]) -> Callable[[Export], str | None]:
+    def check(export: Export) -> str | None:
+        xml = objects.find(export, "custom-function", name).xml
+        found = re.search(r"<Calculation>\s*<Text><!\[CDATA\[([\s\S]*?)\]\]>", xml)
+        if not found or lines(found.group(1)) != lines(calc):
+            return "the formula is missing from the result (FileMaker rejected the calculation)"
+        stored = [unescape(p) for p in re.findall(r'<Parameter name="([^"]*)"', xml)]
+        return None if stored == params else f"the parameters are {stored} instead of {params}"
+    return check
+
+
+def add_field(ws: Workspace, table: str, name: str, type: str = "Text", calc: str = "", is_global: bool = False,
+              comment: str = "", context: str = "", image: str = "", image_width: int = 0, message: str = "", dry_run: bool = False) -> str:
+    if type not in FIELD_TYPES:
+        raise PatchworkError(f"Unknown field type: {type}. Choose from {', '.join(FIELD_TYPES)}.")
+    if image:
+        calc, type, is_global = image_calc(Path(image), image_width or None), "Container", True
+    xml = field_xml(ws.export, table, name, type, comment, is_global, calc or None, context or None)
+    return run(ws, add_field_action(ws.export, table, xml), message or f"add field {table}::{name}", dry_run, f"+ field {table}::{name}")
+
+
+def add_value_list(ws: Workspace, name: str, values: list[str], message: str = "", dry_run: bool = False) -> str:
+    action = objects.add_object(ws.export, "value-list", objects.value_list_xml(name, values))
+    return run(ws, action, message or f"add value list {name}", dry_run, f"+ value-list {name}", check_value_list(name, values))
+
+
+def add_custom_function(ws: Workspace, name: str, calc: str, params: list[str] | None = None, message: str = "", dry_run: bool = False) -> str:
+    action = objects.add_object(ws.export, "custom-function", objects.custom_function_xml(name, params or [], calc))
+    return run(ws, action, message or f"add custom function {name}", dry_run, f"+ custom-function {name}",
+               check_custom_function(name, calc, params or []))
+
+
+def steps_xml(export: Export, steps: str, existing: str = "") -> str:
+    """<Step> XML from FileMaker script text, or the XML itself."""
+    return steps if script.is_xml(steps) else script.build(export, steps, existing)
+
+
+def check_steps(name: str, want: list[str]) -> Callable[[Export], str | None]:
+    def check(export: Export) -> str | None:
+        got = script.normalized(objects.script_steps(export, name)[1])
+        for i, (w, g) in enumerate(zip(want, got), 1):
+            if w != g:
+                return f"step {i} came back as `{g}` instead of `{w}` (FileMaker dropped or changed a parameter)"
+        if len(want) != len(got):
+            return f"the script has {len(got)} steps instead of {len(want)}"
+        return None
+    return check
+
+
+def add_script(ws: Workspace, name: str, steps: str = "", message: str = "", dry_run: bool = False) -> str:
+    xml = steps_xml(ws.export, steps) if steps.strip() else ""
+    return run(ws, objects.add_script(ws.export, name, xml), message or f"add script {name}", dry_run, f"+ script {name}",
+               check_steps(name, script.normalized(xml)))
+
+
+def add(ws: Workspace, kind: str, xml: str, message: str = "", dry_run: bool = False) -> str:
+    action = objects.add_object(ws.export, kind, xml)
+    name = re.search(r'\sname="([^"]*)"', xml)
+    return run(ws, action, message or f"add {kind} {name.group(1) if name else ''}".strip(), dry_run)
+
+
+def set_steps(ws: Workspace, name: str, steps: str, message: str = "", dry_run: bool = False) -> str:
+    _, existing = objects.script_steps(ws.export, name)
+    xml = steps_xml(ws.export, steps, existing)
+    return run(ws, objects.set_steps(ws.export, name, xml), message or f"rewrite steps of {name}", dry_run, f"~ script {name}",
+               check_steps(name, script.normalized(xml)))
+
+
+def append_steps(ws: Workspace, name: str, steps: str, message: str = "", dry_run: bool = False) -> str:
+    _, existing = objects.script_steps(ws.export, name)
+    xml = steps_xml(ws.export, steps)
+    return run(ws, objects.append_steps(ws.export, name, xml), message or f"append steps to {name}", dry_run, f"~ script {name}",
+               check_steps(name, script.normalized(existing) + script.normalized(xml)))
+
+
+def replace(ws: Workspace, kind: str, name: str, xml: str, message: str = "", dry_run: bool = False) -> str:
+    return run(ws, objects.replace_object(ws.export, kind, name, xml), message or f"edit {kind} {name}", dry_run)
+
+
+def place_field(ws: Workspace, layout: str, field: str, near: str, label: str | None = None, side: str = "below",
+                message: str = "", dry_run: bool = False) -> str:
+    xml, field_uuid = place.place_field(ws.export, layout, field, near, label, side)
+
+    def check(export: Export) -> str | None:
+        found = re.search(rf'<FieldReference [^>]*\bUUID="{field_uuid}"', export.layout(layout).xml)
+        return None if found else f"{field} is not on {layout!r} in the result"
+
+    return run(ws, objects.replace_object(ws.export, "layout", layout, xml), message or f"place {field} on {layout}",
+               dry_run, f"~ layout {layout}", check)
+
+
+def uses(ws: Workspace, kind: str, name: str) -> str:
+    return find_uses(ws.export, kind, name).report()
+
+
+def delete(ws: Workspace, kind: str, name: str, message: str = "", dry_run: bool = False, force: bool = False) -> str:
+    found = find_uses(ws.export, kind, name)
+    if found.references and not force:
+        raise PatchworkError(f"{found.report()}\nNot deleted: these would point at nothing. Check them first, "
+                             "then delete with --force (MCP: force=true). `undo` brings it back either way.")
+    result = run(ws, objects.delete_object(ws.export, kind, name), message or f"delete {kind} {name}", dry_run, f"- {kind} {name}")
+    if found.references or found.mentions:
+        result += f"\nWarning, review these: {found.report()}"
+    return result
+
+
+def retheme(ws: Workspace, theme: str = "", colors: dict | None = None, fonts: dict | None = None, rename: str = "",
+            message: str = "", dry_run: bool = False) -> str:
+    export = ws.export
+    label = theme or export.main_theme()
+    action = theme_replace(export, label, rename or None, colors or {}, fonts or {})
+    return run(ws, action, message or f"edit theme {export.theme(label).name}", dry_run)
+
+
+def recolor_layouts(ws: Workspace, colors: dict | None = None, fonts: dict | None = None, swap_field: list[str] | None = None,
+                    only: list[str] | None = None, message: str = "", dry_run: bool = False) -> str:
+    patch, names = layouts_patch(ws.export, only or None, colors or {}, fonts or {}, tuple(swap_field) if swap_field else None)
+    if not names:
+        raise PatchworkError("No layout would change.")
+    return run(ws, patch, message or f"edit {len(names)} layout(s)", dry_run)
+
+
+def push(ws: Workspace, patch_xml: str, message: str = "", dry_run: bool = False) -> str:
+    if "<FMUpgradeToolPatch" not in patch_xml:
+        raise PatchworkError("Expected a full patch (root <FMUpgradeToolPatch>).")
+    return run(ws, patch_xml, message or "push patch", dry_run)
+
+
+def palette(ws: Workspace, theme: str = "") -> str:
+    block = ws.export.theme(theme or ws.export.main_theme())
+    return f"{block.name}\n" + "\n".join(f"{color}  {count}x" for color, count in theme_palette(block.xml))
+
+
+def undo(ws: Workspace) -> str:
+    return f"Back to v{ws.undo():03d}"
+
+
+def log(ws: Workspace) -> str:
+    lines = []
+    for entry in ws.log():
+        lines.append(f"v{entry['n']:03d}  {entry['time']}  {entry['message']}")
+        lines += [f"        {c}" for c in entry.get("changes", [])[:10]]
+    return "\n".join(lines)
+
+
+def save(ws: Workspace, dest: str, force: bool = False) -> str:
+    return f"Saved v{ws.version:03d} to {ws.save(Path(dest), force)}"
+
+
+def load_json(value: str | dict | None) -> dict:
+    if not value:
+        return {}
+    if isinstance(value, dict):
+        return value
+    path = Path(value)
+    if path.is_file():
+        return json.loads(path.read_text(encoding="utf-8"))
+    return json.loads(value)

patchwork/place.py

@@ -0,0 +1,201 @@
+"""Put a field on a layout by copying one that is already there, with its label.
+
+FMUpgradeTool skips a lone LayoutObject add or replace, so the whole layout is replaced.
+Bounds in a Save-as-XML export are absolute (from the top of the layout), and a field
+points at its label with <Accessibility><Label>ID</Label>.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from patchwork import PatchworkError, objects
+from patchwork.export import Export, escape, unescape
+
+OBJECT = re.compile(r"(?m)^(\t*)<LayoutObject [^>]*>[\s\S]*?^\1</LayoutObject>")
+BOUNDS = re.compile(r'<Bounds top="(-?[\d.]+)" left="(-?[\d.]+)" bottom="(-?[\d.]+)" right="(-?[\d.]+)"></Bounds>')
+GAP = 10
+SLACK = 4
+
+
+@dataclass
+class Box:
+    top: float
+    left: float
+    bottom: float
+    right: float
+
+    def moved(self, dy: float, dx: float) -> "Box":
+        return Box(self.top + dy, self.left + dx, self.bottom + dy, self.right + dx)
+
+    def grown(self, dy: float) -> "Box":
+        return Box(self.top, self.left, self.bottom + dy, self.right)
+
+    def union(self, other: "Box") -> "Box":
+        return Box(min(self.top, other.top), min(self.left, other.left), max(self.bottom, other.bottom), max(self.right, other.right))
+
+    def overlaps(self, other: "Box") -> bool:
+        return self.top < other.bottom and other.top < self.bottom and self.left < other.right and other.left < self.right
+
+    def tag(self) -> str:
+        return f'<Bounds top="{num(self.top)}" left="{num(self.left)}" bottom="{num(self.bottom)}" right="{num(self.right)}"></Bounds>'
+
+
+@dataclass
+class Obj:
+    start: int
+    end: int
+    xml: str
+    id: str
+    box: Box
+
+
+def num(value: float) -> str:
+    return str(int(value)) if value == int(value) else f"{value:g}"
+
+
+def own_bounds(xml: str) -> Box:
+    found = BOUNDS.search(xml)
+    if not found:
+        raise PatchworkError("Layout object without bounds.")
+    return Box(*(float(v) for v in found.groups()))
+
+
+def top_level(part: str, offset: int) -> list[Obj]:
+    """Objects directly in a part (not inside button bars, portals or groups)."""
+    found = []
+    depth = None
+    for match in OBJECT.finditer(part):
+        indent = len(match.group(1))
+        depth = indent if depth is None else min(depth, indent)
+    for match in OBJECT.finditer(part):
+        if len(match.group(1)) == depth:
+            xml = match.group(0)
+            ident = re.search(r'\sid="(\d+)"', xml[: xml.index(">")])
+            found.append(Obj(offset + match.start(), offset + match.end(), xml, ident.group(1) if ident else "", own_bounds(xml)))
+    return found
+
+
+def field_target(export: Export, field: str) -> tuple[str, str, str, str]:
+    """(field id, field name, field UUID, TableOccurrenceReference) for TO::Field."""
+    occurrence, name = objects.split_field(field)
+    to = objects.find(export, "table-occurrence", occurrence)
+    base = re.search(r'<BaseTableReference [^>]*\bname="([^"]*)"', to.xml)
+    if not base:
+        raise PatchworkError(f"Table occurrence {occurrence} has no base table in the export.")
+    field_id, field_uuid = export.field(unescape(base.group(1)), name)
+    return field_id, name, field_uuid, export.table_occurrence(occurrence)
+
+
+def place_field(export: Export, layout: str, field: str, near: str, label: str | None = None,
+                side: str = "below") -> tuple[str, str]:
+    """(whole new layout XML, field UUID). `near` is a field already on the layout, as Name or TO::Name."""
+    block = export.layout(layout)
+    xml = block.xml
+    field_id, field_name, field_uuid, to_ref = field_target(export, field)
+    near_name = near.split("::", 1)[-1]
+
+    parts = list(re.finditer(r"<Part type=\"([^\"]*)\"[\s\S]*?</Part>", xml))
+    for part in parts:
+        objs = top_level(part.group(0), part.start())
+        anchor = next((o for o in objs if re.search(rf'<FieldReference [^>]*\bname="{re.escape(escape(near_name))}"', o.xml)
+                       and (near_name == near or f'name="{escape(near.split("::")[0])}"' in o.xml)), None)
+        if anchor:
+            break
+    else:
+        raise PatchworkError(f"No field {near!r} directly on layout {layout!r}. Name a field that is on it, e.g. one from `patchwork show layout`.")
+    if re.search(rf'<FieldReference [^>]*\bUUID="{field_uuid}"', part.group(0)):
+        raise PatchworkError(f"{field} is already on {layout!r}.")
+
+    label_id = re.search(r"<Accessibility>\s*<Label>(\d+)</Label>", anchor.xml)
+    caption = next((o for o in objs if label_id and o.id == label_id.group(1) and 'type="Text"' in o.xml[:200]), None)
+    group = anchor.box.union(caption.box) if caption else anchor.box
+    if side == "below":
+        line = group.bottom - SLACK
+        under = [o.box.top - group.bottom for o in objs
+                 if o.box.top >= line and o.box.left < group.right and group.left < o.box.right]
+        gap = min(under) if under and 0 <= min(under) <= 40 else GAP
+        dy, dx = group.bottom - group.top + gap, 0.0
+    elif side == "right":
+        line, dy, dx = None, 0.0, group.right - group.left + GAP
+    else:
+        raise PatchworkError("side is below or right.")
+
+    placed = group.moved(dy, dx)
+    width = float(re.search(r'<Layout [^>]*\bwidth="([\d.]+)"', xml).group(1))
+    if placed.right > width:
+        raise PatchworkError(f"No room right of {near!r}: it would go past the edge of the layout. Use side=below.")
+    staying = [o for o in objs if line is None or o.box.top < line]
+    blocking = [o for o in staying if o.box.overlaps(placed) and not stretches(o)]
+    if blocking:
+        names = [re.search(r'<FieldReference [^>]*\bname="([^"]*)"', o.xml) for o in blocking]
+        what = ", ".join(f"field {n.group(1)}" if n else f"object {o.id}" for n, o in zip(names, blocking))
+        raise PatchworkError(f"No room {side} {near!r}: it would cover {what}. "
+                             f"Try side={'right' if side == 'below' else 'below'} or another field.")
+
+    next_id = max((int(i) for i in re.findall(r'<LayoutObject [^>]*?\bid="(\d+)"', export.section("LayoutCatalog"))), default=0) + 1
+    new_field = copy(anchor.xml, str(next_id), dy, dx)
+    new_field = re.sub(r"<FieldReference [^>]*>[\s\S]*?</FieldReference>",
+                       f'<FieldReference id="{field_id}" name="{escape(field_name)}" repetition="1" UUID="{field_uuid}">'
+                       f"\n{indent_of(anchor.xml, 'TableOccurrenceReference')}{to_ref}\n{indent_of(anchor.xml, 'FieldReference')}</FieldReference>",
+                       new_field, count=1)
+    new_field = re.sub(r"\s*<TabOrder [\s\S]*?</TabOrder>", "", new_field)
+    added = [new_field]
+    if caption:
+        text = escape_cdata(label if label is not None else field_name)
+        new_caption = copy(caption.xml, str(next_id + 1), dy, dx)
+        new_caption = re.sub(r"<Data><!\[CDATA\[[\s\S]*?\]\]></Data>", lambda _: f"<Data><![CDATA[{text}]]></Data>", new_caption, count=1)
+        new_field = new_field.replace(f"<Label>{caption.id}</Label>", f"<Label>{next_id + 1}</Label>")
+        added = [new_caption, new_field]
+
+    edits = [(anchor.end, anchor.end, "".join(f"\n{a}" for a in added))]
+    if line is not None:
+        for o in objs:
+            if o.box.top >= line:
+                edits.append((o.start, o.end, shift(o.xml, dy)))
+            elif o.box.bottom > line and stretches(o):
+                edits.append((o.start, o.end, BOUNDS.sub(lambda m: Box(*(float(v) for v in m.groups())).grown(dy).tag(), o.xml, count=1)))
+        definition = re.search(r'<Definition [^>]*\bsize="([\d.]+)"', part.group(0))
+        if definition:
+            at = part.start() + definition.start(1)
+            edits.append((at, at + len(definition.group(1)), num(float(definition.group(1)) + dy)))
+        for later in parts[parts.index(part) + 1:]:
+            moved = BOUNDS.sub(lambda m: Box(*(float(v) for v in m.groups())).moved(dy, 0).tag(), later.group(0))
+            moved = re.sub(r'(<Definition [^>]*\babsolute=")([\d.]+)', lambda m: m.group(1) + num(float(m.group(2)) + dy), moved, count=1)
+            edits.append((later.start(), later.end(), moved))
+    for start, end, text in sorted(edits, key=lambda e: e[0], reverse=True):
+        xml = xml[:start] + text + xml[end:]
+    count = re.compile(r'(<ObjectList membercount=")(\d+)(">)')
+    first = count.search(xml, part.start())
+    xml = xml[: first.start(2)] + str(int(first.group(2)) + len(added)) + xml[first.end(2):]
+    return xml, field_uuid
+
+
+def stretches(o: Obj) -> bool:
+    """Background shapes grow with the row instead of moving."""
+    return bool(re.match(r'\t*<LayoutObject [^>]*\btype="(Rectangle|Rounded Rectangle)"', o.xml))
+
+
+def shift(xml: str, dy: float) -> str:
+    return BOUNDS.sub(lambda m: Box(*(float(v) for v in m.groups())).moved(dy, 0).tag(), xml)
+
+
+def copy(xml: str, new_id: str, dy: float, dx: float) -> str:
+    head_end = xml.index(">")
+    head = re.sub(r'\shash="[^"]*"', "", xml[:head_end])
+    head = re.sub(r'\sid="\d+"', f' id="{new_id}"', head, count=1)
+    body = objects.fresh_uuids(xml[head_end:])
+    body = BOUNDS.sub(lambda m: Box(*(float(v) for v in m.groups())).moved(dy, dx).tag(), body)
+    return head + body
+
+
+def indent_of(xml: str, tag: str) -> str:
+    found = re.search(rf"\n(\t*)<{tag}\b", xml)
+    return found.group(1) if found else ""
+
+
+def escape_cdata(text: str) -> str:
+    if "]]>" in text:
+        raise PatchworkError("The label cannot contain ']]>'.")
+    return text

patchwork/project.py

@@ -0,0 +1,96 @@
+"""`patchwork init`: a project folder wired for Claude Code, Cursor, Codex and Google Antigravity.
+
+Antigravity and Codex read AGENTS.md; Claude Code reads CLAUDE.md, which imports it.
+Skills go to .cursor/skills, .claude/skills and .agents/skills (Antigravity, Codex).
+Existing files are never overwritten, so `init` can wire an existing folder.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+from importlib import resources
+from pathlib import Path
+
+SKILL_HOMES = (".cursor/skills", ".claude/skills", ".agents/skills")
+
+
+class Init:
+    def __init__(self, root: Path):
+        self.root = root
+        self.written: list[str] = []
+        self.kept: list[str] = []
+
+    def write(self, relative: str, text: str) -> None:
+        path = self.root / relative
+        if path.exists():
+            self.kept.append(relative)
+            return
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text, encoding="utf-8")
+        self.written.append(relative)
+
+    def report(self) -> str:
+        lines = [f"Project ready: {self.root}"]
+        lines += [f"  + {name}" for name in self.written]
+        if self.kept:
+            lines.append(f"  kept {len(self.kept)} existing file(s): {', '.join(self.kept)}")
+        return "\n".join(lines)
+
+
+def init_project(directory: Path, name: str, skills: bool = True) -> Init:
+    root = directory.resolve()
+    root.mkdir(parents=True, exist_ok=True)
+    init = Init(root)
+    values = {"NAME": name.strip() or root.name}
+    init.write("AGENTS.md", template("AGENTS.md", values))
+    init.write("CLAUDE.md", "@AGENTS.md\n")
+    init.write("standards/naming.md", template("naming.md", values))
+    init.write(".gitignore", template("gitignore", values))
+    init.write("patches/.gitkeep", "")
+    for relative, text in mcp_configs(root).items():
+        init.write(relative, text)
+    if skills:
+        source = resources.files("patchwork") / "skills"
+        for home in SKILL_HOMES:
+            for skill in source.iterdir():
+                if skill.is_dir():
+                    init.write(f"{home}/{skill.name}/SKILL.md", (skill / "SKILL.md").read_text(encoding="utf-8"))
+    return init
+
+
+def server_command() -> tuple[str, list[str]]:
+    """`patchwork` when agents can find it on PATH, otherwise this Python with `-m patchwork`."""
+    if shutil.which("patchwork"):
+        return "patchwork", []
+    return sys.executable, ["-m", "patchwork"]
+
+
+def mcp_configs(root: Path) -> dict[str, str]:
+    command, prefix = server_command()
+    server = {"command": command, "args": [*prefix, "mcp"]}
+    cursor = {"mcpServers": {"patchwork": {**server, "args": [*prefix, "-C", "${workspaceFolder}", "mcp"],
+                                           "env": {"PATCHWORK_PASSWORD": "${env:PATCHWORK_PASSWORD}"}}}}
+    claude = {"mcpServers": {"patchwork": {**server, "env": {"PATCHWORK_PASSWORD": "${PATCHWORK_PASSWORD:-}"}}}}
+    antigravity = {"mcpServers": {"patchwork": {**server, "cwd": str(root)}}}
+    codex = (
+        "[mcp_servers.patchwork]\n"
+        f"command = {json.dumps(command)}\n"
+        f"args = {json.dumps(server['args'])}\n"
+        f"cwd = {json.dumps(str(root))}\n"
+        'env_vars = ["PATCHWORK_PASSWORD"]\n'
+    )
+    return {
+        ".cursor/mcp.json": json.dumps(cursor, indent=2) + "\n",
+        ".mcp.json": json.dumps(claude, indent=2) + "\n",
+        ".agents/mcp_config.json": json.dumps(antigravity, indent=2) + "\n",
+        ".codex/config.toml": codex,
+    }
+
+
+def template(name: str, values: dict[str, str]) -> str:
+    text = (resources.files("patchwork") / "templates" / name).read_text(encoding="utf-8")
+    for key, value in values.items():
+        text = text.replace("{{" + key + "}}", value)
+    return text