rankops 0.1.20__tar.gz

rankops-0.1.20/.cursor/rules/integration-priorities.mdc

@@ -0,0 +1,104 @@
+---
+title: "Integration Priorities"
+id: integration-priorities
+description: "Guidelines for how Tekne repositories interact and point to canonical overview"
+globs: ["Cargo.toml", "evals/arch/dev_repos_overview.html", "evals/arch/**/*.html", "docs/**/*.md", "README.md"]
+alwaysApply: true
+---
+
+# Integration Priorities: What Actually Matters
+
+## Canonical integration view (single HTML artifact)
+
+**Canonical file**: `evals/arch/dev_repos_overview.html`
+
+**Rule**: If you need to understand or explain how repos interact, update that one HTML page instead of creating a new report page.
+
+**It should contain**:
+- **Levels (L0–L6)**: group repos by the Tekne stack layers (conceptual).
+- **Repo-level graph**: integration edges (git deps, `[patch]` overrides, and the local “super-workspace”).
+- **Crate-level graph**: the dev workspace view (“what Cargo sees”) plus a small conceptual edge set, and a mismatch table.
+- **Tekne facade table**: feature ↔ crate mapping.
+- **Recent activity + size**: the few biggest disk drivers + a short “what changed recently” list.
+- **Axes view**: call out which repos are Tekne (L0–L6) vs Agents (A0–A3) vs Governance (G0–G5), since these are different partial orders.
+
+**Links**:
+- `tekne-core.mdc` defines the *meaning* of levels (L0–L6).
+- `tekne-module-taxonomy.mdc` assesses doc quality by module; it is not a dependency graph.
+
+## The Ecosystem at a Glance
+
+```
+PRODUCTION SCALE                        MATH PRIMITIVES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+anno      371.3K LOC  7531 tests        equi          17 LOC     0 tests
+cerno      90.5K LOC  2627 tests        fynch       1.5K LOC    53 tests
+hop       117.8K LOC  2410 tests        walk         234 LOC     0 tests
+innr        4.5K LOC   153 tests        helm          21 LOC     0 tests
+jin        29.8K LOC   367 tests        hyp           2K LOC    51 tests
+subsume    14.5K LOC   282 tests        kuji         738 LOC    15 tests
+tier        4.7K LOC    76 tests        lapl         968 LOC    13 tests
+webs       13.9K LOC   253 tests        law           38 LOC     0 tests
+weigh          4 LOC     0 tests        liga          12 LOC     0 tests
+                                        logp         567 LOC    10 tests
+                                        pare         403 LOC     3 tests
+                                        propago     4.7K LOC     0 tests
+                                        qig          148 LOC     4 tests
+                                        ritu          49 LOC     0 tests
+                                        rkhs        1.3K LOC    23 tests
+                                        rmt          230 LOC     7 tests
+                                        textprep     197 LOC     3 tests
+                                        sbits        736 LOC     8 tests
+                                        sign          15 LOC     0 tests
+                                        slabs       2.3K LOC    82 tests
+                                        telic         31 LOC     0 tests
+                                        wass         691 LOC    13 tests
+```
+
+## The Real Problems
+
+### Problem 1: Differentiable ranking should stay centralized
+`fynch` is the single canonical crate for differentiable sort/rank/top-k.
+
+### Problem 2: fynch/metrics vs cerno-eval Overlap
+Keep **core rank-based** metrics in one place (e.g. `fynch::metrics`), and keep domain adapters (IR / KGE / NED) in their domain crates.
+
+### Problem 3: New Math Crates Are Islands
+The “islands” problem is missing usage/tests, not missing dependency edges. Ensure integration tests verify that combining components improves outcomes versus using them individually.
+
+### Problem 4: Hypha integration
+`hypha` provides the P2P substrate. `bop` (Agents) should eventually run *over* `hypha` for distributed coordination. `hypha-knowledge` should leverage `jin` (L3) for vector storage to avoid duplication. `recal` provides the agent's long-term memory via FTS5/vector retrieval.
+
+### Problem 5: Graph Layer Split
+Keep `lattix` as the low-level graph core (L3/L4) and `webs` as the high-level knowledge graph layer (L5). `webs` consumes `lattix` types.
+
+### Problem 6: Cross-axis coupling creep
+The most common structural regression is accidental coupling where:
+- Tekne crates start depending on Agents or Governance crates, making the substrate “application-shaped”
+- Governance becomes a compile-time cross-cutting dependency instead of a gate/eval layer
+
+Prefer governance as *inputs/outputs* (policy decisions, eval reports) over ubiquitous imports.
+
+### Problem 7: Sparse lexical retrieval has no clear “low-level home”
+Right now, **BM25/TF‑IDF + (learned) sparse retrieval** lives in `cerno-retrieve` (L5 Domain), but the underlying **inverted-index engine** shape belongs lower:
+
+- **L1/L1.5**: scoring math + tokenization/normalization (`textprep`)
+- **L3**: inverted index / segments / deletes / compaction / persistence format
+- **L5**: pipelines (BM25 → rerank), hybrid orchestration, adapters
+
+For a publishable, reusable L3 “sparse index” crate, borrow the *constraints-first* boundary from BurntSushi’s Nakala plan:
+- keep tokenization pluggable (don’t bake in language-specific processing)
+- keep query model small (boolean term queries are enough to start)
+- avoid “fields/schema” early (multi-set of terms is the core)
+- index-only (don’t store document content)
+- handle deletes + segment merges as owned complexity
+
+Also keep the candidate-generation contract explicit:
+- **No false negatives** for the index/planner path: it may return false positives, but must not exclude a true match.
+- **Planner bailouts are required**: if the query is too broad, it must be legal to fall back to exhaustive scanning.
+
+Evidence/anchors:
+- ripgrep indexing RFC (`BurntSushi/ripgrep#1497`) and implementation discussion (`BurntSushi/ripgrep#1518`) are a concrete example of these constraints applied to regex candidate generation (n-gram index + verification).
+- Russ Cox’s trigram-index writeup is the canonical mental model for regex → boolean n-gram query → postings → verify.
+
+Reference: `https://raw.githubusercontent.com/BurntSushi/nakala/master/doc/PLAN.md`

rankops-0.1.20/.cursor/rules/super-workspace-context.mdc

@@ -0,0 +1,22 @@
+---
+description: Super-workspace context discipline (repo truth vs editor hints)
+globs: ["**/*"]
+alwaysApply: true
+---
+
+## Invariant: repo path is truth
+
+This workspace is a super-workspace containing many independent repos.
+
+- Treat `open_and_recently_viewed_files` as a UI hint only.
+- Never assume the currently open file indicates the repo/task being worked on.
+
+## Practical workflow
+
+- When a task is repo-scoped, first name the repo directory explicitly (e.g. `anno/`, `cerno/`, `wass/`, `devdev/tooling/dev-top/`).
+- Prefer pinning the repo root with `@Folders` before making multi-file changes.
+- Scope searches to the chosen repo directory (avoid whole-workspace scans unless explicitly needed).
+
+## Drift check (cheap)
+
+If the only open file(s) are outside the named repo, call that out and ask to pin the correct folder/file(s) before proceeding.

rankops-0.1.20/.cursor/rules/tekne-core.mdc

@@ -0,0 +1,212 @@
+---
+description: PRIMARY INVARIANTS for the Tekne Stack (L0-L6). This is the single source of truth for architecture and safety.
+globs: ["**/*.rs", "**/Cargo.toml"]
+alwaysApply: true
+---
+
+# Tekne Core Invariants (L0-L6)
+
+## 0.5 Dev Workspace Reality (this folder is not a repo)
+
+This Cursor workspace (the folder you opened in Cursor) is a **super-workspace** directory:
+
+- **Not a git repo**: do not assume `git` operations make sense at the workspace root.
+- **Many independent projects live side-by-side**: most subdirectories are their own repos (or archives), with their own history and tooling.
+- **One root Cargo workspace exists**: `Cargo.toml` at the root defines a *virtual* Rust workspace that includes a curated subset of crates across subdirectories.
+- **Cargo.lock is not present at the root**: dependency stability comes from per-crate `Cargo.lock` files (where used) and pinned workspace dependency versions in the root `Cargo.toml`.
+
+Implication: when reasoning about “the project”, be explicit about *which* layer you mean:
+\[
+\text{root dev folder} \;\supset\; \text{root Cargo workspace members} \;\supset\; \text{Tekne stack subset (one organizing view)}.
+\]
+
+## 0. The Principle of Economy of Thought
+**Goal**: Reduce the reasoning required to understand the system.
+*   **Framing over Computation**: Time spent finding the right mathematical framing (e.g. Invariants) beats time spent debugging executions.
+*   **Separation of Concerns**: 
+    *   **Efficiency** is settled in L0 (Iron).
+    *   **Correctness** is settled in L1 (Logic).
+    *   **Orchestration** is settled in L6 (Mesh).
+*   **The Five-Line Rule**: If a core logic argument or function body exceeds ~5 lines, reconsider the framing.
+
+## 1. The Layering Invariant (DAG Hard-Stop)
+The Tekne Stack is a Directed Acyclic Graph (DAG). **No lower layer may depend on a higher layer.**
+
+| Layer | Name | Domain | Responsibility |
+| :--- | :--- | :--- | :--- |
+| **L0** | **Iron** | Hardware/SIMD | Raw performance, vector similarity ($Cosine$, $L_2$). |
+| **L1** | **Logic** | Math Primitives | Scalar measures: Entropy, Divergences ($KL$, $JS$). |
+| **L2** | **Algos** | Composite | Differentiable sorting, optimal transport, kernels. |
+| **L3** | **Structures** | Aggregators | ANN Indices (`jin`), Hierarchy/aggregation (`tier`), Graph core (`lattix`). |
+| **L4** | **Embeddings** | Representations | Geometric boxes (`subsume`), Statistical mirror (`weigh`). |
+| **L5** | **Domain** | Systems/NLP/IR | NER/Coref (`anno`), Retrieval (`cerno`), Knowledge Graphs (`webs`). |
+| **L6** | **Orch** | Multi-Agent/Mesh | Retrieval/pipeline (`hop`), coordination substrate (`hypha`). |
+
+*   **Private Gravity**: If a higher-level system implements reusable logic, push it *down* to L0-L2.
+*   **Enforcement**: Prefer automated checks, but don’t assume a verifier exists.
+    If enforcement tooling is missing, treat the root `Cargo.toml` membership list as the source of truth.
+
+## 1.5 Multiple “Virtual Workspaces” Can Coexist
+
+`tekne` is one coherent naming/stack view used by the root Cargo workspace, but it is not the only possible organizing principle.
+
+- It’s acceptable to have other coherent sub-ecosystems (e.g., “Scholar stack”, “Infra ops”, editor plugins) living in the same dev directory.
+- Do not force everything into Tekne if the dependency DAG / semantics don’t fit.
+
+## 1.25 Three Parallel DAGs (Math/System vs Agents vs Governance)
+
+The “Tekne stack” (L0–L6) is a **math/system DAG**. Agent/tooling and governance are **different axes**.
+
+- **Math/System DAG**: operators, representations, and systems (e.g. `innr → logp → fynch → ... → anno/cerno/webs`).
+- **Agents/Tooling DAG**: agent contract engine + orchestration apps (e.g. `axi → bop`, which then *uses* the math/system crates).
+- **Governance DAG**: constraints/policy/oversight that can apply to both agents and systems, without being “higher math”.
+
+This avoids category errors like “`axi` should be L1”: agent contracts are not math primitives.
+
+### Why Tekne is “special”
+
+Tekne is special in one sense: it is the **reusable substrate DAG**.
+
+- If something is in Tekne, it should be *plausibly reusable* outside a single application.
+- Therefore Tekne is the place where we are strictest about:
+  - dependency direction (no higher → lower)
+  - Unicode correctness at boundaries (character offsets)
+  - stability of core types and invariants
+
+Agents and Governance can be equally rigorous, but they are *different* partial orders.
+
+### Agent/Tooling Tree (A0–A3)
+
+Use this when you want a *different* partial order than Tekne’s L0–L6:
+
+| Level | Name | Responsibility | Examples |
+| :--- | :--- | :--- | :--- |
+| **A0** | **Contracts** | Typed tool contracts, schema/repair, run traces | `axi` |
+| **A1** | **Adapters** | Providers/transports (LLM, MCP, storage) | (often lives inside `axi`/apps initially) |
+| **A2** | **Orchestration Apps** | The runnable agent application layer | `bop` |
+| **A3** | **Operations** | Deployment, cost, monitoring | (repo-specific) |
+
+### Governance Tree (G0–G5)
+
+Governance is its own axis (not “L7–L12 of Tekne”):
+
+| Level | Name | Responsibility | Repo |
+| :--- | :--- | :--- | :--- |
+| **G0** | **Adjudication** | deciding / evaluating / ruling | `law` |
+| **G1** | **Steering** | policy + strategy control | `helm` |
+| **G2** | **Equilibrium** | constraints / balance / alignment | `equi` |
+| **G3** | **Interface** | representation boundaries / signaling | `sign` |
+| **G4** | **Federation** | multi-party coordination contracts | `liga` |
+| **G5** | **Telos** | goals/purpose/intention | `telic` |
+
+### Cross-axis dependency rules (compile-time vs “gates”)
+
+**Compile-time dependencies (Cargo `dependencies`)**:
+
+- **Allowed**:
+  - Agents → Tekne (agents can use substrate)
+  - Governance → Tekne (governance can use substrate for scoring/metrics/types)
+  - Apps (A2) → Governance (apps may call adjudicators/steering code)
+- **Forbidden by default**:
+  - Tekne → Agents
+  - Tekne → Governance
+  - Governance → Agents (especially Governance → A2 apps)
+
+**Why**: if Tekne depends on Agents/Governance, the substrate becomes “application-shaped” and stops being substrate.
+
+**Governance should often be a gate, not a dependency**:
+
+- Prefer governance as *inputs/outputs* and pipeline checks:
+  - plan/request → policy decision
+  - run trace → evaluation/audit
+- Avoid “sprinkling governance imports everywhere” as a cross-cutting compile-time dependency, which tends to reintroduce cycles and coupling.
+
+## 2. The Naming Invariant (Structure > Style)
+
+**Naming Strategy**: Names should make the *structure* easier to see.
+
+\[
+\text{good name} \;\approx\; \text{a cheap index into the right invariants.}
+\]
+
+### Primary Preference: Structural Resonance
+
+- Prefer names that align with the *true symmetry* of the object:
+  - distance / similarity / norm / kernel / transport / rank / conformal / graph / lattice / contract / covenant / ledger
+- Prefer names that let readers guess the constraints:
+  - e.g. “rank fusion” vs “rerank” vs “retrieve” are distinct operators in a pipeline; names should preserve that.
+- Cross-language is encouraged when it improves precision (sometimes the original term is the most exact handle).
+
+### Secondary Preference: Etymology (cross-cultural only when helpful)
+
+- Culture is not the goal; *precision* is.
+- Use Sanskrit/Arabic/Old Norse/etc. when it carries the exact nuance for governance or agency concepts.
+- Use Latin/Greek/English when it better matches the mathematical framing.
+
+### Ecosystem/Prefix Coherence (important)
+
+- If a set of crates is meant to be used together, prefer a shared prefix.
+  - IR stack: prefer `cerno-*` as the canonical prefix (retrieve/fuse/rerank/eval/train + facade `cerno`).
+  - Text chunking: prefer `slabs` as canonical (avoid dual naming like `slabs` vs `slabs`).
+
+### crates.io Policy (mandatory, explicit)
+
+Always check crates.io **before** selecting a name (don’t guess).
+
+- If a name is **taken** on crates.io (HTTP 200), treat it as **unavailable** unless:
+  - the crate is permanently `publish = false`, and
+  - we accept that the name is *internal-only* (no future publish path).
+
+This prevents “pretty internal names” that block publication later.
+
+### Consistency Rule: one concept, one name
+
+- Avoid “ghost prior names” lingering in code/docs (e.g., `colligo` remnants inside `hop`).
+- Avoid having directory name, package name, and crate name drift.
+  - If we keep an old directory during migration, document it and fix it quickly.
+
+## 3. The Meta-ND Invariant (Multi-Dimensional Metadata)
+**Goal**: Unified handling of high-dimensional metadata and structures.
+*   **Dimensional Rigor**: Systems dealing with N-dimensional data (e.g., `subsume` boxes, `innr` vectors) must explicitly track and leverage metadata dimensions.
+*   **Subsumption Theory**: Use formal subsumption/entailment theory to manage metadata hierarchies across the stack.
+*   **Representation**: Metadata should be treated as a first-class N-dimensional object, not a flat bag of tags.
+
+## 4. Type Hierarchy & Invariants
+*   **Canonical Flows**: Signal (Detection) → Track (Coreference) → Identity (Linking).
+*   **Numerical Stability**: Use `NORM_EPSILON` ($10^{-9}$) for zero-norm handling.
+*   **Algebraic Closure**: Intersection operations (e.g. in L4) must return the same type.
+
+## 3. Engineering Rigor
+*   **Unicode**: ALWAYS use character offsets, NEVER byte offsets for text slicing.
+*   **SIMD**: Prefer `innr` for vector operations with automatic runtime dispatch.
+*   **Fast Math**: Use reciprocal square root ($rsqrt$) + Newton-Raphson for throughput.
+*   **Math**: Cite foundational papers (TAOCP style).
+
+## 4. Documentation vs. Process Logs
+*   **Chat for Process**: Do not write temporary markdown files for progress. Reply in chat.
+*   **Lecture Notes**: Review `docs/lectures/*.md` to pick up stack-wide habits.
+*   **Visual Rigor**: Visualizations must use real data from actual execution. fit distributions.
+
+## 4.5 Memory Recall Discipline (Cursor history is data)
+
+When intent or prior decisions matter (renames, merges, “publish vs private”, repo cleanup), **do not guess**.
+Treat prior chat + rule history as a dataset and re-derive intent from it.
+
+- **Preferred**: use `iksh` to inspect Cursor’s DB-backed chat history and rule memory:
+  - list conversation ids: `cargo run -p iksh -- chats --limit N`
+  - list with previews (recommended): `cargo run -p iksh -- chats --limit N --meta --format text --preview-chars 160`
+  - list as JSON (for tooling): `cargo run -p iksh -- chats --limit N --format json --preview-chars 160`
+  - reconstruct a conversation: `cargo run -p iksh -- convo <conversation-uuid>`
+  - search for keywords: `cargo run -p iksh -- db-search-values <needle> --limit N`
+- **Fallback**: consult the saved agent transcript file(s) when the DB doesn’t contain what we need.
+
+Goal: minimize “phantom intent” errors by making recall a first-class step.
+
+## 5. Repository & Tool Safety
+*   **Isolation**: Never create a new repo inside another repo.
+*   **Timeout Handling**: If a tool call fails/times out, narrow the scope. Do not repeat.
+*   **Local Resolution**: Use `[patch.crates-io]` in root for development speed.
+
+## 6. Git Discipline (Staging)
+
+Default to explicit staging (e.g. `git add <paths>`). Avoid `git add -A` unless the user explicitly requests “stage everything”.

rankops-0.1.20/.cursor/rules/tekne-module-taxonomy.mdc

@@ -0,0 +1,30 @@
+---
+title: "Tekne Module Taxonomy"
+id: tekne-module-taxonomy
+description: "Assessment of documentation quality and purpose by module"
+alwaysApply: false
+---
+
+# Tekne Module Taxonomy
+
+Assessment of documentation quality and pedagogical readiness across the stack.
+
+## Grade A: Pedagogical Gold Standard (TAOCP / Mackay Style)
+
+| Module | Lines | Additions |
+|:---|:---|:---|
+| `jin/hnsw` | ~210 | Mathematical invariant check, probability distribution |
+| `tier/kmeans` | ~110 | Hard vs soft, GMM math, linkage table |
+| `hyp` (lib.rs) | ~80 | **Model selection table**, when NOT to use |
+| `innr` (lib.rs) | ~60 | **Function selection table**, SIMD dispatch |
+
+## Verification Checklist
+
+For each module, verify:
+- [ ] Problem statement (what does this solve?)
+- [ ] Why this approach (what's the insight?)
+- [ ] Comparison to alternatives (when to use/not use)
+- [ ] Parameters with effects (not just names)
+- [ ] Complexity (time/space)
+- [ ] Working code example
+- [ ] References (papers, not just URLs)

rankops-0.1.20/.github/settings.yml

@@ -0,0 +1,21 @@
+# Managed by repository-settings/app
+# https://github.com/repository-settings/app
+
+repository:
+  description: "Operations on ranked lists: fusion (RRF, CombMNZ, Borda, DBSF), reranking (MaxSim/ColBERT, MMR, DPP, Matryoshka). Pairs with rankfns (scoring kernels)."
+  homepage: "https://docs.rs/rankops"
+  private: false
+  has_issues: true
+  has_wiki: false
+  has_downloads: true
+  default_branch: main
+  allow_squash_merge: true
+  allow_merge_commit: true
+  allow_rebase_merge: true
+  delete_branch_on_merge: true
+
+  topics:
+    - information-retrieval
+    - reranking
+    - rank-fusion
+    - rust

rankops-0.1.20/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: ci
+
+on:
+  push:
+    branches: ["main", "master"]
+  pull_request:
+
+permissions:
+  contents: read
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  rust:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+      - uses: Swatinem/rust-cache@v2
+
+      - name: fmt
+        run: cargo fmt --check
+
+      - name: clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+      - name: test
+        run: cargo test --all-targets --all-features
+
+      - name: build rankops-wasm (wasm32)
+        run: |
+          rustup target add wasm32-unknown-unknown
+          cargo build --manifest-path crates/rankops-wasm/Cargo.toml --target wasm32-unknown-unknown

rankops-0.1.20/.github/workflows/publish-pypi.yml

@@ -0,0 +1,101 @@
+name: publish-pypi
+
+on:
+  push:
+    tags:
+      - "python-v*"
+
+permissions:
+  contents: read
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          manylinux: auto
+          working-directory: rankops-python
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheel-linux-${{ matrix.target }}
+          path: rankops-python/dist/*.whl
+
+  macos:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}-apple-darwin
+          args: --release --out dist --find-interpreter
+          working-directory: rankops-python
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheel-macos-${{ matrix.target }}
+          path: rankops-python/dist/*.whl
+
+  windows:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          architecture: x64
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          args: --release --out dist --find-interpreter
+          working-directory: rankops-python
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheel-windows-x64
+          path: rankops-python/dist/*.whl
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+          working-directory: rankops-python
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: rankops-python/dist/*.tar.gz
+
+  publish:
+    needs: [linux, macos, windows, sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

rankops-0.1.20/.gitignore

@@ -0,0 +1,6 @@
+target/
+**/target/
+.DS_Store
+Cargo 2.toml
+rankops-python/Cargo.lock.fastembed_cache/
+.fastembed_cache/

rankops-0.1.20/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "rankops"
+version = "0.1.4"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+description = "Operations on ranked lists: fusion (RRF, Copeland, CombMNZ, DBSF, 14 methods), reranking (MaxSim/ColBERT, MMR, DPP), evaluation (NDCG, MAP, MRR), diagnostics, pipeline builder."
+repository = "https://github.com/arclabs561/rankops"
+readme = "README.md"
+keywords = ["rerank", "rrf", "retrieval", "rankops", "fusion"]
+categories = ["algorithms", "mathematics", "science"]
+
+[dependencies]
+serde = { version = "1.0", optional = true, features = ["derive"] }
+# SIMD primitives for reranking (MaxSim/ColBERT)
+innr = { version = "0.1.9", optional = true }
+# Hierarchical clustering for ColBERT (optional)
+kodama = { version = "0.3", optional = true }
+# Pareto frontier for multi-objective reranking (optional)
+pare = { version = "0.2.0", optional = true }
+
+[features]
+default = ["rerank"]
+serde = ["dep:serde"]
+# Reranking: MaxSim (ColBERT), diversity, matryoshka — requires innr for SIMD
+rerank = ["dep:innr"]
+# Alias so #[cfg(feature = "innr")] in rerank/simd.rs matches (rerank enables innr)
+innr = ["rerank"]
+# Hierarchical ColBERT; enables kodama for dendrogram clustering
+hierarchical = ["dep:kodama"]
+# Pareto frontier for multi-objective result selection
+pareto = ["dep:pare"]
+
+[dev-dependencies]
+criterion = { version = "0.7", features = ["html_reports"] }
+proptest = "1.9"
+
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]

rankops-0.1.20/LICENSE-APACHE

@@ -0,0 +1,85 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form.
+
+   "Work" shall mean the work of authorship made available under the License.
+
+   "Derivative Works" shall mean any work that is based on the Work.
+
+   "Contribution" shall mean any work of authorship submitted to the Licensor.
+
+   "Contributor" shall mean Licensor and any Legal Entity on behalf of whom
+   a Contribution has been received by Licensor.
+
+2. Grant of Copyright License. Subject to the terms of this License, each
+   Contributor grants to You a perpetual, worldwide, non-exclusive, no-charge,
+   royalty-free, irrevocable copyright license to reproduce, prepare Derivative
+   Works of, publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms of this License, each
+   Contributor grants to You a perpetual, worldwide, non-exclusive, no-charge,
+   royalty-free, irrevocable patent license to make, have made, use, offer to
+   sell, sell, import, and otherwise transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the Work
+   provided that You meet the following conditions:
+   (a) You must give recipients a copy of this License; and
+   (b) You must cause modified files to carry prominent notices; and
+   (c) You must retain all copyright, patent, trademark notices; and
+   (d) If the Work includes a "NOTICE" file, You must include a readable copy.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution submitted for inclusion in the Work shall be under the
+   terms of this License, without any additional terms or conditions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor.
+
+7. Disclaimer of Warranty. The Work is provided on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND.
+
+8. Limitation of Liability. In no event shall any Contributor be liable
+   to You for damages, including any direct, indirect, special, incidental,
+   or consequential damages.
+
+9. Accepting Warranty or Additional Liability. You may choose to offer
+   support, warranty, indemnity, or other liability obligations.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2024 arclabs561
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.