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

frontend/src/App.tsx

@@ -1,16 +1,16 @@
 import { Routes, Route } from 'react-router-dom';
 import Layout from './components/Layout';
 import Home from './pages/Home';
-import GrovePage from './pages/GrovePage';
-import TreePage from './pages/TreePage';
+import ProjectPage from './pages/ProjectPage';
+import PackagePage from './pages/PackagePage';
 
 function App() {
   return (
     <Layout>
       <Routes>
         <Route path="/" element={<Home />} />
-        <Route path="/grove/:groveName" element={<GrovePage />} />
-        <Route path="/grove/:groveName/:treeName" element={<TreePage />} />
+        <Route path="/project/:projectName" element={<ProjectPage />} />
+        <Route path="/project/:projectName/:packageName" element={<PackagePage />} />
       </Routes>
     </Layout>
   );

frontend/src/api.ts

@@ -1,4 +1,4 @@
-import { Grove, Tree, Graft, Fruit, CultivateResponse } from './types';
+import { Project, Package, Tag, Artifact, UploadResponse } from './types';
 
 const API_BASE = '/api/v1';
 
@@ -10,78 +10,78 @@ async function handleResponse<T>(response: Response): Promise<T> {
   return response.json();
 }
 
-// Grove API
-export async function listGroves(): Promise<Grove[]> {
-  const response = await fetch(`${API_BASE}/groves`);
-  return handleResponse<Grove[]>(response);
+// Project API
+export async function listProjects(): Promise<Project[]> {
+  const response = await fetch(`${API_BASE}/projects`);
+  return handleResponse<Project[]>(response);
 }
 
-export async function createGrove(data: { name: string; description?: string; is_public?: boolean }): Promise<Grove> {
-  const response = await fetch(`${API_BASE}/groves`, {
+export async function createProject(data: { name: string; description?: string; is_public?: boolean }): Promise<Project> {
+  const response = await fetch(`${API_BASE}/projects`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(data),
   });
-  return handleResponse<Grove>(response);
+  return handleResponse<Project>(response);
 }
 
-export async function getGrove(name: string): Promise<Grove> {
-  const response = await fetch(`${API_BASE}/groves/${name}`);
-  return handleResponse<Grove>(response);
+export async function getProject(name: string): Promise<Project> {
+  const response = await fetch(`${API_BASE}/projects/${name}`);
+  return handleResponse<Project>(response);
 }
 
-// Tree API
-export async function listTrees(groveName: string): Promise<Tree[]> {
-  const response = await fetch(`${API_BASE}/grove/${groveName}/trees`);
-  return handleResponse<Tree[]>(response);
+// Package API
+export async function listPackages(projectName: string): Promise<Package[]> {
+  const response = await fetch(`${API_BASE}/project/${projectName}/packages`);
+  return handleResponse<Package[]>(response);
 }
 
-export async function createTree(groveName: string, data: { name: string; description?: string }): Promise<Tree> {
-  const response = await fetch(`${API_BASE}/grove/${groveName}/trees`, {
+export async function createPackage(projectName: string, data: { name: string; description?: string }): Promise<Package> {
+  const response = await fetch(`${API_BASE}/project/${projectName}/packages`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(data),
   });
-  return handleResponse<Tree>(response);
+  return handleResponse<Package>(response);
 }
 
-// Graft API
-export async function listGrafts(groveName: string, treeName: string): Promise<Graft[]> {
-  const response = await fetch(`${API_BASE}/grove/${groveName}/${treeName}/grafts`);
-  return handleResponse<Graft[]>(response);
+// Tag API
+export async function listTags(projectName: string, packageName: string): Promise<Tag[]> {
+  const response = await fetch(`${API_BASE}/project/${projectName}/${packageName}/tags`);
+  return handleResponse<Tag[]>(response);
 }
 
-export async function createGraft(groveName: string, treeName: string, data: { name: string; fruit_id: string }): Promise<Graft> {
-  const response = await fetch(`${API_BASE}/grove/${groveName}/${treeName}/graft`, {
+export async function createTag(projectName: string, packageName: string, data: { name: string; artifact_id: string }): Promise<Tag> {
+  const response = await fetch(`${API_BASE}/project/${projectName}/${packageName}/tags`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(data),
   });
-  return handleResponse<Graft>(response);
+  return handleResponse<Tag>(response);
 }
 
-// Fruit API
-export async function getFruit(fruitId: string): Promise<Fruit> {
-  const response = await fetch(`${API_BASE}/fruit/${fruitId}`);
-  return handleResponse<Fruit>(response);
+// Artifact API
+export async function getArtifact(artifactId: string): Promise<Artifact> {
+  const response = await fetch(`${API_BASE}/artifact/${artifactId}`);
+  return handleResponse<Artifact>(response);
 }
 
 // Upload
-export async function cultivate(groveName: string, treeName: string, file: File, tag?: string): Promise<CultivateResponse> {
+export async function uploadArtifact(projectName: string, packageName: string, file: File, tag?: string): Promise<UploadResponse> {
   const formData = new FormData();
   formData.append('file', file);
   if (tag) {
     formData.append('tag', tag);
   }
 
-  const response = await fetch(`${API_BASE}/grove/${groveName}/${treeName}/cultivate`, {
+  const response = await fetch(`${API_BASE}/project/${projectName}/${packageName}/upload`, {
     method: 'POST',
     body: formData,
   });
-  return handleResponse<CultivateResponse>(response);
+  return handleResponse<UploadResponse>(response);
 }
 
 // Download URL
-export function getDownloadUrl(groveName: string, treeName: string, ref: string): string {
-  return `${API_BASE}/grove/${groveName}/${treeName}/+/${ref}`;
+export function getDownloadUrl(projectName: string, packageName: string, ref: string): string {
+  return `${API_BASE}/project/${projectName}/${packageName}/+/${ref}`;
 }

frontend/src/pages/Home.css

@@ -129,36 +129,36 @@
   border-radius: 8px;
 }
 
-.grove-grid {
+.project-grid {
   display: grid;
   grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
   gap: 1rem;
 }
 
-.grove-card {
+.project-card {
   display: block;
   color: inherit;
   transition: transform 0.2s, box-shadow 0.2s;
 }
 
-.grove-card:hover {
+.project-card:hover {
   transform: translateY(-2px);
   box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
   text-decoration: none;
 }
 
-.grove-card h3 {
+.project-card h3 {
   color: var(--primary);
   margin-bottom: 0.5rem;
 }
 
-.grove-card p {
+.project-card p {
   color: var(--text-light);
   font-size: 0.875rem;
   margin-bottom: 1rem;
 }
 
-.grove-meta {
+.project-meta {
   display: flex;
   justify-content: space-between;
   align-items: center;

frontend/src/pages/Home.tsx

@@ -1,74 +1,74 @@
 import { useState, useEffect } from 'react';
 import { Link } from 'react-router-dom';
-import { Grove } from '../types';
-import { listGroves, createGrove } from '../api';
+import { Project } from '../types';
+import { listProjects, createProject } from '../api';
 import './Home.css';
 
 function Home() {
-  const [groves, setGroves] = useState<Grove[]>([]);
+  const [projects, setProjects] = useState<Project[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [showForm, setShowForm] = useState(false);
-  const [newGrove, setNewGrove] = useState({ name: '', description: '', is_public: true });
+  const [newProject, setNewProject] = useState({ name: '', description: '', is_public: true });
   const [creating, setCreating] = useState(false);
 
   useEffect(() => {
-    loadGroves();
+    loadProjects();
   }, []);
 
-  async function loadGroves() {
+  async function loadProjects() {
     try {
       setLoading(true);
-      const data = await listGroves();
-      setGroves(data);
+      const data = await listProjects();
+      setProjects(data);
       setError(null);
     } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to load groves');
+      setError(err instanceof Error ? err.message : 'Failed to load projects');
     } finally {
       setLoading(false);
     }
   }
 
-  async function handleCreateGrove(e: React.FormEvent) {
+  async function handleCreateProject(e: React.FormEvent) {
     e.preventDefault();
     try {
       setCreating(true);
-      await createGrove(newGrove);
-      setNewGrove({ name: '', description: '', is_public: true });
+      await createProject(newProject);
+      setNewProject({ name: '', description: '', is_public: true });
       setShowForm(false);
-      loadGroves();
+      loadProjects();
     } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to create grove');
+      setError(err instanceof Error ? err.message : 'Failed to create project');
     } finally {
       setCreating(false);
     }
   }
 
   if (loading) {
-    return <div className="loading">Loading groves...</div>;
+    return <div className="loading">Loading projects...</div>;
   }
 
   return (
     <div className="home">
       <div className="page-header">
-        <h1>Groves</h1>
+        <h1>Projects</h1>
         <button className="btn btn-primary" onClick={() => setShowForm(!showForm)}>
-          {showForm ? 'Cancel' : '+ New Grove'}
+          {showForm ? 'Cancel' : '+ New Project'}
         </button>
       </div>
 
       {error && <div className="error-message">{error}</div>}
 
       {showForm && (
-        <form className="form card" onSubmit={handleCreateGrove}>
-          <h3>Create New Grove</h3>
+        <form className="form card" onSubmit={handleCreateProject}>
+          <h3>Create New Project</h3>
           <div className="form-group">
             <label htmlFor="name">Name</label>
             <input
               id="name"
               type="text"
-              value={newGrove.name}
-              onChange={(e) => setNewGrove({ ...newGrove, name: e.target.value })}
+              value={newProject.name}
+              onChange={(e) => setNewProject({ ...newProject, name: e.target.value })}
               placeholder="my-project"
               required
             />
@@ -78,8 +78,8 @@ function Home() {
             <input
               id="description"
               type="text"
-              value={newGrove.description}
-              onChange={(e) => setNewGrove({ ...newGrove, description: e.target.value })}
+              value={newProject.description}
+              onChange={(e) => setNewProject({ ...newProject, description: e.target.value })}
               placeholder="Optional description"
             />
           </div>
@@ -87,34 +87,34 @@ function Home() {
             <label>
               <input
                 type="checkbox"
-                checked={newGrove.is_public}
-                onChange={(e) => setNewGrove({ ...newGrove, is_public: e.target.checked })}
+                checked={newProject.is_public}
+                onChange={(e) => setNewProject({ ...newProject, is_public: e.target.checked })}
               />
               Public
             </label>
           </div>
           <button type="submit" className="btn btn-primary" disabled={creating}>
-            {creating ? 'Creating...' : 'Create Grove'}
+            {creating ? 'Creating...' : 'Create Project'}
           </button>
         </form>
       )}
 
-      {groves.length === 0 ? (
+      {projects.length === 0 ? (
         <div className="empty-state">
-          <p>No groves yet. Create your first grove to get started!</p>
+          <p>No projects yet. Create your first project to get started!</p>
         </div>
       ) : (
-        <div className="grove-grid">
-          {groves.map((grove) => (
-            <Link to={`/grove/${grove.name}`} key={grove.id} className="grove-card card">
-              <h3>{grove.name}</h3>
-              {grove.description && <p>{grove.description}</p>}
-              <div className="grove-meta">
-                <span className={`badge ${grove.is_public ? 'badge-public' : 'badge-private'}`}>
-                  {grove.is_public ? 'Public' : 'Private'}
+        <div className="project-grid">
+          {projects.map((project) => (
+            <Link to={`/project/${project.name}`} key={project.id} className="project-card card">
+              <h3>{project.name}</h3>
+              {project.description && <p>{project.description}</p>}
+              <div className="project-meta">
+                <span className={`badge ${project.is_public ? 'badge-public' : 'badge-private'}`}>
+                  {project.is_public ? 'Public' : 'Private'}
                 </span>
                 <span className="date">
-                  Created {new Date(grove.created_at).toLocaleDateString()}
+                  Created {new Date(project.created_at).toLocaleDateString()}
                 </span>
               </div>
             </Link>

frontend/src/pages/PackagePage.css

@@ -54,7 +54,7 @@ h2 {
   color: var(--primary-dark);
 }
 
-.grafts-table {
+.tags-table {
   background-color: var(--surface);
   border: 1px solid var(--border);
   border-radius: 8px;
@@ -62,19 +62,19 @@ h2 {
   margin-bottom: 2rem;
 }
 
-.grafts-table table {
+.tags-table table {
   width: 100%;
   border-collapse: collapse;
 }
 
-.grafts-table th,
-.grafts-table td {
+.tags-table th,
+.tags-table td {
   padding: 0.875rem 1rem;
   text-align: left;
   border-bottom: 1px solid var(--border);
 }
 
-.grafts-table th {
+.tags-table th {
   background-color: #f9f9f9;
   font-weight: 600;
   font-size: 0.75rem;
@@ -82,15 +82,15 @@ h2 {
   color: var(--text-light);
 }
 
-.grafts-table tr:last-child td {
+.tags-table tr:last-child td {
   border-bottom: none;
 }
 
-.grafts-table tr:hover {
+.tags-table tr:hover {
   background-color: #f9f9f9;
 }
 
-.fruit-id {
+.artifact-id {
   font-family: monospace;
   font-size: 0.875rem;
   color: var(--text-light);

frontend/src/pages/PackagePage.tsx

@@ -1,13 +1,13 @@
 import { useState, useEffect, useRef } from 'react';
 import { useParams, Link } from 'react-router-dom';
-import { Graft } from '../types';
-import { listGrafts, cultivate, getDownloadUrl } from '../api';
+import { Tag } from '../types';
+import { listTags, uploadArtifact, getDownloadUrl } from '../api';
 import './Home.css';
-import './TreePage.css';
+import './PackagePage.css';
 
-function TreePage() {
-  const { groveName, treeName } = useParams<{ groveName: string; treeName: string }>();
-  const [grafts, setGrafts] = useState<Graft[]>([]);
+function PackagePage() {
+  const { projectName, packageName } = useParams<{ projectName: string; packageName: string }>();
+  const [tags, setTags] = useState<Tag[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [uploading, setUploading] = useState(false);
@@ -16,19 +16,19 @@ function TreePage() {
   const fileInputRef = useRef<HTMLInputElement>(null);
 
   useEffect(() => {
-    if (groveName && treeName) {
-      loadGrafts();
+    if (projectName && packageName) {
+      loadTags();
     }
-  }, [groveName, treeName]);
+  }, [projectName, packageName]);
 
-  async function loadGrafts() {
+  async function loadTags() {
     try {
       setLoading(true);
-      const data = await listGrafts(groveName!, treeName!);
-      setGrafts(data);
+      const data = await listTags(projectName!, packageName!);
+      setTags(data);
       setError(null);
     } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to load grafts');
+      setError(err instanceof Error ? err.message : 'Failed to load tags');
     } finally {
       setLoading(false);
     }
@@ -45,13 +45,13 @@ function TreePage() {
     try {
       setUploading(true);
       setError(null);
-      const result = await cultivate(groveName!, treeName!, file, tag || undefined);
-      setUploadResult(`Uploaded successfully! Fruit ID: ${result.fruit_id}`);
+      const result = await uploadArtifact(projectName!, packageName!, file, tag || undefined);
+      setUploadResult(`Uploaded successfully! Artifact ID: ${result.artifact_id}`);
       setTag('');
       if (fileInputRef.current) {
         fileInputRef.current.value = '';
       }
-      loadGrafts();
+      loadTags();
     } catch (err) {
       setError(err instanceof Error ? err.message : 'Upload failed');
     } finally {
@@ -66,11 +66,11 @@ function TreePage() {
   return (
     <div className="home">
       <nav className="breadcrumb">
-        <Link to="/">Groves</Link> / <Link to={`/grove/${groveName}`}>{groveName}</Link> / <span>{treeName}</span>
+        <Link to="/">Projects</Link> / <Link to={`/project/${projectName}`}>{projectName}</Link> / <span>{packageName}</span>
       </nav>
 
       <div className="page-header">
-        <h1>📦 {treeName}</h1>
+        <h1>{packageName}</h1>
       </div>
 
       {error && <div className="error-message">{error}</div>}
@@ -105,30 +105,30 @@ function TreePage() {
       </div>
 
       <h2>Tags / Versions</h2>
-      {grafts.length === 0 ? (
+      {tags.length === 0 ? (
         <div className="empty-state">
           <p>No tags yet. Upload an artifact with a tag to create one!</p>
         </div>
       ) : (
-        <div className="grafts-table">
+        <div className="tags-table">
           <table>
             <thead>
               <tr>
                 <th>Tag</th>
-                <th>Fruit ID</th>
+                <th>Artifact ID</th>
                 <th>Created</th>
                 <th>Actions</th>
               </tr>
             </thead>
             <tbody>
-              {grafts.map((graft) => (
-                <tr key={graft.id}>
-                  <td><strong>{graft.name}</strong></td>
-                  <td className="fruit-id">{graft.fruit_id.substring(0, 12)}...</td>
-                  <td>{new Date(graft.created_at).toLocaleString()}</td>
+              {tags.map((t) => (
+                <tr key={t.id}>
+                  <td><strong>{t.name}</strong></td>
+                  <td className="artifact-id">{t.artifact_id.substring(0, 12)}...</td>
+                  <td>{new Date(t.created_at).toLocaleString()}</td>
                   <td>
                     <a
-                      href={getDownloadUrl(groveName!, treeName!, graft.name)}
+                      href={getDownloadUrl(projectName!, packageName!, t.name)}
                       className="btn btn-secondary btn-small"
                       download
                     >
@@ -146,15 +146,15 @@ function TreePage() {
         <h3>Usage</h3>
         <p>Download artifacts using:</p>
         <pre>
-          <code>curl -O {window.location.origin}/api/v1/grove/{groveName}/{treeName}/+/latest</code>
+          <code>curl -O {window.location.origin}/api/v1/project/{projectName}/{packageName}/+/latest</code>
         </pre>
         <p>Or with a specific tag:</p>
         <pre>
-          <code>curl -O {window.location.origin}/api/v1/grove/{groveName}/{treeName}/+/v1.0.0</code>
+          <code>curl -O {window.location.origin}/api/v1/project/{projectName}/{packageName}/+/v1.0.0</code>
         </pre>
       </div>
     </div>
   );
 }
 
-export default TreePage;
+export default PackagePage;

frontend/src/pages/ProjectPage.tsx

@@ -1,34 +1,34 @@
 import { useState, useEffect } from 'react';
 import { useParams, Link } from 'react-router-dom';
-import { Grove, Tree } from '../types';
-import { getGrove, listTrees, createTree } from '../api';
+import { Project, Package } from '../types';
+import { getProject, listPackages, createPackage } from '../api';
 import './Home.css';
 
-function GrovePage() {
-  const { groveName } = useParams<{ groveName: string }>();
-  const [grove, setGrove] = useState<Grove | null>(null);
-  const [trees, setTrees] = useState<Tree[]>([]);
+function ProjectPage() {
+  const { projectName } = useParams<{ projectName: string }>();
+  const [project, setProject] = useState<Project | null>(null);
+  const [packages, setPackages] = useState<Package[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [showForm, setShowForm] = useState(false);
-  const [newTree, setNewTree] = useState({ name: '', description: '' });
+  const [newPackage, setNewPackage] = useState({ name: '', description: '' });
   const [creating, setCreating] = useState(false);
 
   useEffect(() => {
-    if (groveName) {
+    if (projectName) {
       loadData();
     }
-  }, [groveName]);
+  }, [projectName]);
 
   async function loadData() {
     try {
       setLoading(true);
-      const [groveData, treesData] = await Promise.all([
-        getGrove(groveName!),
-        listTrees(groveName!),
+      const [projectData, packagesData] = await Promise.all([
+        getProject(projectName!),
+        listPackages(projectName!),
       ]);
-      setGrove(groveData);
-      setTrees(treesData);
+      setProject(projectData);
+      setPackages(packagesData);
       setError(null);
     } catch (err) {
       setError(err instanceof Error ? err.message : 'Failed to load data');
@@ -37,16 +37,16 @@ function GrovePage() {
     }
   }
 
-  async function handleCreateTree(e: React.FormEvent) {
+  async function handleCreatePackage(e: React.FormEvent) {
     e.preventDefault();
     try {
       setCreating(true);
-      await createTree(groveName!, newTree);
-      setNewTree({ name: '', description: '' });
+      await createPackage(projectName!, newPackage);
+      setNewPackage({ name: '', description: '' });
       setShowForm(false);
       loadData();
     } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to create tree');
+      setError(err instanceof Error ? err.message : 'Failed to create package');
     } finally {
       setCreating(false);
     }
@@ -56,38 +56,38 @@ function GrovePage() {
     return <div className="loading">Loading...</div>;
   }
 
-  if (!grove) {
-    return <div className="error-message">Grove not found</div>;
+  if (!project) {
+    return <div className="error-message">Project not found</div>;
   }
 
   return (
     <div className="home">
       <nav className="breadcrumb">
-        <Link to="/">Groves</Link> / <span>{grove.name}</span>
+        <Link to="/">Projects</Link> / <span>{project.name}</span>
       </nav>
 
       <div className="page-header">
         <div>
-          <h1>{grove.name}</h1>
-          {grove.description && <p className="description">{grove.description}</p>}
+          <h1>{project.name}</h1>
+          {project.description && <p className="description">{project.description}</p>}
         </div>
         <button className="btn btn-primary" onClick={() => setShowForm(!showForm)}>
-          {showForm ? 'Cancel' : '+ New Tree'}
+          {showForm ? 'Cancel' : '+ New Package'}
         </button>
       </div>
 
       {error && <div className="error-message">{error}</div>}
 
       {showForm && (
-        <form className="form card" onSubmit={handleCreateTree}>
-          <h3>Create New Tree</h3>
+        <form className="form card" onSubmit={handleCreatePackage}>
+          <h3>Create New Package</h3>
           <div className="form-group">
             <label htmlFor="name">Name</label>
             <input
               id="name"
               type="text"
-              value={newTree.name}
-              onChange={(e) => setNewTree({ ...newTree, name: e.target.value })}
+              value={newPackage.name}
+              onChange={(e) => setNewPackage({ ...newPackage, name: e.target.value })}
               placeholder="releases"
               required
             />
@@ -97,30 +97,30 @@ function GrovePage() {
             <input
               id="description"
               type="text"
-              value={newTree.description}
-              onChange={(e) => setNewTree({ ...newTree, description: e.target.value })}
+              value={newPackage.description}
+              onChange={(e) => setNewPackage({ ...newPackage, description: e.target.value })}
               placeholder="Optional description"
             />
           </div>
           <button type="submit" className="btn btn-primary" disabled={creating}>
-            {creating ? 'Creating...' : 'Create Tree'}
+            {creating ? 'Creating...' : 'Create Package'}
           </button>
         </form>
       )}
 
-      {trees.length === 0 ? (
+      {packages.length === 0 ? (
         <div className="empty-state">
-          <p>No trees yet. Create your first tree to start uploading artifacts!</p>
+          <p>No packages yet. Create your first package to start uploading artifacts!</p>
         </div>
       ) : (
-        <div className="grove-grid">
-          {trees.map((tree) => (
-            <Link to={`/grove/${groveName}/${tree.name}`} key={tree.id} className="grove-card card">
-              <h3>📦 {tree.name}</h3>
-              {tree.description && <p>{tree.description}</p>}
-              <div className="grove-meta">
+        <div className="project-grid">
+          {packages.map((pkg) => (
+            <Link to={`/project/${projectName}/${pkg.name}`} key={pkg.id} className="project-card card">
+              <h3>{pkg.name}</h3>
+              {pkg.description && <p>{pkg.description}</p>}
+              <div className="project-meta">
                 <span className="date">
-                  Created {new Date(tree.created_at).toLocaleDateString()}
+                  Created {new Date(pkg.created_at).toLocaleDateString()}
                 </span>
               </div>
             </Link>
@@ -131,4 +131,4 @@ function GrovePage() {
   );
 }
 
-export default GrovePage;
+export default ProjectPage;

frontend/src/types.ts

@@ -1,4 +1,4 @@
-export interface Grove {
+export interface Project {
   id: string;
   name: string;
   description: string | null;
@@ -8,16 +8,16 @@ export interface Grove {
   created_by: string;
 }
 
-export interface Tree {
+export interface Package {
   id: string;
-  grove_id: string;
+  project_id: string;
   name: string;
   description: string | null;
   created_at: string;
   updated_at: string;
 }
 
-export interface Fruit {
+export interface Artifact {
   id: string;
   size: number;
   content_type: string | null;
@@ -27,27 +27,27 @@ export interface Fruit {
   ref_count: number;
 }
 
-export interface Graft {
+export interface Tag {
   id: string;
-  tree_id: string;
+  package_id: string;
   name: string;
-  fruit_id: string;
+  artifact_id: string;
   created_at: string;
   created_by: string;
 }
 
 export interface Consumer {
   id: string;
-  tree_id: string;
+  package_id: string;
   project_url: string;
   last_access: string;
   created_at: string;
 }
 
-export interface CultivateResponse {
-  fruit_id: string;
+export interface UploadResponse {
+  artifact_id: string;
   size: number;
-  grove: string;
-  tree: string;
+  project: string;
+  package: string;
   tag: string | null;
 }