339 lines
11 KiB
Python
339 lines
11 KiB
Python
|
from __future__ import annotations
|
||
|
|
|
||
|
|
import json
|
||
|
|
import sqlite3
|
||
|
|
from pathlib import Path
|
||
|
|
from typing import Any
|
||
|
|
|
||
|
|
from repo_registry.core.models import (
|
||
|
|
Ability,
|
||
|
|
Capability,
|
||
|
|
Evidence,
|
||
|
|
Feature,
|
||
|
|
Repository,
|
||
|
|
RepositoryAbilityMap,
|
||
|
|
SearchResult,
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
class NotFoundError(ValueError):
|
||
|
|
pass
|
||
|
|
|
||
|
|
|
||
|
|
class RegistryStore:
|
||
|
|
def __init__(self, database_path: str | Path) -> None:
|
||
|
|
self.database_path = str(database_path)
|
||
|
|
|
||
|
|
def initialize(self) -> None:
|
||
|
|
migration_path = Path(__file__).parents[3] / "migrations" / "0001_initial.sql"
|
||
|
|
with self.connect() as connection:
|
||
|
|
connection.executescript(migration_path.read_text(encoding="utf-8"))
|
||
|
|
|
||
|
|
def connect(self) -> sqlite3.Connection:
|
||
|
|
connection = sqlite3.connect(self.database_path)
|
||
|
|
connection.row_factory = sqlite3.Row
|
||
|
|
connection.execute("PRAGMA foreign_keys = ON")
|
||
|
|
return connection
|
||
|
|
|
||
|
|
def create_repository(
|
||
|
|
self,
|
||
|
|
*,
|
||
|
|
name: str,
|
||
|
|
url: str,
|
||
|
|
description: str | None,
|
||
|
|
branch: str,
|
||
|
|
) -> Repository:
|
||
|
|
with self.connect() as connection:
|
||
|
|
cursor = connection.execute(
|
||
|
|
"""
|
||
|
|
INSERT INTO repositories (name, url, description, branch)
|
||
|
|
VALUES (?, ?, ?, ?)
|
||
|
|
""",
|
||
|
|
(name, url, description, branch),
|
||
|
|
)
|
||
|
|
repository_id = int(cursor.lastrowid)
|
||
|
|
return self.get_repository(repository_id)
|
||
|
|
|
||
|
|
def list_repositories(self) -> list[Repository]:
|
||
|
|
with self.connect() as connection:
|
||
|
|
rows = connection.execute(
|
||
|
|
"""
|
||
|
|
SELECT id, name, url, description, branch, status
|
||
|
|
FROM repositories
|
||
|
|
ORDER BY created_at DESC, id DESC
|
||
|
|
"""
|
||
|
|
).fetchall()
|
||
|
|
return [self._repository_from_row(row) for row in rows]
|
||
|
|
|
||
|
|
def get_repository(self, repository_id: int) -> Repository:
|
||
|
|
with self.connect() as connection:
|
||
|
|
row = connection.execute(
|
||
|
|
"""
|
||
|
|
SELECT id, name, url, description, branch, status
|
||
|
|
FROM repositories
|
||
|
|
WHERE id = ?
|
||
|
|
""",
|
||
|
|
(repository_id,),
|
||
|
|
).fetchone()
|
||
|
|
if row is None:
|
||
|
|
raise NotFoundError(f"repository {repository_id} was not found")
|
||
|
|
return self._repository_from_row(row)
|
||
|
|
|
||
|
|
def create_ability(
|
||
|
|
self,
|
||
|
|
repository_id: int,
|
||
|
|
*,
|
||
|
|
name: str,
|
||
|
|
description: str,
|
||
|
|
confidence: float,
|
||
|
|
) -> int:
|
||
|
|
with self.connect() as connection:
|
||
|
|
cursor = connection.execute(
|
||
|
|
"""
|
||
|
|
INSERT INTO approved_abilities
|
||
|
|
(repository_id, name, description, confidence)
|
||
|
|
VALUES (?, ?, ?, ?)
|
||
|
|
""",
|
||
|
|
(repository_id, name, description, confidence),
|
||
|
|
)
|
||
|
|
return int(cursor.lastrowid)
|
||
|
|
|
||
|
|
def ensure_ability(self, repository_id: int, ability_id: int) -> None:
|
||
|
|
with self.connect() as connection:
|
||
|
|
row = connection.execute(
|
||
|
|
"""
|
||
|
|
SELECT id FROM approved_abilities
|
||
|
|
WHERE id = ? AND repository_id = ?
|
||
|
|
""",
|
||
|
|
(ability_id, repository_id),
|
||
|
|
).fetchone()
|
||
|
|
if row is None:
|
||
|
|
raise NotFoundError(
|
||
|
|
f"ability {ability_id} was not found for repository {repository_id}"
|
||
|
|
)
|
||
|
|
|
||
|
|
def create_capability(
|
||
|
|
self,
|
||
|
|
repository_id: int,
|
||
|
|
ability_id: int,
|
||
|
|
*,
|
||
|
|
name: str,
|
||
|
|
description: str,
|
||
|
|
inputs: list[str],
|
||
|
|
outputs: list[str],
|
||
|
|
confidence: float,
|
||
|
|
) -> int:
|
||
|
|
with self.connect() as connection:
|
||
|
|
cursor = connection.execute(
|
||
|
|
"""
|
||
|
|
INSERT INTO approved_capabilities
|
||
|
|
(repository_id, ability_id, name, description, inputs, outputs, confidence)
|
||
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
||
|
|
""",
|
||
|
|
(
|
||
|
|
repository_id,
|
||
|
|
ability_id,
|
||
|
|
name,
|
||
|
|
description,
|
||
|
|
json.dumps(inputs),
|
||
|
|
json.dumps(outputs),
|
||
|
|
confidence,
|
||
|
|
),
|
||
|
|
)
|
||
|
|
return int(cursor.lastrowid)
|
||
|
|
|
||
|
|
def ensure_capability(self, repository_id: int, capability_id: int) -> None:
|
||
|
|
with self.connect() as connection:
|
||
|
|
row = connection.execute(
|
||
|
|
"""
|
||
|
|
SELECT id FROM approved_capabilities
|
||
|
|
WHERE id = ? AND repository_id = ?
|
||
|
|
""",
|
||
|
|
(capability_id, repository_id),
|
||
|
|
).fetchone()
|
||
|
|
if row is None:
|
||
|
|
raise NotFoundError(
|
||
|
|
f"capability {capability_id} was not found for repository {repository_id}"
|
||
|
|
)
|
||
|
|
|
||
|
|
def create_feature(
|
||
|
|
self,
|
||
|
|
repository_id: int,
|
||
|
|
capability_id: int,
|
||
|
|
*,
|
||
|
|
name: str,
|
||
|
|
type: str,
|
||
|
|
location: str,
|
||
|
|
confidence: float,
|
||
|
|
) -> int:
|
||
|
|
with self.connect() as connection:
|
||
|
|
cursor = connection.execute(
|
||
|
|
"""
|
||
|
|
INSERT INTO approved_features
|
||
|
|
(repository_id, capability_id, name, type, location, confidence)
|
||
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
||
|
|
""",
|
||
|
|
(repository_id, capability_id, name, type, location, confidence),
|
||
|
|
)
|
||
|
|
return int(cursor.lastrowid)
|
||
|
|
|
||
|
|
def create_evidence(
|
||
|
|
self,
|
||
|
|
repository_id: int,
|
||
|
|
capability_id: int,
|
||
|
|
*,
|
||
|
|
type: str,
|
||
|
|
reference: str,
|
||
|
|
strength: str,
|
||
|
|
) -> int:
|
||
|
|
with self.connect() as connection:
|
||
|
|
cursor = connection.execute(
|
||
|
|
"""
|
||
|
|
INSERT INTO approved_evidence
|
||
|
|
(repository_id, capability_id, type, reference, strength)
|
||
|
|
VALUES (?, ?, ?, ?, ?)
|
||
|
|
""",
|
||
|
|
(repository_id, capability_id, type, reference, strength),
|
||
|
|
)
|
||
|
|
return int(cursor.lastrowid)
|
||
|
|
|
||
|
|
def get_ability_map(self, repository_id: int) -> RepositoryAbilityMap:
|
||
|
|
repository = self.get_repository(repository_id)
|
||
|
|
with self.connect() as connection:
|
||
|
|
ability_rows = connection.execute(
|
||
|
|
"""
|
||
|
|
SELECT id, name, description, confidence
|
||
|
|
FROM approved_abilities
|
||
|
|
WHERE repository_id = ?
|
||
|
|
ORDER BY id
|
||
|
|
""",
|
||
|
|
(repository_id,),
|
||
|
|
).fetchall()
|
||
|
|
capability_rows = connection.execute(
|
||
|
|
"""
|
||
|
|
SELECT id, ability_id, name, description, inputs, outputs, confidence
|
||
|
|
FROM approved_capabilities
|
||
|
|
WHERE repository_id = ?
|
||
|
|
ORDER BY id
|
||
|
|
""",
|
||
|
|
(repository_id,),
|
||
|
|
).fetchall()
|
||
|
|
feature_rows = connection.execute(
|
||
|
|
"""
|
||
|
|
SELECT id, capability_id, name, type, location, confidence
|
||
|
|
FROM approved_features
|
||
|
|
WHERE repository_id = ?
|
||
|
|
ORDER BY id
|
||
|
|
""",
|
||
|
|
(repository_id,),
|
||
|
|
).fetchall()
|
||
|
|
evidence_rows = connection.execute(
|
||
|
|
"""
|
||
|
|
SELECT id, capability_id, type, reference, strength
|
||
|
|
FROM approved_evidence
|
||
|
|
WHERE repository_id = ?
|
||
|
|
ORDER BY id
|
||
|
|
""",
|
||
|
|
(repository_id,),
|
||
|
|
).fetchall()
|
||
|
|
|
||
|
|
features_by_capability: dict[int, list[Feature]] = {}
|
||
|
|
for row in feature_rows:
|
||
|
|
features_by_capability.setdefault(row["capability_id"], []).append(
|
||
|
|
Feature(
|
||
|
|
id=row["id"],
|
||
|
|
name=row["name"],
|
||
|
|
type=row["type"],
|
||
|
|
location=row["location"],
|
||
|
|
confidence=row["confidence"],
|
||
|
|
)
|
||
|
|
)
|
||
|
|
|
||
|
|
evidence_by_capability: dict[int, list[Evidence]] = {}
|
||
|
|
for row in evidence_rows:
|
||
|
|
evidence_by_capability.setdefault(row["capability_id"], []).append(
|
||
|
|
Evidence(
|
||
|
|
id=row["id"],
|
||
|
|
type=row["type"],
|
||
|
|
reference=row["reference"],
|
||
|
|
strength=row["strength"],
|
||
|
|
)
|
||
|
|
)
|
||
|
|
|
||
|
|
capabilities_by_ability: dict[int, list[Capability]] = {}
|
||
|
|
for row in capability_rows:
|
||
|
|
capabilities_by_ability.setdefault(row["ability_id"], []).append(
|
||
|
|
Capability(
|
||
|
|
id=row["id"],
|
||
|
|
name=row["name"],
|
||
|
|
description=row["description"],
|
||
|
|
inputs=json.loads(row["inputs"]),
|
||
|
|
outputs=json.loads(row["outputs"]),
|
||
|
|
confidence=row["confidence"],
|
||
|
|
features=features_by_capability.get(row["id"], []),
|
||
|
|
evidence=evidence_by_capability.get(row["id"], []),
|
||
|
|
)
|
||
|
|
)
|
||
|
|
|
||
|
|
abilities = [
|
||
|
|
Ability(
|
||
|
|
id=row["id"],
|
||
|
|
name=row["name"],
|
||
|
|
description=row["description"],
|
||
|
|
confidence=row["confidence"],
|
||
|
|
capabilities=capabilities_by_ability.get(row["id"], []),
|
||
|
|
)
|
||
|
|
for row in ability_rows
|
||
|
|
]
|
||
|
|
return RepositoryAbilityMap(repository=repository, abilities=abilities)
|
||
|
|
|
||
|
|
def search(self, query: str) -> list[SearchResult]:
|
||
|
|
needle = f"%{query.strip()}%"
|
||
|
|
if needle == "%%":
|
||
|
|
return []
|
||
|
|
|
||
|
|
with self.connect() as connection:
|
||
|
|
rows = connection.execute(
|
||
|
|
"""
|
||
|
|
SELECT r.id AS repository_id, r.name AS repository_name,
|
||
|
|
'repository' AS match_type, r.name AS match_name,
|
||
|
|
1.0 AS confidence
|
||
|
|
FROM repositories r
|
||
|
|
WHERE r.name LIKE ? OR COALESCE(r.description, '') LIKE ?
|
||
|
|
UNION ALL
|
||
|
|
SELECT r.id, r.name, 'ability', a.name, a.confidence
|
||
|
|
FROM approved_abilities a
|
||
|
|
JOIN repositories r ON r.id = a.repository_id
|
||
|
|
WHERE a.name LIKE ? OR a.description LIKE ?
|
||
|
|
UNION ALL
|
||
|
|
SELECT r.id, r.name, 'capability', c.name, c.confidence
|
||
|
|
FROM approved_capabilities c
|
||
|
|
JOIN repositories r ON r.id = c.repository_id
|
||
|
|
WHERE c.name LIKE ? OR c.description LIKE ?
|
||
|
|
ORDER BY confidence DESC, repository_name ASC, match_name ASC
|
||
|
|
""",
|
||
|
|
(needle, needle, needle, needle, needle, needle),
|
||
|
|
).fetchall()
|
||
|
|
|
||
|
|
return [
|
||
|
|
SearchResult(
|
||
|
|
repository_id=row["repository_id"],
|
||
|
|
repository_name=row["repository_name"],
|
||
|
|
match_type=row["match_type"],
|
||
|
|
match_name=row["match_name"],
|
||
|
|
confidence=row["confidence"],
|
||
|
|
)
|
||
|
|
for row in rows
|
||
|
|
]
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _repository_from_row(row: sqlite3.Row) -> Repository:
|
||
|
|
return Repository(
|
||
|
|
id=row["id"],
|
||
|
|
name=row["name"],
|
||
|
|
url=row["url"],
|
||
|
|
description=row["description"],
|
||
|
|
branch=row["branch"],
|
||
|
|
status=row["status"],
|
||
|
|
)
|