attocode-code-intel 0.1.0__py3-none-any.whl

attocode_intel/migrations/versions/014_blame_hunks.py

@@ -0,0 +1,40 @@
+"""Add blame_hunks table for DB-backed blame data.
+
+Revision ID: 014
+Revises: 013
+Create Date: 2026-03-15
+"""
+from __future__ import annotations
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "014"
+down_revision: Union[str, None] = "013"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "blame_hunks",
+        sa.Column("id", sa.dialects.postgresql.UUID(as_uuid=True), primary_key=True),
+        sa.Column("repo_id", sa.dialects.postgresql.UUID(as_uuid=True), sa.ForeignKey("repositories.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("path", sa.Text(), nullable=False),
+        sa.Column("branch_name", sa.Text(), nullable=False, server_default="main"),
+        sa.Column("commit_oid", sa.Text(), nullable=False),
+        sa.Column("author_name", sa.Text(), nullable=False),
+        sa.Column("author_email", sa.Text(), nullable=False),
+        sa.Column("timestamp", sa.BigInteger(), nullable=False),
+        sa.Column("start_line", sa.Integer(), nullable=False),
+        sa.Column("end_line", sa.Integer(), nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+    )
+    op.create_index("ix_blame_hunks_repo_path_branch", "blame_hunks", ["repo_id", "path", "branch_name"])
+
+
+def downgrade() -> None:
+    op.drop_index("ix_blame_hunks_repo_path_branch", table_name="blame_hunks")
+    op.drop_table("blame_hunks")

attocode_intel/migrations/versions/015_commit_file_stats.py

@@ -0,0 +1,40 @@
+"""Add commit_file_stats table for per-file commit statistics.
+
+Revision ID: 015
+Revises: 014
+Create Date: 2026-03-21
+"""
+from __future__ import annotations
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "015"
+down_revision: Union[str, None] = "014"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "commit_file_stats",
+        sa.Column("id", sa.dialects.postgresql.UUID(as_uuid=True), primary_key=True),
+        sa.Column("commit_id", sa.dialects.postgresql.UUID(as_uuid=True), sa.ForeignKey("commits.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("repo_id", sa.dialects.postgresql.UUID(as_uuid=True), sa.ForeignKey("repositories.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("path", sa.Text(), nullable=False),
+        sa.Column("lines_added", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column("lines_removed", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column("symbols_changed", sa.dialects.postgresql.JSONB(), nullable=False, server_default="[]"),
+        sa.Column("change_type", sa.Text(), nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+    )
+    op.create_index("ix_commit_file_stats_repo_path", "commit_file_stats", ["repo_id", "path"])
+    op.create_index("ix_commit_file_stats_commit_id", "commit_file_stats", ["commit_id"])
+
+
+def downgrade() -> None:
+    op.drop_index("ix_commit_file_stats_commit_id", table_name="commit_file_stats")
+    op.drop_index("ix_commit_file_stats_repo_path", table_name="commit_file_stats")
+    op.drop_table("commit_file_stats")

attocode_intel/migrations/versions/016_embedding_provenance_columns.py

@@ -0,0 +1,179 @@
+"""Add provenance columns to embeddings (non-destructive).
+
+This migration addresses the "embedding model/dimension silently wipes all
+vectors" footgun by introducing explicit provenance columns — *without*
+touching the primary ``vector`` column. Re-dimensioning is handled via a
+separate rotation flow in a later phase; this migration is purely additive.
+
+Changes:
+  - Add ``embeddings.embedding_model_version`` (text, default '').
+  - Add ``embeddings.embedding_dim`` (int, nullable — backfilled from
+    ``vector_dims(vector)`` for rows where pgvector is available).
+  - Add ``embeddings.embedding_provenance`` (JSONB, default '{}').
+  - Replace the ``(content_sha, embedding_model, chunk_type)`` unique with
+    ``(content_sha, embedding_model, embedding_model_version, chunk_type)``
+    so two versions of the same model can coexist during rotation.
+
+Revision ID: 016
+Revises: 015
+Create Date: 2026-04-10
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import sqlalchemy as sa
+from alembic import op
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+revision: str = "016"
+down_revision: str | None = "015"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # 1. Add new columns with safe defaults so existing rows don't break.
+    op.add_column(
+        "embeddings",
+        sa.Column(
+            "embedding_model_version",
+            sa.Text(),
+            nullable=False,
+            server_default="",
+        ),
+    )
+    op.add_column(
+        "embeddings",
+        sa.Column(
+            "embedding_dim",
+            sa.Integer(),
+            nullable=True,
+        ),
+    )
+    op.add_column(
+        "embeddings",
+        sa.Column(
+            "embedding_provenance",
+            sa.dialects.postgresql.JSONB(),
+            nullable=False,
+            server_default="{}",
+        ),
+    )
+
+    # 2. Backfill embedding_dim from pgvector's vector_dims() where possible.
+    #    Rows without a vector (vector IS NULL) stay NULL.
+    #
+    #    Done in a DO block so a connection lacking the `vector` extension
+    #    or the `vector` column still lets the migration run on brand-new
+    #    databases where ensure_vector_column() hasn't fired yet.
+    op.execute(
+        """
+        DO $$
+        BEGIN
+            IF EXISTS (
+                SELECT 1 FROM information_schema.columns
+                WHERE table_name = 'embeddings' AND column_name = 'vector'
+            ) THEN
+                EXECUTE 'UPDATE embeddings SET embedding_dim = vector_dims(vector) '
+                        'WHERE vector IS NOT NULL';
+            END IF;
+        END $$;
+        """
+    )
+
+    # 3. Replace the unique constraint to include embedding_model_version.
+    #    During rotation two versions of the same model coexist in place.
+    op.drop_constraint(
+        "uq_embedding_content_model_chunk",
+        "embeddings",
+        type_="unique",
+    )
+    op.create_unique_constraint(
+        "uq_embedding_content_model_version_chunk",
+        "embeddings",
+        ["content_sha", "embedding_model", "embedding_model_version", "chunk_type"],
+    )
+
+    # 4. Helpful secondary index for provenance lookups.
+    op.create_index(
+        "ix_embeddings_model_version",
+        "embeddings",
+        ["embedding_model", "embedding_model_version"],
+    )
+
+
+def downgrade() -> None:
+    """Revert the non-destructive dual-column rewrite.
+
+    A naive downgrade (drop the wide unique key, recreate the narrow
+    one) fails outright when a dual-version rotation has left multiple
+    ``embedding_model_version`` values for the same
+    ``(content_sha, embedding_model, chunk_type)`` tuple — recreating
+    the narrow unique constraint raises at DDL time.
+
+    Safe default: REFUSE the downgrade unless the operator sets
+    ``ATTOCODE_ALLOW_DESTRUCTIVE_016_DOWNGRADE``. When set, delete every
+    row whose ``embedding_model_version`` is non-empty first (logging
+    the count) and then rewrite. Pre-rotation databases (every row has
+    ``embedding_model_version = ''``) downgrade cleanly without the
+    flag.
+    """
+    import logging
+    import os
+
+    logger = logging.getLogger("alembic.016")
+
+    bind = op.get_bind()
+    conflicts_row = bind.execute(
+        sa.text(
+            "SELECT COUNT(*) FROM embeddings "
+            "WHERE embedding_model_version IS NOT NULL "
+            "  AND embedding_model_version != ''"
+        )
+    ).fetchone()
+    conflict_count = int(conflicts_row[0] or 0) if conflicts_row else 0
+
+    if conflict_count > 0:
+        allow = os.environ.get(
+            "ATTOCODE_ALLOW_DESTRUCTIVE_016_DOWNGRADE", ""
+        ).lower() in {"1", "true", "yes"}
+        if not allow:
+            raise RuntimeError(
+                f"Refusing to downgrade migration 016: {conflict_count} "
+                f"embedding row(s) carry a non-empty "
+                f"embedding_model_version, which would violate the "
+                f"recreated (content_sha, embedding_model, chunk_type) "
+                f"unique constraint. Set "
+                f"ATTOCODE_ALLOW_DESTRUCTIVE_016_DOWNGRADE=1 to confirm "
+                f"the destructive downgrade (this will DELETE those rows)."
+            )
+        logger.warning(
+            "016 downgrade: destructive flag set, deleting %d "
+            "embedding row(s) with non-empty embedding_model_version",
+            conflict_count,
+        )
+        bind.execute(
+            sa.text(
+                "DELETE FROM embeddings "
+                "WHERE embedding_model_version IS NOT NULL "
+                "  AND embedding_model_version != ''"
+            )
+        )
+
+    op.drop_index("ix_embeddings_model_version", table_name="embeddings")
+    op.drop_constraint(
+        "uq_embedding_content_model_version_chunk",
+        "embeddings",
+        type_="unique",
+    )
+    op.create_unique_constraint(
+        "uq_embedding_content_model_chunk",
+        "embeddings",
+        ["content_sha", "embedding_model", "chunk_type"],
+    )
+    op.drop_column("embeddings", "embedding_provenance")
+    op.drop_column("embeddings", "embedding_dim")
+    op.drop_column("embeddings", "embedding_model_version")

attocode_intel/migrations/versions/017_provenance_table.py

@@ -0,0 +1,102 @@
+"""Add provenance table — one row per derived code-intel artifact.
+
+A ``Provenance`` row records how a symbol set / embedding / dep graph /
+repo-map slice was produced: which indexer, which version, which blob was
+the input, when, and by whom. Joined into derived-artifact queries by
+``action_hash``.
+
+Per-row storage here rather than a JSONB column on every derived table
+because:
+  - Multiple artifact types want the same shape (no duplication).
+  - Queries like "find everything produced by indexer X version Y" are
+    common for audit / GC and would be O(n_tables) with per-table JSONB.
+  - Provenance should outlive the derived row it describes (for audit).
+
+Revision ID: 017
+Revises: 016
+Create Date: 2026-04-10
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import sqlalchemy as sa
+from alembic import op
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+revision: str = "017"
+down_revision: str | None = "016"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "provenance",
+        sa.Column(
+            "id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            primary_key=True,
+            server_default=sa.text("gen_random_uuid()"),
+        ),
+        sa.Column("action_hash", sa.Text(), nullable=False),
+        sa.Column("artifact_type", sa.Text(), nullable=False),
+        sa.Column("input_blob_oid", sa.Text(), nullable=False),
+        sa.Column("input_tree_oid", sa.Text(), nullable=True),
+        sa.Column("indexer_name", sa.Text(), nullable=False),
+        sa.Column("indexer_version", sa.Text(), nullable=False),
+        sa.Column("config_digest", sa.Text(), nullable=False),
+        sa.Column(
+            "produced_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.func.now(),
+            nullable=False,
+        ),
+        sa.Column(
+            "producer_service",
+            sa.Text(),
+            nullable=False,
+            server_default="attocode-server",
+        ),
+        sa.Column(
+            "producer_user_id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("users.id", ondelete="SET NULL"),
+            nullable=True,
+        ),
+        sa.Column(
+            "producer_job_id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("indexing_jobs.id", ondelete="SET NULL"),
+            nullable=True,
+        ),
+        sa.Column("producer_host", sa.Text(), nullable=False, server_default=""),
+        sa.Column(
+            "extra",
+            sa.dialects.postgresql.JSONB(),
+            nullable=False,
+            server_default="{}",
+        ),
+    )
+    # action_hash is not quite unique: if the same artifact is re-produced
+    # (idempotent indexer rerun with identical inputs) we still want a new
+    # provenance row for audit purposes. So no UNIQUE, but an index for fast
+    # dedup joins.
+    op.create_index("ix_provenance_action_hash", "provenance", ["action_hash"])
+    op.create_index("ix_provenance_input_blob", "provenance", ["input_blob_oid"])
+    op.create_index("ix_provenance_job", "provenance", ["producer_job_id"])
+    op.create_index(
+        "ix_provenance_indexer_version",
+        "provenance",
+        ["indexer_name", "indexer_version"],
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_provenance_indexer_version", table_name="provenance")
+    op.drop_index("ix_provenance_job", table_name="provenance")
+    op.drop_index("ix_provenance_input_blob", table_name="provenance")
+    op.drop_index("ix_provenance_action_hash", table_name="provenance")
+    op.drop_table("provenance")

attocode_intel/migrations/versions/018_repo_snapshots.py

@@ -0,0 +1,178 @@
+"""Add repo_snapshots + repo_snapshot_components tables.
+
+A ``repo_snapshot`` row records a point-in-time manifest hash of a repo's
+code-intel state (branch manifest + derived artifacts). Components
+(symbols / embeddings / deps / content slice) are stored in a sibling
+table so downstream tools can walk the component list, fetch individual
+blobs from ``file_contents`` / related stores, and reassemble the
+snapshot without unpacking a monolithic tarball.
+
+The shape of this table is forward-compatible with Phase 3b's OCI
+adapter: every row's ``manifest_hash`` matches the SHA-256 of a canonical
+JSON manifest that maps 1:1 to an OCI image manifest (``config`` +
+``layers`` with media types) without schema changes.
+
+Revision ID: 018
+Revises: 017
+Create Date: 2026-04-10
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import sqlalchemy as sa
+from alembic import op
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+revision: str = "018"
+down_revision: str | None = "017"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "repo_snapshots",
+        sa.Column(
+            "id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            primary_key=True,
+            server_default=sa.text("gen_random_uuid()"),
+        ),
+        sa.Column(
+            "org_id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("organizations.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column(
+            "repo_id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("repositories.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column(
+            "branch_id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("branches.id", ondelete="SET NULL"),
+            nullable=True,
+        ),
+        sa.Column("name", sa.Text(), nullable=False),
+        sa.Column("description", sa.Text(), nullable=False, server_default=""),
+        sa.Column("manifest_hash", sa.Text(), nullable=False),
+        # Total bytes across every component, for at-a-glance sizing in the
+        # list endpoint (no need to scan component rows on every list call).
+        sa.Column(
+            "total_bytes",
+            sa.BigInteger(),
+            nullable=False,
+            server_default="0",
+        ),
+        sa.Column(
+            "component_count",
+            sa.Integer(),
+            nullable=False,
+            server_default="0",
+        ),
+        # Commit pinning — stored as a plain string so even repos without a
+        # commits table entry (e.g. local_path only) can still be pinned.
+        sa.Column("commit_oid", sa.Text(), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.func.now(),
+            nullable=False,
+        ),
+        sa.Column(
+            "created_by_user_id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("users.id", ondelete="SET NULL"),
+            nullable=True,
+        ),
+        sa.Column(
+            "extra",
+            sa.dialects.postgresql.JSONB(),
+            nullable=False,
+            server_default="{}",
+        ),
+    )
+    # Unique per (repo_id, name) so you can't shadow an existing named
+    # snapshot — forces the user to delete + recreate.
+    op.create_unique_constraint(
+        "uq_repo_snapshots_repo_name",
+        "repo_snapshots",
+        ["repo_id", "name"],
+    )
+    op.create_index(
+        "ix_repo_snapshots_repo_created",
+        "repo_snapshots",
+        ["repo_id", "created_at"],
+    )
+    op.create_index(
+        "ix_repo_snapshots_org",
+        "repo_snapshots",
+        ["org_id"],
+    )
+
+    op.create_table(
+        "repo_snapshot_components",
+        sa.Column(
+            "id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            primary_key=True,
+            server_default=sa.text("gen_random_uuid()"),
+        ),
+        sa.Column(
+            "snapshot_id",
+            sa.dialects.postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("repo_snapshots.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column("name", sa.Text(), nullable=False),
+        sa.Column("media_type", sa.Text(), nullable=False),
+        # Each component is content-addressed by a SHA-256 digest (in the
+        # OCI ``sha256:<hex>`` form). For symbol_set_v1 / embedding_blob_v1
+        # components this lines up with the content_store action hash.
+        sa.Column("digest", sa.Text(), nullable=False),
+        sa.Column("size_bytes", sa.BigInteger(), nullable=False, server_default="0"),
+        sa.Column(
+            "extra",
+            sa.dialects.postgresql.JSONB(),
+            nullable=False,
+            server_default="{}",
+        ),
+    )
+    op.create_index(
+        "ix_repo_snapshot_components_snapshot",
+        "repo_snapshot_components",
+        ["snapshot_id"],
+    )
+    op.create_index(
+        "ix_repo_snapshot_components_digest",
+        "repo_snapshot_components",
+        ["digest"],
+    )
+
+
+def downgrade() -> None:
+    op.drop_index(
+        "ix_repo_snapshot_components_digest",
+        table_name="repo_snapshot_components",
+    )
+    op.drop_index(
+        "ix_repo_snapshot_components_snapshot",
+        table_name="repo_snapshot_components",
+    )
+    op.drop_table("repo_snapshot_components")
+    op.drop_index("ix_repo_snapshots_org", table_name="repo_snapshots")
+    op.drop_index(
+        "ix_repo_snapshots_repo_created", table_name="repo_snapshots",
+    )
+    op.drop_constraint(
+        "uq_repo_snapshots_repo_name",
+        "repo_snapshots",
+        type_="unique",
+    )
+    op.drop_table("repo_snapshots")

attocode_intel/migrations/versions/019_symref_caller.py

@@ -0,0 +1,42 @@
+"""Add caller_qualified_name to symbol_references for call-graph attribution.
+
+Pairs with the function-level call graph in CrossRefIndex (Phase 1, A1).
+Without this column, the full-indexer pipeline persists references but
+loses the enclosing function/method, which makes call_graph queries over
+HTTP-indexed repos return empty edges.
+
+Revision ID: 019
+Revises: 018
+Create Date: 2026-05-03
+"""
+from __future__ import annotations
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "019"
+down_revision: Union[str, None] = "018"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "symbol_references",
+        sa.Column(
+            "caller_qualified_name",
+            sa.String(500),
+            nullable=False,
+            server_default="",
+        ),
+    )
+    op.create_index(
+        "ix_symref_caller", "symbol_references", ["caller_qualified_name"],
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_symref_caller", "symbol_references")
+    op.drop_column("symbol_references", "caller_qualified_name")

attocode_intel/migrations/versions/020_shared_knowledge.py

@@ -0,0 +1,29 @@
+"""Durable repository knowledge shared across clients and committed revisions."""
+from alembic import op
+import sqlalchemy as sa
+
+revision = "020"
+down_revision = "019"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table("knowledge_entries",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("repo_id", sa.Uuid(), sa.ForeignKey("repositories.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("author_id", sa.String(64), nullable=False),
+        sa.Column("kind", sa.String(16), nullable=False),
+        sa.Column("status", sa.String(16), nullable=False),
+        sa.Column("scope", sa.Text(), nullable=False),
+        sa.Column("payload", sa.JSON(), nullable=False),
+        sa.Column("revision", sa.String(64), nullable=False),
+        sa.Column("anchor_hash", sa.String(64), nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+    )
+    op.create_index("ix_knowledge_entries_repo_id", "knowledge_entries", ["repo_id"])
+
+
+def downgrade():
+    op.drop_table("knowledge_entries")