code-coordinator 0.5.273__tar.gz → 0.5.274__tar.gz

{code_coordinator-0.5.273 → code_coordinator-0.5.274}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.273
+Version: 0.5.274
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.273 → code_coordinator-0.5.274}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.273
+Version: 0.5.274
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.273 → code_coordinator-0.5.274}/code_coordinator.egg-info/SOURCES.txt

@@ -141,6 +141,7 @@ coord/split_work.py
 coord/sql.py
 coord/stage_projection.py
 coord/state.py
+coord/store_migrate.py
 coord/test_author.py
 coord/test_chat.py
 coord/test_orchestrator.py
@@ -181,6 +182,7 @@ coord/commands/scorecard.py
 coord/commands/sessions.py
 coord/commands/setup.py
 coord/commands/status.py
+coord/commands/store_migrate.py
 coord/commands/terminal.py
 coord/commands/test_gate.py
 coord/commands/tui.py
@@ -724,6 +726,7 @@ tests/test_state_review_findings_daemon.py
 tests/test_status_fleet_footer.py
 tests/test_stop_1567.py
 tests/test_store_contract.py
+tests/test_store_migrate.py
 tests/test_stuck.py
 tests/test_stuck_test_state_watchdog_2803.py
 tests/test_terminal_command.py
@@ -754,6 +757,8 @@ tests/test_worker_safety.py
 tests/test_worker_test_scoping.py
 tests/test_worktree.py
 tests/test_worktree_rmtree_chokepoint.py
+tests/test_write_parity.py
+tests/write_parity.py
 tests/acceptance/ms-33/audit_1039.rs
 tests/acceptance/ms-33/contract.md
 tests/acceptance/ms-33/manifest.yml

{code_coordinator-0.5.273 → code_coordinator-0.5.274}/code_coordinator.egg-info/scm_file_list.json

@@ -77,6 +77,7 @@
     "coord/commands/sessions.py",
     "coord/commands/setup.py",
     "coord/commands/status.py",
+    "coord/commands/store_migrate.py",
     "coord/commands/terminal.py",
     "coord/commands/test_gate.py",
     "coord/commands/tui.py",
@@ -251,6 +252,7 @@
     "coord/sql.py",
     "coord/stage_projection.py",
     "coord/state.py",
+    "coord/store_migrate.py",
     "coord/test_author.py",
     "coord/test_chat.py",
     "coord/test_orchestrator.py",
@@ -796,6 +798,7 @@
     "tests/test_status_fleet_footer.py",
     "tests/test_stop_1567.py",
     "tests/test_store_contract.py",
+    "tests/test_store_migrate.py",
     "tests/test_stuck.py",
     "tests/test_stuck_test_state_watchdog_2803.py",
     "tests/test_terminal_command.py",
@@ -826,6 +829,8 @@
     "tests/test_worker_test_scoping.py",
     "tests/test_worktree.py",
     "tests/test_worktree_rmtree_chokepoint.py",
+    "tests/test_write_parity.py",
+    "tests/write_parity.py",
     "tui/Cargo.lock",
     "tui/Cargo.toml",
     "tui/cargo-config-local-quadraui.toml.example",

{code_coordinator-0.5.273 → code_coordinator-0.5.274}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.273",
+  "tag": "0.5.274",
   "distance": 0,
-  "node": "gd5980777425030eea6f688b62a154d8312a34199",
+  "node": "g431089da1ef90b647a608a440d189de80f9bac42",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-28"

{code_coordinator-0.5.273 → code_coordinator-0.5.274}/coord/cli.py

@@ -147,6 +147,7 @@ from coord.commands.release import release_group, release_preflight
 # #2220: `coord repo add` / `coord repo doctor` — onboarding a repo, and
 # verifying it actually happened across all five layers.
 from coord.commands.repo import repo_group
+from coord.commands.store_migrate import migrate_to_postgres
 from coord.commands.plan_followup import (
     _dispatch_followup,  # noqa: F401 — re-exported for tests
     approve_plan,
@@ -491,6 +492,7 @@ main.add_command(release_preflight)
 main.add_command(release_group)
 # #2220: repo onboarding + its verifier.
 main.add_command(repo_group)
+main.add_command(migrate_to_postgres)
 main.add_command(tui_group)
 
 

code_coordinator-0.5.274/coord/commands/store_migrate.py

@@ -0,0 +1,105 @@
+"""``coord migrate-to-postgres`` -- one-shot import of an existing SQLite
+``coord.db`` into the Postgres store #827's ``store:`` config seam names
+(#828 second half). See ``coord.store_migrate`` for the actual audit/copy
+logic this command is a thin CLI wrapper around.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from coord import db as coord_db
+from coord import sql
+from coord.store_migrate import ImportAborted, run_import
+
+
+@click.command(
+    "migrate-to-postgres",
+    help=(
+        "Import an existing SQLite coord.db into the Postgres store configured "
+        "by coordinator.yml's store: block (#828). Audits referential integrity "
+        "and type-affinity drift before writing anything."
+    ),
+)
+@click.option(
+    "--source",
+    "source_path",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Path to the source coord.db (default: this install's DB_PATH).",
+)
+@click.option(
+    "--dsn",
+    default=None,
+    help="Target Postgres DSN (default: coordinator.yml's store.dsn).",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Wipe and re-import any target tables that already have rows (default: refuse).",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Audit the source and report row counts without opening or writing the target.",
+)
+def migrate_to_postgres(
+    source_path: Path | None, dsn: str | None, force: bool, dry_run: bool
+) -> None:
+    source_path = source_path or coord_db.DB_PATH
+    if dsn is None and not dry_run:
+        target = coord_db._resolve_store_target()
+        if not target.dsn:
+            raise click.ClickException(
+                "no --dsn given and coordinator.yml has no store.dsn configured -- "
+                "pass --dsn explicitly, or set store.backend: postgres / store.dsn "
+                "in coordinator.yml first (#827)."
+            )
+        dsn = target.dsn
+
+    click.echo(f"Source: {source_path}")
+    # Never echo the raw DSN -- it routinely embeds a password
+    # (`store.dsn`'s plain-string shape, coord/config.py), and this command's
+    # stdout is exactly the kind of text that can end up in a log or a
+    # GitHub comment (coord.db._migrate_if_needed's docstring states the
+    # policy this follows). sql.redact_dsn() prints host/dbname only.
+    target_line = sql.redact_dsn(dsn) if dsn else "(dry-run -- target is never opened)"
+    click.echo(f"Target: {target_line}")
+
+    try:
+        report = run_import(sqlite_path=source_path, dsn=dsn or "", force=force, dry_run=dry_run)
+    except ImportAborted as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    click.echo()
+    if report.dry_run:
+        # The target is never opened for a dry run, so TableReport.target_rows
+        # is a placeholder 0 -- printing a source/target/status table here
+        # would read every table as a false "MISMATCH". Report source counts
+        # only; the audits (referential integrity, type affinity) already ran
+        # and would have raised ImportAborted above if either found anything.
+        click.echo(f"{'table':<30} {'source rows':>12}")
+        for t in report.tables:
+            click.echo(f"{t.table:<30} {t.source_rows:>12}")
+        click.echo(
+            "\nAudits passed (referential integrity, type affinity). "
+            "Dry run -- no target opened, no rows written."
+        )
+        return
+
+    click.echo(f"{'table':<30} {'source':>10} {'target':>10}  status")
+    all_ok = True
+    for t in report.tables:
+        status = "OK" if t.ok else "MISMATCH"
+        if not t.ok:
+            all_ok = False
+        click.echo(f"{t.table:<30} {t.source_rows:>10} {t.target_rows:>10}  {status}")
+
+    if not all_ok:
+        raise click.ClickException(
+            "row-count parity mismatch after import -- see table above; the target "
+            "was written but does not match the source row-for-row"
+        )
+    click.echo("\nImport complete: row-count parity confirmed for every table.")

{code_coordinator-0.5.273 → code_coordinator-0.5.274}/coord/db.py

@@ -361,6 +361,20 @@ def _open_postgres(dsn: str) -> Any:
     return conn
 
 
+def open_postgres_connection(dsn: str) -> Any:
+    """Public entry point onto :func:`_open_postgres` for tooling that needs
+    a fully-migrated Postgres connection outside the ``get_connection()``
+    singleton -- today, only ``coord.store_migrate``'s importer (#828), which
+    opens a target that may not (yet) be the DSN this process's own
+    ``coordinator.yml`` names, so it calls this directly with whatever DSN
+    the operator gave it rather than going through :func:`get_connection`'s
+    config-resolution path. Same guarantees as every other caller of
+    :func:`_open_postgres`: refuses under pytest, and runs the same schema
+    creation/migration path SQLite gets (#827 item 3).
+    """
+    return _open_postgres(dsn)
+
+
 # #2752: a clean, tagged release is always exactly "X.Y.Z" -- setuptools_scm
 # only emits anything else (a ".devN+g<sha>" local/dev suffix, a bare
 # "0+unknown" when no distribution resolves at all, or git-describe's

{code_coordinator-0.5.273 → code_coordinator-0.5.274}/coord/sql.py

@@ -46,8 +46,10 @@ text for the same intent.
 
 from __future__ import annotations
 
+import re
 from pathlib import Path
 from typing import Any, Iterable, Sequence
+from urllib.parse import urlsplit, urlunsplit
 
 # ── dialects ──────────────────────────────────────────────────────────────
 #
@@ -77,6 +79,55 @@ class UnsupportedDialectError(ValueError):
 POSTGRES_EXTRA_INSTALL_HINT = "pip install 'code-coordinator[postgres]'"
 
 
+# Libpq keyword=value DSN tokens: ``key=value`` or ``key='quoted value'``
+# (single-quoted values may escape ``\'`` and ``\\`` per libpq's own
+# grammar). Used only by :func:`redact_dsn` below.
+_DSN_KV_RE = re.compile(r"(\w+)\s*=\s*('(?:\\.|[^'\\])*'|\S+)")
+
+
+def redact_dsn(dsn: str) -> str:
+    """*dsn* with every credential-bearing field removed -- safe to print,
+    log, or post as a GitHub comment.
+
+    A Postgres DSN routinely embeds ``user:password@host`` (URI form,
+    ``postgresql://user:pass@host:port/db``) or ``user=... password=...``
+    (libpq keyword=value form, ``host=... dbname=... user=... password=...``)
+    -- ``coord/db.py``'s ``_migrate_if_needed`` docstring already states the
+    policy this exists to satisfy: a DSN must "deliberately never" appear in
+    text that "can end up in a log or a GitHub comment", since agent failure
+    reports post their captured stdout/stderr verbatim. Every caller that
+    would otherwise echo a configured ``store.dsn`` (e.g. ``coord
+    migrate-to-postgres``'s ``--dsn`` echo) must route through this first.
+
+    Returns host/dbname only (port too, when the DSN specifies one) -- not a
+    masked-but-recognizable form, so nothing of the credential survives even
+    truncated. Handles both DSN shapes; an unparseable field is rendered as
+    ``?`` rather than raising, since this exists for a diagnostic message,
+    not validation -- a malformed DSN should fail *later*, at
+    :func:`connect`, with a real error naming what's wrong.
+    """
+    stripped = dsn.strip()
+    if "://" in stripped:
+        parts = urlsplit(stripped)
+        host = parts.hostname or "?"
+        if parts.port:
+            host = f"{host}:{parts.port}"
+        dbname = parts.path.lstrip("/") or "?"
+        return urlunsplit((parts.scheme, host, dbname, "", ""))
+
+    def _unquote(value: str) -> str:
+        if len(value) >= 2 and value[0] == "'" and value[-1] == "'":
+            return value[1:-1].replace("\\'", "'").replace("\\\\", "\\")
+        return value
+
+    fields = {key: _unquote(value) for key, value in _DSN_KV_RE.findall(stripped)}
+    host = fields.get("host", "?")
+    if fields.get("port"):
+        host = f"{host}:{fields['port']}"
+    dbname = fields.get("dbname", "?")
+    return f"host={host} dbname={dbname}"
+
+
 def _import_psycopg() -> Any:
     """Import ``psycopg``, translating its absence into an actionable message
     (#2886).
@@ -478,6 +529,77 @@ def autoincrement_pk_ddl(dialect: str) -> str:
     raise UnsupportedDialectError(dialect)
 
 
+def identity_columns(conn: Any, table: str) -> list[str]:
+    """Column names in *table* declared ``GENERATED { ALWAYS | BY DEFAULT }
+    AS IDENTITY`` -- i.e. produced by :func:`autoincrement_pk_ddl`'s Postgres
+    branch. Always ``[]`` on SQLite: ``AUTOINCREMENT`` is a ROWID alias, not
+    a separate sequence object, so there is nothing to fall out of sync
+    (see :func:`resync_identity_sequence`).
+
+    Used by ``coord.store_migrate.import_table`` -- a bulk import writes
+    explicit ``id`` values into these columns (accepted by
+    ``GENERATED BY DEFAULT``, unlike ``GENERATED ALWAYS``), which does not
+    itself advance the underlying sequence, so the caller must resync it
+    afterward or the next ordinary write collides with an id the import
+    already used.
+    """
+    dialect = detect_dialect(conn)
+    if dialect == DIALECT_SQLITE:
+        return []
+    if dialect == DIALECT_POSTGRES:
+        cur = execute(
+            conn,
+            "SELECT column_name FROM information_schema.columns "
+            "WHERE table_name = ? AND identity_generation IS NOT NULL "
+            "ORDER BY ordinal_position",
+            (table,),
+        )
+        names = []
+        for row in cur.fetchall():
+            try:
+                names.append(row["column_name"])
+            except (KeyError, TypeError, IndexError):
+                names.append(row[0])
+        return names
+    raise UnsupportedDialectError(dialect)
+
+
+def resync_identity_sequence(conn: Any, table: str, column: str) -> None:
+    """Advance *table*.*column*'s identity sequence to match the data
+    actually in the table -- a no-op on SQLite.
+
+    A bulk import that INSERTs explicit ``id`` values into a
+    ``GENERATED BY DEFAULT AS IDENTITY`` column (see
+    :func:`autoincrement_pk_ddl`) does not advance that column's sequence as
+    a side effect -- the sequence only moves when something calls
+    ``nextval()`` on it, which an explicit-value INSERT never does. Left
+    unresynced, the next ordinary write with no explicit id (how every
+    caller in this tree writes today) is handed a value the import already
+    used and rejected as a primary-key violation.
+
+    ``setval(pg_get_serial_sequence(...), ..., is_called)``'s three-arg form
+    is used rather than the two-arg form specifically for the empty-table
+    case: with *is_called* explicitly computed as "does the table have any
+    rows", an empty table correctly leaves the sequence so the *next*
+    ``nextval()`` returns the identity's own start value (1) instead of 2,
+    which the two-arg form (which always behaves as if ``is_called=true``)
+    would get wrong.
+    """
+    dialect = detect_dialect(conn)
+    if dialect == DIALECT_SQLITE:
+        return
+    if dialect == DIALECT_POSTGRES:
+        execute(
+            conn,
+            "SELECT setval(pg_get_serial_sequence(?, ?), "
+            f'COALESCE((SELECT MAX("{column}") FROM "{table}"), 1), '  # noqa: S608 -- column/table from introspection, not user input
+            f'(SELECT MAX("{column}") FROM "{table}") IS NOT NULL)',  # noqa: S608
+            (table, column),
+        )
+        return
+    raise UnsupportedDialectError(dialect)
+
+
 # SQLite has no BOOLEAN type -- every flag column in coord/db.py's schema
 # (e.g. ``pinned INTEGER NOT NULL DEFAULT 0``, ``hold_after INTEGER NOT
 # NULL DEFAULT 0``) is declared ``INTEGER DEFAULT 0``, using 0/1 as
@@ -606,6 +728,71 @@ def table_columns(conn: Any, table: str) -> list[tuple[str, str]]:
     raise UnsupportedDialectError(dialect)
 
 
+def foreign_keys(conn: Any, table: str) -> list[tuple[str, str, str]]:
+    """Return ``[(from_column, ref_table, ref_column), ...]`` for every FK
+    *table* declares (empty if none, or if *table* doesn't exist) --
+    portably across SQLite's ``PRAGMA foreign_key_list(...)`` and Postgres's
+    standard ``information_schema`` constraint views (#828).
+
+    SQLite's FK introspection is a pragma, like ``table_info`` above -- same
+    reasoning, same fix: this is the one place that pragma's statement text
+    may appear outside ``coord/db.py``, so a caller (``coord.store_migrate``,
+    today) never writes it directly. Postgres has no single-pragma
+    equivalent; the standard three-way join across
+    ``information_schema.table_constraints`` /
+    ``key_column_usage`` / ``constraint_column_usage`` is the SQL-standard
+    way to ask "what does this table reference, and through which column"
+    without touching Postgres's own (non-standard) ``pg_catalog`` tables.
+
+    The table name is interpolated into the SQLite ``PRAGMA`` text for the
+    same reason :func:`table_columns` does -- pragmas take no bound
+    parameter for their target object; every call site passes a hardcoded
+    table constant, never user input.
+
+    Known limitation, Postgres branch: the three-way join keys purely on
+    ``constraint_name``/``table_schema``, with no ordinal-position join
+    between ``key_column_usage`` and ``constraint_column_usage``. For a
+    *composite* (multi-column) foreign key this can mis-pair columns --
+    e.g. return ``(col_a, ref_table, ref_col_b)`` instead of the two
+    correctly-paired single-column edges. Not triggered today: the schema
+    has exactly one FK, and it's single-column. Fix before adding a
+    composite FK to ``coord/db.py``'s schema: join on ``ordinal_position``
+    too (Postgres exposes it on both views).
+    """
+    dialect = detect_dialect(conn)
+    if dialect == DIALECT_SQLITE:
+        cur = execute(conn, f"PRAGMA foreign_key_list({table})")  # noqa: S608 -- table name, not user input
+        edges = []
+        for row in cur.fetchall():
+            values = tuple(row)
+            # id, seq, table, from, to, on_update, on_delete, match
+            edges.append((values[3], values[2], values[4] or "rowid"))
+        return edges
+    if dialect == DIALECT_POSTGRES:
+        cur = execute(
+            conn,
+            "SELECT kcu.column_name, ccu.table_name AS ref_table, "
+            "ccu.column_name AS ref_column "
+            "FROM information_schema.table_constraints tc "
+            "JOIN information_schema.key_column_usage kcu "
+            "  ON tc.constraint_name = kcu.constraint_name "
+            "  AND tc.table_schema = kcu.table_schema "
+            "JOIN information_schema.constraint_column_usage ccu "
+            "  ON tc.constraint_name = ccu.constraint_name "
+            "  AND tc.table_schema = ccu.table_schema "
+            "WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = ?",
+            (table,),
+        )
+        edges = []
+        for row in cur.fetchall():
+            try:
+                edges.append((row["column_name"], row["ref_table"], row["ref_column"]))
+            except (KeyError, TypeError, IndexError):
+                edges.append((row[0], row[1], row[2]))
+        return edges
+    raise UnsupportedDialectError(dialect)
+
+
 # ── WAL (#2782) ───────────────────────────────────────────────────────────
 #
 # WAL is a SQLite storage concept with no Postgres equivalent at all -- unlike