Rename terminology to industry standard terms

- Grove → Project
- Tree → Package
- Fruit → Artifact
- Graft → Tag
- Cultivate → Upload
- Harvest → Download

Updated across:
- Backend models, schemas, and routes
- Frontend types, API client, and components
- README documentation
- API endpoints now use /project/:project/packages pattern

backend/app/models.py

@@ -11,8 +11,8 @@ import uuid
 Base = declarative_base()
 
 
-class Grove(Base):
-    __tablename__ = "groves"
+class Project(Base):
+    __tablename__ = "projects"
 
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     name = Column(String(255), unique=True, nullable=False)
@@ -22,39 +22,39 @@ class Grove(Base):
     updated_at = Column(DateTime(timezone=True), default=datetime.utcnow, onupdate=datetime.utcnow)
     created_by = Column(String(255), nullable=False)
 
-    trees = relationship("Tree", back_populates="grove", cascade="all, delete-orphan")
-    permissions = relationship("AccessPermission", back_populates="grove", cascade="all, delete-orphan")
+    packages = relationship("Package", back_populates="project", cascade="all, delete-orphan")
+    permissions = relationship("AccessPermission", back_populates="project", cascade="all, delete-orphan")
 
     __table_args__ = (
-        Index("idx_groves_name", "name"),
-        Index("idx_groves_created_by", "created_by"),
+        Index("idx_projects_name", "name"),
+        Index("idx_projects_created_by", "created_by"),
     )
 
 
-class Tree(Base):
-    __tablename__ = "trees"
+class Package(Base):
+    __tablename__ = "packages"
 
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    grove_id = Column(UUID(as_uuid=True), ForeignKey("groves.id", ondelete="CASCADE"), nullable=False)
+    project_id = Column(UUID(as_uuid=True), ForeignKey("projects.id", ondelete="CASCADE"), nullable=False)
     name = Column(String(255), nullable=False)
     description = Column(Text)
     created_at = Column(DateTime(timezone=True), default=datetime.utcnow)
     updated_at = Column(DateTime(timezone=True), default=datetime.utcnow, onupdate=datetime.utcnow)
 
-    grove = relationship("Grove", back_populates="trees")
-    grafts = relationship("Graft", back_populates="tree", cascade="all, delete-orphan")
-    harvests = relationship("Harvest", back_populates="tree", cascade="all, delete-orphan")
-    consumers = relationship("Consumer", back_populates="tree", cascade="all, delete-orphan")
+    project = relationship("Project", back_populates="packages")
+    tags = relationship("Tag", back_populates="package", cascade="all, delete-orphan")
+    uploads = relationship("Upload", back_populates="package", cascade="all, delete-orphan")
+    consumers = relationship("Consumer", back_populates="package", cascade="all, delete-orphan")
 
     __table_args__ = (
-        Index("idx_trees_grove_id", "grove_id"),
-        Index("idx_trees_name", "name"),
+        Index("idx_packages_project_id", "project_id"),
+        Index("idx_packages_name", "name"),
         {"extend_existing": True},
     )
 
 
-class Fruit(Base):
-    __tablename__ = "fruits"
+class Artifact(Base):
+    __tablename__ = "artifacts"
 
     id = Column(String(64), primary_key=True)  # SHA256 hash
     size = Column(BigInteger, nullable=False)
@@ -65,70 +65,70 @@ class Fruit(Base):
     ref_count = Column(Integer, default=1)
     s3_key = Column(String(1024), nullable=False)
 
-    grafts = relationship("Graft", back_populates="fruit")
-    harvests = relationship("Harvest", back_populates="fruit")
+    tags = relationship("Tag", back_populates="artifact")
+    uploads = relationship("Upload", back_populates="artifact")
 
     __table_args__ = (
-        Index("idx_fruits_created_at", "created_at"),
-        Index("idx_fruits_created_by", "created_by"),
+        Index("idx_artifacts_created_at", "created_at"),
+        Index("idx_artifacts_created_by", "created_by"),
     )
 
 
-class Graft(Base):
-    __tablename__ = "grafts"
+class Tag(Base):
+    __tablename__ = "tags"
 
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    tree_id = Column(UUID(as_uuid=True), ForeignKey("trees.id", ondelete="CASCADE"), nullable=False)
+    package_id = Column(UUID(as_uuid=True), ForeignKey("packages.id", ondelete="CASCADE"), nullable=False)
     name = Column(String(255), nullable=False)
-    fruit_id = Column(String(64), ForeignKey("fruits.id"), nullable=False)
+    artifact_id = Column(String(64), ForeignKey("artifacts.id"), nullable=False)
     created_at = Column(DateTime(timezone=True), default=datetime.utcnow)
     created_by = Column(String(255), nullable=False)
 
-    tree = relationship("Tree", back_populates="grafts")
-    fruit = relationship("Fruit", back_populates="grafts")
-    history = relationship("GraftHistory", back_populates="graft", cascade="all, delete-orphan")
+    package = relationship("Package", back_populates="tags")
+    artifact = relationship("Artifact", back_populates="tags")
+    history = relationship("TagHistory", back_populates="tag", cascade="all, delete-orphan")
 
     __table_args__ = (
-        Index("idx_grafts_tree_id", "tree_id"),
-        Index("idx_grafts_fruit_id", "fruit_id"),
+        Index("idx_tags_package_id", "package_id"),
+        Index("idx_tags_artifact_id", "artifact_id"),
     )
 
 
-class GraftHistory(Base):
-    __tablename__ = "graft_history"
+class TagHistory(Base):
+    __tablename__ = "tag_history"
 
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    graft_id = Column(UUID(as_uuid=True), ForeignKey("grafts.id", ondelete="CASCADE"), nullable=False)
-    old_fruit_id = Column(String(64), ForeignKey("fruits.id"))
-    new_fruit_id = Column(String(64), ForeignKey("fruits.id"), nullable=False)
+    tag_id = Column(UUID(as_uuid=True), ForeignKey("tags.id", ondelete="CASCADE"), nullable=False)
+    old_artifact_id = Column(String(64), ForeignKey("artifacts.id"))
+    new_artifact_id = Column(String(64), ForeignKey("artifacts.id"), nullable=False)
     changed_at = Column(DateTime(timezone=True), default=datetime.utcnow)
     changed_by = Column(String(255), nullable=False)
 
-    graft = relationship("Graft", back_populates="history")
+    tag = relationship("Tag", back_populates="history")
 
     __table_args__ = (
-        Index("idx_graft_history_graft_id", "graft_id"),
+        Index("idx_tag_history_tag_id", "tag_id"),
     )
 
 
-class Harvest(Base):
-    __tablename__ = "harvests"
+class Upload(Base):
+    __tablename__ = "uploads"
 
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    fruit_id = Column(String(64), ForeignKey("fruits.id"), nullable=False)
-    tree_id = Column(UUID(as_uuid=True), ForeignKey("trees.id"), nullable=False)
+    artifact_id = Column(String(64), ForeignKey("artifacts.id"), nullable=False)
+    package_id = Column(UUID(as_uuid=True), ForeignKey("packages.id"), nullable=False)
     original_name = Column(String(1024))
-    harvested_at = Column(DateTime(timezone=True), default=datetime.utcnow)
-    harvested_by = Column(String(255), nullable=False)
+    uploaded_at = Column(DateTime(timezone=True), default=datetime.utcnow)
+    uploaded_by = Column(String(255), nullable=False)
     source_ip = Column(String(45))
 
-    fruit = relationship("Fruit", back_populates="harvests")
-    tree = relationship("Tree", back_populates="harvests")
+    artifact = relationship("Artifact", back_populates="uploads")
+    package = relationship("Package", back_populates="uploads")
 
     __table_args__ = (
-        Index("idx_harvests_fruit_id", "fruit_id"),
-        Index("idx_harvests_tree_id", "tree_id"),
-        Index("idx_harvests_harvested_at", "harvested_at"),
+        Index("idx_uploads_artifact_id", "artifact_id"),
+        Index("idx_uploads_package_id", "package_id"),
+        Index("idx_uploads_uploaded_at", "uploaded_at"),
     )
 
 
@@ -136,15 +136,15 @@ class Consumer(Base):
     __tablename__ = "consumers"
 
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    tree_id = Column(UUID(as_uuid=True), ForeignKey("trees.id", ondelete="CASCADE"), nullable=False)
+    package_id = Column(UUID(as_uuid=True), ForeignKey("packages.id", ondelete="CASCADE"), nullable=False)
     project_url = Column(String(2048), nullable=False)
     last_access = Column(DateTime(timezone=True), default=datetime.utcnow)
     created_at = Column(DateTime(timezone=True), default=datetime.utcnow)
 
-    tree = relationship("Tree", back_populates="consumers")
+    package = relationship("Package", back_populates="consumers")
 
     __table_args__ = (
-        Index("idx_consumers_tree_id", "tree_id"),
+        Index("idx_consumers_package_id", "package_id"),
         Index("idx_consumers_last_access", "last_access"),
     )
 
@@ -153,17 +153,17 @@ class AccessPermission(Base):
     __tablename__ = "access_permissions"
 
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    grove_id = Column(UUID(as_uuid=True), ForeignKey("groves.id", ondelete="CASCADE"), nullable=False)
+    project_id = Column(UUID(as_uuid=True), ForeignKey("projects.id", ondelete="CASCADE"), nullable=False)
     user_id = Column(String(255), nullable=False)
     level = Column(String(20), nullable=False)
     created_at = Column(DateTime(timezone=True), default=datetime.utcnow)
     expires_at = Column(DateTime(timezone=True))
 
-    grove = relationship("Grove", back_populates="permissions")
+    project = relationship("Project", back_populates="permissions")
 
     __table_args__ = (
         CheckConstraint("level IN ('read', 'write', 'admin')", name="check_level"),
-        Index("idx_access_permissions_grove_id", "grove_id"),
+        Index("idx_access_permissions_project_id", "project_id"),
         Index("idx_access_permissions_user_id", "user_id"),
     )
 

backend/app/routes.py

@@ -7,13 +7,13 @@ import re
 
 from .database import get_db
 from .storage import get_storage, S3Storage
-from .models import Grove, Tree, Fruit, Graft, Harvest, Consumer
+from .models import Project, Package, Artifact, Tag, Upload, Consumer
 from .schemas import (
-    GroveCreate, GroveResponse,
-    TreeCreate, TreeResponse,
-    FruitResponse,
-    GraftCreate, GraftResponse,
-    CultivateResponse,
+    ProjectCreate, ProjectResponse,
+    PackageCreate, PackageResponse,
+    ArtifactResponse,
+    TagCreate, TagResponse,
+    UploadResponse,
     ConsumerResponse,
     HealthResponse,
 )
@@ -38,81 +38,81 @@ def health_check():
     return HealthResponse(status="ok")
 
 
-# Grove routes
-@router.get("/api/v1/groves", response_model=List[GroveResponse])
-def list_groves(request: Request, db: Session = Depends(get_db)):
+# Project routes
+@router.get("/api/v1/projects", response_model=List[ProjectResponse])
+def list_projects(request: Request, db: Session = Depends(get_db)):
     user_id = get_user_id(request)
-    groves = db.query(Grove).filter(
-        or_(Grove.is_public == True, Grove.created_by == user_id)
-    ).order_by(Grove.name).all()
-    return groves
+    projects = db.query(Project).filter(
+        or_(Project.is_public == True, Project.created_by == user_id)
+    ).order_by(Project.name).all()
+    return projects
 
 
-@router.post("/api/v1/groves", response_model=GroveResponse)
-def create_grove(grove: GroveCreate, request: Request, db: Session = Depends(get_db)):
+@router.post("/api/v1/projects", response_model=ProjectResponse)
+def create_project(project: ProjectCreate, request: Request, db: Session = Depends(get_db)):
     user_id = get_user_id(request)
 
-    existing = db.query(Grove).filter(Grove.name == grove.name).first()
+    existing = db.query(Project).filter(Project.name == project.name).first()
     if existing:
-        raise HTTPException(status_code=400, detail="Grove already exists")
+        raise HTTPException(status_code=400, detail="Project already exists")
 
-    db_grove = Grove(
-        name=grove.name,
-        description=grove.description,
-        is_public=grove.is_public,
+    db_project = Project(
+        name=project.name,
+        description=project.description,
+        is_public=project.is_public,
         created_by=user_id,
     )
-    db.add(db_grove)
+    db.add(db_project)
     db.commit()
-    db.refresh(db_grove)
-    return db_grove
+    db.refresh(db_project)
+    return db_project
 
 
-@router.get("/api/v1/groves/{grove_name}", response_model=GroveResponse)
-def get_grove(grove_name: str, db: Session = Depends(get_db)):
-    grove = db.query(Grove).filter(Grove.name == grove_name).first()
-    if not grove:
-        raise HTTPException(status_code=404, detail="Grove not found")
-    return grove
+@router.get("/api/v1/projects/{project_name}", response_model=ProjectResponse)
+def get_project(project_name: str, db: Session = Depends(get_db)):
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+    return project
 
 
-# Tree routes
-@router.get("/api/v1/grove/{grove_name}/trees", response_model=List[TreeResponse])
-def list_trees(grove_name: str, db: Session = Depends(get_db)):
-    grove = db.query(Grove).filter(Grove.name == grove_name).first()
-    if not grove:
-        raise HTTPException(status_code=404, detail="Grove not found")
+# Package routes
+@router.get("/api/v1/project/{project_name}/packages", response_model=List[PackageResponse])
+def list_packages(project_name: str, db: Session = Depends(get_db)):
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
 
-    trees = db.query(Tree).filter(Tree.grove_id == grove.id).order_by(Tree.name).all()
-    return trees
+    packages = db.query(Package).filter(Package.project_id == project.id).order_by(Package.name).all()
+    return packages
 
 
-@router.post("/api/v1/grove/{grove_name}/trees", response_model=TreeResponse)
-def create_tree(grove_name: str, tree: TreeCreate, db: Session = Depends(get_db)):
-    grove = db.query(Grove).filter(Grove.name == grove_name).first()
-    if not grove:
-        raise HTTPException(status_code=404, detail="Grove not found")
+@router.post("/api/v1/project/{project_name}/packages", response_model=PackageResponse)
+def create_package(project_name: str, package: PackageCreate, db: Session = Depends(get_db)):
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
 
-    existing = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree.name).first()
+    existing = db.query(Package).filter(Package.project_id == project.id, Package.name == package.name).first()
     if existing:
-        raise HTTPException(status_code=400, detail="Tree already exists in this grove")
+        raise HTTPException(status_code=400, detail="Package already exists in this project")
 
-    db_tree = Tree(
-        grove_id=grove.id,
-        name=tree.name,
-        description=tree.description,
+    db_package = Package(
+        project_id=project.id,
+        name=package.name,
+        description=package.description,
     )
-    db.add(db_tree)
+    db.add(db_package)
     db.commit()
-    db.refresh(db_tree)
-    return db_tree
+    db.refresh(db_package)
+    return db_package
 
 
-# Cultivate (upload)
-@router.post("/api/v1/grove/{grove_name}/{tree_name}/cultivate", response_model=CultivateResponse)
-def cultivate(
-    grove_name: str,
-    tree_name: str,
+# Upload artifact
+@router.post("/api/v1/project/{project_name}/{package_name}/upload", response_model=UploadResponse)
+def upload_artifact(
+    project_name: str,
+    package_name: str,
     request: Request,
     file: UploadFile = File(...),
     tag: Optional[str] = Form(None),
@@ -121,24 +121,24 @@ def cultivate(
 ):
     user_id = get_user_id(request)
 
-    # Get grove and tree
-    grove = db.query(Grove).filter(Grove.name == grove_name).first()
-    if not grove:
-        raise HTTPException(status_code=404, detail="Grove not found")
+    # Get project and package
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
 
-    tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
-    if not tree:
-        raise HTTPException(status_code=404, detail="Tree not found")
+    package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
+    if not package:
+        raise HTTPException(status_code=404, detail="Package not found")
 
     # Store file
     sha256_hash, size, s3_key = storage.store(file.file)
 
-    # Create or update fruit record
-    fruit = db.query(Fruit).filter(Fruit.id == sha256_hash).first()
-    if fruit:
-        fruit.ref_count += 1
+    # Create or update artifact record
+    artifact = db.query(Artifact).filter(Artifact.id == sha256_hash).first()
+    if artifact:
+        artifact.ref_count += 1
     else:
-        fruit = Fruit(
+        artifact = Artifact(
             id=sha256_hash,
             size=size,
             content_type=file.content_type,
@@ -146,188 +146,188 @@ def cultivate(
             created_by=user_id,
             s3_key=s3_key,
         )
-        db.add(fruit)
+        db.add(artifact)
 
-    # Record harvest
-    harvest = Harvest(
-        fruit_id=sha256_hash,
-        tree_id=tree.id,
+    # Record upload
+    upload = Upload(
+        artifact_id=sha256_hash,
+        package_id=package.id,
         original_name=file.filename,
-        harvested_by=user_id,
+        uploaded_by=user_id,
         source_ip=request.client.host if request.client else None,
     )
-    db.add(harvest)
+    db.add(upload)
 
     # Create tag if provided
     if tag:
-        existing_graft = db.query(Graft).filter(Graft.tree_id == tree.id, Graft.name == tag).first()
-        if existing_graft:
-            existing_graft.fruit_id = sha256_hash
-            existing_graft.created_by = user_id
+        existing_tag = db.query(Tag).filter(Tag.package_id == package.id, Tag.name == tag).first()
+        if existing_tag:
+            existing_tag.artifact_id = sha256_hash
+            existing_tag.created_by = user_id
         else:
-            graft = Graft(
-                tree_id=tree.id,
+            new_tag = Tag(
+                package_id=package.id,
                 name=tag,
-                fruit_id=sha256_hash,
+                artifact_id=sha256_hash,
                 created_by=user_id,
             )
-            db.add(graft)
+            db.add(new_tag)
 
     db.commit()
 
-    return CultivateResponse(
-        fruit_id=sha256_hash,
+    return UploadResponse(
+        artifact_id=sha256_hash,
         size=size,
-        grove=grove_name,
-        tree=tree_name,
+        project=project_name,
+        package=package_name,
         tag=tag,
     )
 
 
-# Harvest (download)
-@router.get("/api/v1/grove/{grove_name}/{tree_name}/+/{ref}")
-def harvest(
-    grove_name: str,
-    tree_name: str,
+# Download artifact
+@router.get("/api/v1/project/{project_name}/{package_name}/+/{ref}")
+def download_artifact(
+    project_name: str,
+    package_name: str,
     ref: str,
     db: Session = Depends(get_db),
     storage: S3Storage = Depends(get_storage),
 ):
-    # Get grove and tree
-    grove = db.query(Grove).filter(Grove.name == grove_name).first()
-    if not grove:
-        raise HTTPException(status_code=404, detail="Grove not found")
+    # Get project and package
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
 
-    tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
-    if not tree:
-        raise HTTPException(status_code=404, detail="Tree not found")
+    package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
+    if not package:
+        raise HTTPException(status_code=404, detail="Package not found")
 
-    # Resolve reference to fruit
-    fruit = None
+    # Resolve reference to artifact
+    artifact = None
 
     # Check for explicit prefixes
-    if ref.startswith("fruit:"):
-        fruit_id = ref[6:]
-        fruit = db.query(Fruit).filter(Fruit.id == fruit_id).first()
+    if ref.startswith("artifact:"):
+        artifact_id = ref[9:]
+        artifact = db.query(Artifact).filter(Artifact.id == artifact_id).first()
     elif ref.startswith("tag:") or ref.startswith("version:"):
         tag_name = ref.split(":", 1)[1]
-        graft = db.query(Graft).filter(Graft.tree_id == tree.id, Graft.name == tag_name).first()
-        if graft:
-            fruit = db.query(Fruit).filter(Fruit.id == graft.fruit_id).first()
+        tag = db.query(Tag).filter(Tag.package_id == package.id, Tag.name == tag_name).first()
+        if tag:
+            artifact = db.query(Artifact).filter(Artifact.id == tag.artifact_id).first()
     else:
         # Try as tag name first
-        graft = db.query(Graft).filter(Graft.tree_id == tree.id, Graft.name == ref).first()
-        if graft:
-            fruit = db.query(Fruit).filter(Fruit.id == graft.fruit_id).first()
+        tag = db.query(Tag).filter(Tag.package_id == package.id, Tag.name == ref).first()
+        if tag:
+            artifact = db.query(Artifact).filter(Artifact.id == tag.artifact_id).first()
         else:
-            # Try as direct fruit ID
-            fruit = db.query(Fruit).filter(Fruit.id == ref).first()
+            # Try as direct artifact ID
+            artifact = db.query(Artifact).filter(Artifact.id == ref).first()
 
-    if not fruit:
+    if not artifact:
         raise HTTPException(status_code=404, detail="Artifact not found")
 
     # Stream from S3
-    stream = storage.get_stream(fruit.s3_key)
+    stream = storage.get_stream(artifact.s3_key)
 
-    filename = fruit.original_name or f"{fruit.id}"
+    filename = artifact.original_name or f"{artifact.id}"
 
     return StreamingResponse(
         stream,
-        media_type=fruit.content_type or "application/octet-stream",
+        media_type=artifact.content_type or "application/octet-stream",
         headers={"Content-Disposition": f'attachment; filename="{filename}"'},
     )
 
 
 # Compatibility route
-@router.get("/grove/{grove_name}/{tree_name}/+/{ref}")
-def harvest_compat(
-    grove_name: str,
-    tree_name: str,
+@router.get("/project/{project_name}/{package_name}/+/{ref}")
+def download_artifact_compat(
+    project_name: str,
+    package_name: str,
     ref: str,
     db: Session = Depends(get_db),
     storage: S3Storage = Depends(get_storage),
 ):
-    return harvest(grove_name, tree_name, ref, db, storage)
+    return download_artifact(project_name, package_name, ref, db, storage)
 
 
-# Graft routes
-@router.get("/api/v1/grove/{grove_name}/{tree_name}/grafts", response_model=List[GraftResponse])
-def list_grafts(grove_name: str, tree_name: str, db: Session = Depends(get_db)):
-    grove = db.query(Grove).filter(Grove.name == grove_name).first()
-    if not grove:
-        raise HTTPException(status_code=404, detail="Grove not found")
+# Tag routes
+@router.get("/api/v1/project/{project_name}/{package_name}/tags", response_model=List[TagResponse])
+def list_tags(project_name: str, package_name: str, db: Session = Depends(get_db)):
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
 
-    tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
-    if not tree:
-        raise HTTPException(status_code=404, detail="Tree not found")
+    package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
+    if not package:
+        raise HTTPException(status_code=404, detail="Package not found")
 
-    grafts = db.query(Graft).filter(Graft.tree_id == tree.id).order_by(Graft.name).all()
-    return grafts
+    tags = db.query(Tag).filter(Tag.package_id == package.id).order_by(Tag.name).all()
+    return tags
 
 
-@router.post("/api/v1/grove/{grove_name}/{tree_name}/graft", response_model=GraftResponse)
-def create_graft(
-    grove_name: str,
-    tree_name: str,
-    graft: GraftCreate,
+@router.post("/api/v1/project/{project_name}/{package_name}/tags", response_model=TagResponse)
+def create_tag(
+    project_name: str,
+    package_name: str,
+    tag: TagCreate,
     request: Request,
     db: Session = Depends(get_db),
 ):
     user_id = get_user_id(request)
 
-    grove = db.query(Grove).filter(Grove.name == grove_name).first()
-    if not grove:
-        raise HTTPException(status_code=404, detail="Grove not found")
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
 
-    tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
-    if not tree:
-        raise HTTPException(status_code=404, detail="Tree not found")
+    package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
+    if not package:
+        raise HTTPException(status_code=404, detail="Package not found")
 
-    # Verify fruit exists
-    fruit = db.query(Fruit).filter(Fruit.id == graft.fruit_id).first()
-    if not fruit:
-        raise HTTPException(status_code=404, detail="Fruit not found")
+    # Verify artifact exists
+    artifact = db.query(Artifact).filter(Artifact.id == tag.artifact_id).first()
+    if not artifact:
+        raise HTTPException(status_code=404, detail="Artifact not found")
 
-    # Create or update graft
-    existing = db.query(Graft).filter(Graft.tree_id == tree.id, Graft.name == graft.name).first()
+    # Create or update tag
+    existing = db.query(Tag).filter(Tag.package_id == package.id, Tag.name == tag.name).first()
     if existing:
-        existing.fruit_id = graft.fruit_id
+        existing.artifact_id = tag.artifact_id
         existing.created_by = user_id
         db.commit()
         db.refresh(existing)
         return existing
 
-    db_graft = Graft(
-        tree_id=tree.id,
-        name=graft.name,
-        fruit_id=graft.fruit_id,
+    db_tag = Tag(
+        package_id=package.id,
+        name=tag.name,
+        artifact_id=tag.artifact_id,
         created_by=user_id,
     )
-    db.add(db_graft)
+    db.add(db_tag)
     db.commit()
-    db.refresh(db_graft)
-    return db_graft
+    db.refresh(db_tag)
+    return db_tag
 
 
 # Consumer routes
-@router.get("/api/v1/grove/{grove_name}/{tree_name}/consumers", response_model=List[ConsumerResponse])
-def get_consumers(grove_name: str, tree_name: str, db: Session = Depends(get_db)):
-    grove = db.query(Grove).filter(Grove.name == grove_name).first()
-    if not grove:
-        raise HTTPException(status_code=404, detail="Grove not found")
+@router.get("/api/v1/project/{project_name}/{package_name}/consumers", response_model=List[ConsumerResponse])
+def get_consumers(project_name: str, package_name: str, db: Session = Depends(get_db)):
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
 
-    tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
-    if not tree:
-        raise HTTPException(status_code=404, detail="Tree not found")
+    package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
+    if not package:
+        raise HTTPException(status_code=404, detail="Package not found")
 
-    consumers = db.query(Consumer).filter(Consumer.tree_id == tree.id).order_by(Consumer.last_access.desc()).all()
+    consumers = db.query(Consumer).filter(Consumer.package_id == package.id).order_by(Consumer.last_access.desc()).all()
     return consumers
 
 
-# Fruit by ID
-@router.get("/api/v1/fruit/{fruit_id}", response_model=FruitResponse)
-def get_fruit(fruit_id: str, db: Session = Depends(get_db)):
-    fruit = db.query(Fruit).filter(Fruit.id == fruit_id).first()
-    if not fruit:
-        raise HTTPException(status_code=404, detail="Fruit not found")
-    return fruit
+# Artifact by ID
+@router.get("/api/v1/artifact/{artifact_id}", response_model=ArtifactResponse)
+def get_artifact(artifact_id: str, db: Session = Depends(get_db)):
+    artifact = db.query(Artifact).filter(Artifact.id == artifact_id).first()
+    if not artifact:
+        raise HTTPException(status_code=404, detail="Artifact not found")
+    return artifact

backend/app/schemas.py

@@ -4,14 +4,14 @@ from pydantic import BaseModel
 from uuid import UUID
 
 
-# Grove schemas
-class GroveCreate(BaseModel):
+# Project schemas
+class ProjectCreate(BaseModel):
     name: str
     description: Optional[str] = None
     is_public: bool = True
 
 
-class GroveResponse(BaseModel):
+class ProjectResponse(BaseModel):
     id: UUID
     name: str
     description: Optional[str]
@@ -24,15 +24,15 @@ class GroveResponse(BaseModel):
         from_attributes = True
 
 
-# Tree schemas
-class TreeCreate(BaseModel):
+# Package schemas
+class PackageCreate(BaseModel):
     name: str
     description: Optional[str] = None
 
 
-class TreeResponse(BaseModel):
+class PackageResponse(BaseModel):
     id: UUID
-    grove_id: UUID
+    project_id: UUID
     name: str
     description: Optional[str]
     created_at: datetime
@@ -42,8 +42,8 @@ class TreeResponse(BaseModel):
         from_attributes = True
 
 
-# Fruit schemas
-class FruitResponse(BaseModel):
+# Artifact schemas
+class ArtifactResponse(BaseModel):
     id: str
     size: int
     content_type: Optional[str]
@@ -56,17 +56,17 @@ class FruitResponse(BaseModel):
         from_attributes = True
 
 
-# Graft schemas
-class GraftCreate(BaseModel):
+# Tag schemas
+class TagCreate(BaseModel):
     name: str
-    fruit_id: str
+    artifact_id: str
 
 
-class GraftResponse(BaseModel):
+class TagResponse(BaseModel):
     id: UUID
-    tree_id: UUID
+    package_id: UUID
     name: str
-    fruit_id: str
+    artifact_id: str
     created_at: datetime
     created_by: str
 
@@ -74,19 +74,19 @@ class GraftResponse(BaseModel):
         from_attributes = True
 
 
-# Cultivate response (upload)
-class CultivateResponse(BaseModel):
-    fruit_id: str
+# Upload response
+class UploadResponse(BaseModel):
+    artifact_id: str
     size: int
-    grove: str
-    tree: str
+    project: str
+    package: str
     tag: Optional[str]
 
 
 # Consumer schemas
 class ConsumerResponse(BaseModel):
     id: UUID
-    tree_id: UUID
+    package_id: UUID
     project_url: str
     last_access: datetime
     created_at: datetime