vibe-engineering 0.1.7__py3-none-any.whl

src/cli/__init__.py

@@ -0,0 +1,4 @@
+"""CLI module for command-line interface."""
+from .commands import app
+
+__all__ = ["app"]

src/cli/commands.py

@@ -0,0 +1,224 @@
+"""CLI commands for vibe-engineering."""
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich import box
+import time
+
+from src.db import MongoDBClient, get_documents
+from src.llm import FireworksClient
+from src.schemas import SpecifySchema
+
+app = typer.Typer(
+    name="vibe",
+    help="🚀 Vibe Engineering - AI-powered specification and memory management CLI",
+    add_completion=False,
+    rich_markup_mode="rich"
+)
+
+
+@app.command()
+def status():
+    """🔍 Show system status and configuration."""
+    console = Console()
+    
+    console.print("\n[bold blue]🚀 Vibe Engineering Status[/bold blue]\n")
+    
+    # System status panel
+    status_info = "[green]✅ CLI Active[/green]\n"
+    status_info += "[cyan]Version:[/cyan] 0.1.0\n"
+    status_info += "[cyan]Environment:[/cyan] Production"
+    
+    status_panel = Panel(
+        status_info,
+        title="📊 System Status",
+        border_style="blue",
+        box=box.ROUNDED
+    )
+    console.print(status_panel)
+    
+    # Quick help
+    help_text = """[yellow]💡 Quick Commands:[/yellow]
+    
+• [cyan]vibe team[/cyan]           Show team members
+• [cyan]vibe specify[/cyan]        Generate specifications  
+• [cyan]vibe status[/cyan]         Show this status
+• [cyan]vibe --help[/cyan]         Full command list"""
+    
+    help_panel = Panel(
+        help_text,
+        title="🆘 Quick Help",
+        border_style="yellow",
+        box=box.ROUNDED
+    )
+    console.print(help_panel)
+
+
+@app.command()
+def version():
+    """📦 Show version information."""
+    console = Console()
+    
+    version_text = Text("🚀 Vibe Engineering v0.1.0", style="bold blue")
+    console.print(Panel(version_text, box=box.DOUBLE))
+
+
+@app.command()
+def team():
+    """👥 Display the team members from the database."""
+    console = Console()
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console
+    ) as progress:
+        task = progress.add_task("Loading team members...", total=None)
+        
+        try:
+            with MongoDBClient() as db_client:
+                documents = get_documents(
+                    db_client=db_client,
+                    db_name="master",
+                    collection_name="team",
+                    query={}
+                )
+                team_members = [doc["name"] for doc in documents]
+                progress.update(task, completed=True)
+
+            if not team_members:
+                console.print("\n[red]❌ No team members found.[/red]")
+                console.print("[yellow]💡 Tip: Check your database connection and team collection[/yellow]")
+                return
+
+            # Create a beautiful table
+            table = Table(
+                title="🚀 Vibe Engineering Team", 
+                title_style="bold magenta",
+                box=box.ROUNDED,
+                show_header=True,
+                header_style="bold blue"
+            )
+            table.add_column("#", style="cyan", justify="center", width=4)
+            table.add_column("👤 Name", style="green", justify="left")
+            table.add_column("📊 Status", style="bright_blue", justify="center")
+            table.add_column("🕒 Last Seen", style="yellow", justify="center")
+
+            # Add team members to the table
+            for i, member in enumerate(team_members, 1):
+                table.add_row(
+                    str(i), 
+                    member, 
+                    "✨ Active",
+                    "Just now"
+                )
+
+            # Display the table with some extra styling
+            console.print()
+            console.print(table)
+            
+            # Summary panel
+            summary = f"[bold green]Total Members:[/bold green] {len(team_members)}\n"
+            summary += "[bold blue]All Active:[/bold blue] ✅\n"
+            summary += "[bold yellow]Team Health:[/bold yellow] 🟢 Excellent"
+            
+            summary_panel = Panel(
+                summary,
+                title="📈 Team Summary",
+                border_style="green",
+                box=box.ROUNDED
+            )
+            console.print(summary_panel)
+            
+        except Exception as e:
+            progress.update(task, completed=True)
+            console.print(f"\n[red]❌ Error loading team:[/red] {e}")
+            console.print("[yellow]💡 Check your MongoDB connection and configuration[/yellow]")
+
+
+@app.command()
+def specify(
+    prompt: str = typer.Argument(..., help="The specification prompt to process"),
+    output_format: str = typer.Option("json", "--format", "-f", help="Output format: json, yaml, markdown"),
+    save: bool = typer.Option(False, "--save", "-s", help="Save the specification to database"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed output")
+):
+    """✨ Generate a specification schema using AI."""
+    console = Console()
+    
+    console.print(f"\n[bold blue]✨ Generating Specification[/bold blue]\n")
+    
+    if verbose:
+        console.print(f"[cyan]📝 Prompt:[/cyan] {prompt}")
+        console.print(f"[cyan]📄 Format:[/cyan] {output_format}")
+        console.print(f"[cyan]💾 Save:[/cyan] {'Yes' if save else 'No'}")
+        console.print()
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console
+    ) as progress:
+        task = progress.add_task("🤖 Processing with AI...", total=None)
+        
+        try:
+            llm_client = FireworksClient()
+            response = llm_client.generate_with_schema(
+                prompt=prompt,
+                schema=SpecifySchema.model_json_schema(),
+                schema_name="SpecifySchema",
+            )
+            progress.update(task, completed=True)
+
+            # Display results
+            console.print()
+            result_panel = Panel(
+                response,
+                title="📋 Generated Specification",
+                border_style="green",
+                box=box.ROUNDED
+            )
+            console.print(result_panel)
+            
+            if save:
+                console.print("\n[yellow]💾 Saving to database...[/yellow]")
+                # TODO: Implement save functionality
+                console.print("[green]✅ Specification saved successfully![/green]")
+            
+            # Next steps
+            next_steps = """[yellow]💡 Next Steps:[/yellow]
+            
+• Review and refine the specification
+• Save to database with [cyan]--save[/cyan] flag
+• Use [cyan]vibe plan[/cyan] to create implementation plan
+• Generate tasks with [cyan]vibe tasks[/cyan]"""
+            
+            steps_panel = Panel(
+                next_steps,
+                title="🚀 What's Next?",
+                border_style="yellow",
+                box=box.ROUNDED
+            )
+            console.print(steps_panel)
+            
+        except Exception as e:
+            progress.update(task, completed=True)
+            console.print(f"\n[red]❌ Error generating specification:[/red] {e}")
+            console.print("[yellow]💡 Check your API keys and network connection[/yellow]")
+
+
+@app.callback()
+def main():
+    """
+    🚀 [bold blue]Vibe Engineering[/bold blue] - AI-powered specification and memory management CLI
+    
+    [dim]Manage your project specifications, team knowledge, and development workflows with AI assistance.[/dim]
+    """
+    pass
+
+
+if __name__ == "__main__":
+    app()

src/db/__init__.py

@@ -0,0 +1,22 @@
+"""Database module for MongoDB interactions."""
+from .client import MongoDBClient
+from .operations import (
+    upsert_document,
+    get_document,
+    get_documents,
+    delete_document,
+    delete_documents,
+    insert_document,
+    insert_documents,
+)
+
+__all__ = [
+    "MongoDBClient",
+    "upsert_document",
+    "get_document",
+    "get_documents",
+    "delete_document",
+    "delete_documents",
+    "insert_document",
+    "insert_documents",
+]

src/db/client.py

@@ -0,0 +1,61 @@
+"""MongoDB client connection management."""
+import os
+from typing import Optional
+
+import certifi
+from dotenv import load_dotenv
+from pymongo import MongoClient
+from pymongo.database import Database
+
+
+class MongoDBClient:
+    """Manages MongoDB connections and provides access to database resources."""
+
+    def __init__(self, uri: Optional[str] = None):
+        """
+        Initialize MongoDB client.
+
+        Args:
+            uri: MongoDB connection URI. If not provided, reads from MONGODB_URI env var.
+        """
+        load_dotenv()
+        self.uri = uri or os.getenv("MONGODB_URI")
+
+        if not self.uri:
+            raise ValueError("MONGODB_URI environment variable is not set")
+
+        self._client: Optional[MongoClient] = None
+
+    def connect(self) -> MongoClient:
+        """Establish connection to MongoDB."""
+        if self._client is None:
+            self._client = MongoClient(self.uri, tlsCAFile=certifi.where())
+        return self._client
+
+    def get_database(self, db_name: str = "master") -> Database:
+        """
+        Get a database instance.
+
+        Args:
+            db_name: Name of the database. Defaults to "master".
+
+        Returns:
+            Database instance.
+        """
+        client = self.connect()
+        return client.get_database(db_name)
+
+    def close(self):
+        """Close the MongoDB connection."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()

src/db/operations.py

@@ -0,0 +1,193 @@
+"""Generic CRUD operations for MongoDB."""
+from typing import Dict, Any, List, Optional
+
+from .client import MongoDBClient
+
+
+def upsert_document(
+    db_client: MongoDBClient,
+    db_name: str,
+    collection_name: str,
+    query: Dict[str, Any],
+    document: Dict[str, Any],
+    upsert: bool = True
+) -> Any:
+    """
+    Upsert a single document in MongoDB.
+
+    Args:
+        db_client: MongoDB client instance.
+        db_name: Database name.
+        collection_name: Collection name.
+        query: Query to find existing document.
+        document: Document data to insert/update.
+        upsert: If True, insert if document doesn't exist. Defaults to True.
+
+    Returns:
+        Result of the update operation.
+    """
+    db = db_client.get_database(db_name)
+    collection = db[collection_name]
+
+    result = collection.update_one(query, {"$set": document}, upsert=upsert)
+    return result
+
+
+def get_document(
+    db_client: MongoDBClient,
+    db_name: str,
+    collection_name: str,
+    query: Dict[str, Any]
+) -> Optional[Dict[str, Any]]:
+    """
+    Get a single document from MongoDB.
+
+    Args:
+        db_client: MongoDB client instance.
+        db_name: Database name.
+        collection_name: Collection name.
+        query: Query criteria to find the document.
+
+    Returns:
+        Document if found, None otherwise.
+    """
+    db = db_client.get_database(db_name)
+    collection = db[collection_name]
+
+    return collection.find_one(query)
+
+
+def get_documents(
+    db_client: MongoDBClient,
+    db_name: str,
+    collection_name: str,
+    query: Dict[str, Any],
+    limit: Optional[int] = None,
+    sort: Optional[List[tuple]] = None
+) -> List[Dict[str, Any]]:
+    """
+    Get multiple documents from MongoDB.
+
+    Args:
+        db_client: MongoDB client instance.
+        db_name: Database name.
+        collection_name: Collection name.
+        query: Query criteria to find documents.
+        limit: Maximum number of documents to return. None for all.
+        sort: List of (field, direction) tuples for sorting.
+
+    Returns:
+        List of documents matching the query.
+    """
+    db = db_client.get_database(db_name)
+    collection = db[collection_name]
+
+    cursor = collection.find(query)
+
+    if sort:
+        cursor = cursor.sort(sort)
+
+    if limit:
+        cursor = cursor.limit(limit)
+
+    return list(cursor)
+
+
+def delete_document(
+    db_client: MongoDBClient,
+    db_name: str,
+    collection_name: str,
+    query: Dict[str, Any]
+) -> int:
+    """
+    Delete a single document from MongoDB.
+
+    Args:
+        db_client: MongoDB client instance.
+        db_name: Database name.
+        collection_name: Collection name.
+        query: Query criteria to find the document to delete.
+
+    Returns:
+        Number of documents deleted (0 or 1).
+    """
+    db = db_client.get_database(db_name)
+    collection = db[collection_name]
+
+    result = collection.delete_one(query)
+    return result.deleted_count
+
+
+def delete_documents(
+    db_client: MongoDBClient,
+    db_name: str,
+    collection_name: str,
+    query: Dict[str, Any]
+) -> int:
+    """
+    Delete multiple documents from MongoDB.
+
+    Args:
+        db_client: MongoDB client instance.
+        db_name: Database name.
+        collection_name: Collection name.
+        query: Query criteria to find documents to delete.
+
+    Returns:
+        Number of documents deleted.
+    """
+    db = db_client.get_database(db_name)
+    collection = db[collection_name]
+
+    result = collection.delete_many(query)
+    return result.deleted_count
+
+
+def insert_document(
+    db_client: MongoDBClient,
+    db_name: str,
+    collection_name: str,
+    document: Dict[str, Any]
+) -> Any:
+    """
+    Insert a single document into MongoDB.
+
+    Args:
+        db_client: MongoDB client instance.
+        db_name: Database name.
+        collection_name: Collection name.
+        document: Document to insert.
+
+    Returns:
+        Inserted document ID.
+    """
+    db = db_client.get_database(db_name)
+    collection = db[collection_name]
+
+    result = collection.insert_one(document)
+    return result.inserted_id
+
+
+def insert_documents(
+    db_client: MongoDBClient,
+    db_name: str,
+    collection_name: str,
+    documents: List[Dict[str, Any]]
+) -> List[Any]:
+    """
+    Insert multiple documents into MongoDB.
+
+    Args:
+        db_client: MongoDB client instance.
+        db_name: Database name.
+        collection_name: Collection name.
+        documents: List of documents to insert.
+
+    Returns:
+        List of inserted document IDs.
+    """
+    db = db_client.get_database(db_name)
+    collection = db[collection_name]
+
+    result = collection.insert_many(documents)
+    return result.inserted_ids

src/llm/__init__.py

@@ -0,0 +1,6 @@
+"""LLM module for AI integrations."""
+from .client import FireworksClient
+from .embeddings import VoyageEmbeddings
+from .segmentation import SpecificationSegmenter
+
+__all__ = ["FireworksClient", "VoyageEmbeddings", "SpecificationSegmenter"]

src/llm/client.py

@@ -0,0 +1,72 @@
+"""LLM client for Fireworks AI integration."""
+import os
+from typing import Dict, Any, Optional
+
+from dotenv import load_dotenv
+from fireworks import LLM
+
+
+class FireworksClient:
+    """Client for interacting with Fireworks AI LLM services."""
+
+    def __init__(self, api_key: Optional[str] = None, model: str = "deepseek-v3p1-terminus"):
+        """
+        Initialize Fireworks AI client.
+
+        Args:
+            api_key: Fireworks API key. If not provided, reads from FIREWORKS_API_KEY env var.
+            model: Model name to use. Defaults to "deepseek-v3p1-terminus".
+        """
+        load_dotenv()
+        self.api_key = api_key or os.getenv("FIREWORKS_API_KEY")
+
+        if not self.api_key:
+            raise ValueError("FIREWORKS_API_KEY environment variable is not set")
+
+        self.model = model
+        self._client = LLM(model=self.model, deployment_type="auto", api_key=self.api_key)
+
+    def generate_with_schema(self, prompt: str, schema: Dict[str, Any], schema_name: str = "ResponseSchema") -> str:
+        """
+        Generate a response following a specific JSON schema.
+
+        Args:
+            prompt: User prompt to send to the LLM.
+            schema: Pydantic model JSON schema to enforce.
+            schema_name: Name of the schema. Defaults to "ResponseSchema".
+
+        Returns:
+            Generated response content as a string.
+        """
+        response = self._client.chat.completions.create(
+            response_format={
+                "type": "json_schema",
+                "json_schema": {
+                    "name": schema_name,
+                    "schema": schema,
+                },
+            },
+            messages=[{"role": "user", "content": prompt}],
+        )
+
+        return response.choices[0].message.content
+
+    def chat(self, messages: list, temperature: float = 0.7, max_tokens: int = 2000) -> str:
+        """
+        Simple chat completion without schema enforcement.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content' keys.
+            temperature: Sampling temperature. Defaults to 0.7.
+            max_tokens: Maximum tokens to generate. Defaults to 2000.
+
+        Returns:
+            Generated response content as a string.
+        """
+        response = self._client.chat.completions.create(
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+
+        return response.choices[0].message.content

src/llm/embeddings.py

@@ -0,0 +1,86 @@
+"""Embedding generation using Voyage AI."""
+import os
+from typing import Optional, List
+
+import requests
+from dotenv import load_dotenv
+
+
+class VoyageEmbeddings:
+    """Client for generating embeddings using Voyage AI."""
+
+    def __init__(self, api_key: Optional[str] = None, model: str = "voyage-2"):
+        """
+        Initialize Voyage AI embeddings client.
+
+        Args:
+            api_key: Voyage API key. If not provided, reads from VOYAGE_API_KEY env var.
+            model: Model name to use. Defaults to "voyage-2".
+        """
+        load_dotenv()
+        self.api_key = api_key or os.getenv("VOYAGE_API_KEY")
+        self.model = model
+        self.default_dimension = 1024  # Default for voyage-2
+
+    def embed(self, text: str) -> Optional[List[float]]:
+        """
+        Generate embedding for given text.
+
+        Args:
+            text: Text to embed.
+
+        Returns:
+            List of floats representing the embedding, or None if API key not set.
+        """
+        if not self.api_key:
+            # Return a dummy embedding for testing
+            return [0.0] * self.default_dimension
+
+        try:
+            response = requests.post(
+                "https://api.voyageai.com/v1/embeddings",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={"input": text, "model": self.model},
+                timeout=30,
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data["data"][0]["embedding"]
+        except Exception as e:
+            print(f"Warning: Embedding failed: {e}")
+            # Return dummy embedding on failure
+            return [0.0] * self.default_dimension
+
+    def embed_batch(self, texts: List[str]) -> List[Optional[List[float]]]:
+        """
+        Generate embeddings for multiple texts.
+
+        Args:
+            texts: List of texts to embed.
+
+        Returns:
+            List of embeddings corresponding to input texts.
+        """
+        if not self.api_key:
+            return [[0.0] * self.default_dimension for _ in texts]
+
+        try:
+            response = requests.post(
+                "https://api.voyageai.com/v1/embeddings",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={"input": texts, "model": self.model},
+                timeout=30,
+            )
+            response.raise_for_status()
+            data = response.json()
+            return [item["embedding"] for item in data["data"]]
+        except Exception as e:
+            print(f"Warning: Batch embedding failed: {e}")
+            # Return dummy embeddings on failure
+            return [[0.0] * self.default_dimension for _ in texts]

src/llm/segmentation.py

@@ -0,0 +1,108 @@
+"""LLM-based prompt segmentation for specification ingestion."""
+import os
+import json
+from typing import List, Dict
+
+import requests
+from dotenv import load_dotenv
+
+
+# Constants for specification segmentation
+LLM_SYSTEM_PROMPT = """You convert WHAT/WHY product prompts into JSONL "memories".
+Fields: kind ∈ {vibe,spec,constraint,non_goal,metric,example,open_question}, title, content (≤ 8 lines), tags[], deps[].
+Rules: no implementation/tech details; one idea per memory; create open_question if info is missing; concise & reusable; tags from a small set like ["ux","photos","albums","a11y","perf"].
+Output JSONL only."""
+
+FALLBACK_MEMORIES = """
+{"kind": "spec", "title": "Photo album organization", "content": "Application organizes photos into separate albums", "tags": ["photos", "albums"], "deps": []}
+{"kind": "spec", "title": "Album date grouping", "content": "Albums are grouped by date", "tags": ["albums", "organization"], "deps": []}
+{"kind": "spec", "title": "Drag and drop reordering", "content": "Albums can be re-organized by dragging and dropping on the main page", "tags": ["ux", "albums"], "deps": []}
+{"kind": "constraint", "title": "Albums cannot be nested", "content": "Albums are never contained within other albums", "tags": ["albums", "constraint"], "deps": []}
+{"kind": "spec", "title": "Tiled photo previews", "content": "Within each album, photos are previewed in a tile-like interface", "tags": ["photos", "ux"], "deps": []}
+{"kind": "open_question", "title": "Tile size configuration", "content": "What should be the default tile size and can users customize it?", "tags": ["ux", "photos"], "deps": []}
+""".strip()
+
+
+class SpecificationSegmenter:
+    """Segments prompts into atomic memory specifications using LLM."""
+
+    def __init__(self, api_key: str = None, model: str = None):
+        """
+        Initialize specification segmenter.
+
+        Args:
+            api_key: Fireworks API key. If not provided, reads from FIREWORKS_API_KEY env var.
+            model: Model to use. If not provided, reads from FIREWORKS_MODEL env var or uses default.
+        """
+        load_dotenv()
+        self.api_key = api_key or os.getenv("FIREWORKS_API_KEY")
+        self.model = model or os.getenv(
+            "FIREWORKS_MODEL", "accounts/fireworks/models/llama-v3p1-70b-instruct"
+        )
+
+    def segment_to_jsonl(self, prompt_text: str, tags: List[str]) -> str:
+        """
+        Segment prompt into JSONL memories using Fireworks AI LLM or fallback.
+
+        Args:
+            prompt_text: The specification prompt to segment.
+            tags: List of tags to suggest to the LLM.
+
+        Returns:
+            JSONL string containing segmented memories.
+        """
+        if not self.api_key:
+            # Return fallback memories
+            return FALLBACK_MEMORIES
+
+        try:
+            response = requests.post(
+                "https://api.fireworks.ai/inference/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": self.model,
+                    "messages": [
+                        {"role": "system", "content": LLM_SYSTEM_PROMPT},
+                        {
+                            "role": "user",
+                            "content": f"Tags to use: {', '.join(tags) if tags else 'derive appropriate tags'}\n\nPrompt:\n{prompt_text}",
+                        },
+                    ],
+                    "temperature": 0.7,
+                    "max_tokens": 2000,
+                },
+                timeout=30,
+            )
+            response.raise_for_status()
+            data = response.json()
+
+            # Extract the assistant's response
+            content = data["choices"][0]["message"]["content"]
+            return content.strip()
+
+        except Exception as e:
+            print(f"Warning: LLM segmentation failed: {e}")
+            print("Falling back to example memories")
+            return FALLBACK_MEMORIES
+
+    def parse_jsonl(self, jsonl_text: str) -> List[Dict]:
+        """
+        Parse JSONL text into list of dictionaries.
+
+        Args:
+            jsonl_text: JSONL formatted string.
+
+        Returns:
+            List of parsed JSON objects.
+        """
+        items = []
+        for line in jsonl_text.strip().split("\n"):
+            if line.strip():
+                try:
+                    items.append(json.loads(line))
+                except json.JSONDecodeError as e:
+                    print(f"Warning: Failed to parse JSONL line: {e}")
+        return items

src/schemas/__init__.py

@@ -0,0 +1,4 @@
+"""Schemas module for data models."""
+from .models import DecayModel, MetadataModel, SpecifySchema
+
+__all__ = ["DecayModel", "MetadataModel", "SpecifySchema"]

src/schemas/models.py

@@ -0,0 +1,45 @@
+"""Pydantic models for data validation."""
+from typing import List, Optional
+
+from bson import ObjectId
+from pydantic import BaseModel, Field
+
+
+class DecayModel(BaseModel):
+    """Model for memory decay parameters."""
+
+    lambda_: float = Field(..., alias="lambda")
+    pinned: bool
+
+    class Config:
+        populate_by_name = True
+
+
+class MetadataModel(BaseModel):
+    """Model for memory metadata."""
+
+    source: str
+    content_hash: str
+
+
+class SpecifySchema(BaseModel):
+    """Schema for specification/memory documents."""
+
+    memory_id: str
+    project_id: str
+    created_at: str  # ISO 8601 datetime string
+    author: str
+    kind: str
+    title: str
+    content: str
+    tags: List[str]
+    deps: List[str]
+    priority: float
+    decay: DecayModel
+    metadata: MetadataModel
+    embedding: Optional[List[float]] = None
+
+    class Config:
+        populate_by_name = True
+        arbitrary_types_allowed = True
+        json_encoders = {ObjectId: str}

vibe_engineering-0.1.7.dist-info/METADATA

@@ -0,0 +1,262 @@
+Metadata-Version: 2.4
+Name: vibe-engineering
+Version: 0.1.7
+Summary: Add your description here
+Home-page: https://github.com/vibeengineering/vibe-engineering
+Author: Vibe Engineering Team
+Author-email: team@vibeengineering.com
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: certifi>=2024.12.14
+Requires-Dist: fireworks-ai>=0.19.19
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: pymongo>=4.15.3
+Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: requests>=2.32.0
+Requires-Dist: rich>=14.2.0
+Requires-Dist: typer>=0.19.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-python
+
+# 🚀 Vibe Engineering CLI
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+> **AI-powered specification and memory management CLI for modern development teams**
+
+Vibe Engineering is a powerful command-line tool that helps development teams manage specifications, project knowledge, and development workflows using AI assistance. Built with VoyageAI embeddings and MongoDB vector search for intelligent document management.
+
+## ✨ Features
+
+- 🤖 **AI-Powered Specifications** - Generate detailed specs using advanced LLMs
+- 🧠 **Memory Management** - Store and retrieve project knowledge with vector search
+- 👥 **Team Collaboration** - Track team members and project ownership
+- 📊 **Rich CLI Experience** - Beautiful, interactive command-line interface
+- 🔍 **Vector Search** - Find relevant information using semantic similarity
+- 📝 **Multiple Formats** - Export specifications in JSON, YAML, and Markdown
+
+## 🚀 Quick Install
+
+### PowerShell (Windows)
+```powershell
+PowerShell -ExecutionPolicy Bypass -Command "iwr -useb https://raw.githubusercontent.com/vibeengineering/vibe-engineering/main/install.ps1 | iex"
+```
+
+### Bash (Linux/macOS)
+```bash
+curl -sSL https://raw.githubusercontent.com/vibeengineering/vibe-engineering/main/install.sh | bash
+```
+
+### Manual Installation
+```bash
+# Clone the repository
+git clone https://github.com/vibeengineering/vibe-engineering.git
+cd vibe-engineering
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Install the CLI
+pip install -e .
+
+# Setup configuration
+cp .env.dist .env
+# Edit .env with your API keys
+```
+
+## ⚙️ Configuration
+
+1. **Copy environment template:**
+   ```bash
+   cp .env.dist .env
+   ```
+
+2. **Configure your API keys in `.env`:**
+   ```bash
+   # VoyageAI Configuration
+   VOYAGE_API_KEY=your_voyage_api_key_here
+   VOYAGE_MODEL=voyage-2
+
+   # MongoDB Configuration
+   MONGODB_URI=your_mongodb_connection_string
+   MONGO_DB=your_database_name
+   MONGO_COLLECTION=memories
+
+   # Fireworks AI Configuration
+   FIREWORKS_API_KEY=your_fireworks_api_key_here
+   FIREWORKS_MODEL=accounts/fireworks/models/llama-v3p1-70b-instruct
+   ```
+
+## 📖 Usage
+
+### Basic Commands
+
+```bash
+# Show system status
+vibe status
+
+# Display team members
+vibe team
+
+# Generate AI specification
+vibe specify "Create a user authentication system"
+
+# Show version
+vibe version
+
+# Get help
+vibe --help
+```
+
+### Advanced Usage
+
+```bash
+# Generate specification with options
+vibe specify "Add payment processing" --format json --save --verbose
+
+# Custom output formats
+vibe specify "User dashboard" --format markdown
+
+# Save specification to database
+vibe specify "API rate limiting" --save
+```
+
+## 📋 Commands Reference
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `vibe status` | 🔍 Show system status and configuration | `vibe status` |
+| `vibe team` | 👥 Display team members from database | `vibe team` |
+| `vibe specify` | ✨ Generate AI-powered specifications | `vibe specify "Add user auth"` |
+| `vibe version` | 📦 Show version information | `vibe version` |
+
+### Specify Command Options
+
+```bash
+vibe specify PROMPT [OPTIONS]
+
+Options:
+  -f, --format     Output format: json, yaml, markdown (default: json)
+  -s, --save       Save specification to database
+  -v, --verbose    Show detailed output
+  --help           Show help message
+```
+
+## 🏗️ Architecture
+
+```
+├── src/
+│   ├── cli/           # Command-line interface
+│   ├── db/            # Database operations (MongoDB)
+│   ├── llm/           # LLM clients (Fireworks, VoyageAI)
+│   └── schemas/       # Data models and schemas
+├── install.ps1        # PowerShell installer
+├── install.sh         # Bash installer
+├── setup.py          # Python package setup
+└── requirements.txt   # Dependencies
+```
+
+## 🛠️ Development
+
+### Prerequisites
+- Python 3.10+
+- MongoDB (Atlas or local)
+- VoyageAI API key
+- Fireworks AI API key
+
+### Setup Development Environment
+
+```bash
+# Clone repository
+git clone https://github.com/vibeengineering/vibe-engineering.git
+cd vibe-engineering
+
+# Install development dependencies
+pip install -r requirements-dev.txt
+
+# Install in development mode
+pip install -e .
+
+# Run tests
+pytest
+
+# Format code
+black .
+
+# Type checking
+mypy src/
+```
+
+### Running Locally
+
+```bash
+# Run CLI directly
+python -m src.cli --help
+
+# Or use the installed command
+vibe --help
+```
+
+## 🔧 Configuration Options
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `VOYAGE_API_KEY` | VoyageAI API key for embeddings | Required |
+| `VOYAGE_MODEL` | VoyageAI model to use | `voyage-2` |
+| `MONGODB_URI` | MongoDB connection string | Required |
+| `MONGO_DB` | Database name | `master` |
+| `MONGO_COLLECTION` | Collection name | `memories` |
+| `FIREWORKS_API_KEY` | Fireworks AI API key | Required |
+| `FIREWORKS_MODEL` | Fireworks model to use | `llama-v3p1-70b-instruct` |
+
+## 🚦 System Requirements
+
+- **Python**: 3.10 or higher
+- **Memory**: 512MB RAM minimum
+- **Storage**: 100MB free space
+- **Network**: Internet connection for AI APIs
+- **Database**: MongoDB Atlas or local MongoDB instance
+
+## 📚 Documentation
+
+- [Installation Guide](./docs/installation.md)
+- [Configuration Reference](./docs/configuration.md)
+- [API Documentation](./docs/api.md)
+- [Contributing Guide](./CONTRIBUTING.md)
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](./CONTRIBUTING.md) for details.
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
+
+## 🆘 Support
+
+- 📧 Email: support@vibeengineering.com
+- 💬 GitHub Issues: [Create an issue](https://github.com/vibeengineering/vibe-engineering/issues)
+- 📖 Documentation: [Read the docs](https://docs.vibeengineering.com)
+
+## 🙏 Acknowledgments
+
+- Built with [Typer](https://typer.tiangolo.com/) for the CLI framework
+- Powered by [VoyageAI](https://www.voyageai.com/) for embeddings
+- Uses [Fireworks AI](https://fireworks.ai/) for LLM capabilities
+- Styled with [Rich](https://rich.readthedocs.io/) for beautiful terminal output
+
+---
+
+**Made with ❤️ by the Vibe Engineering Team**

vibe_engineering-0.1.7.dist-info/RECORD

@@ -0,0 +1,16 @@
+src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/cli/__init__.py,sha256=jJ7tHuLwJcPDuk45xRuu8xbMBQL45k5oZ6EcNa9MD8k,94
+src/cli/commands.py,sha256=dlZoLSR9n4InbdeAXJXxKmATMGOwLW70ylXlBIJ_808,7885
+src/db/__init__.py,sha256=zrfEUYNVRhGAq0DgIWBkxoM8L0jJNgy1_GhtBVJvhYA,470
+src/db/client.py,sha256=a-KZDyJjUWB1y15p1pxPn_q8UPDLVtOSvidx8XvULlU,1741
+src/db/operations.py,sha256=nJ2AJrYOaOi9L8ZJgQjr4eukKbr2al0tFls83S8M8GY,4881
+src/llm/__init__.py,sha256=LLtIL6wbsmZ2MAs9u34K84pMu_keg6X-HccCZzinPlQ,247
+src/llm/client.py,sha256=5daBZrf4sZ8_9OBFEsWWNoEMvctupDRWxheS3rXWJAw,2542
+src/llm/embeddings.py,sha256=wH-aihD6HfkJtUn4TJGpqLz9BYnX5i0SyRT0tf8hb2E,2987
+src/llm/segmentation.py,sha256=zex5Elfk_ph0nFFzszxtagN6o1SmTu1BsHJ9W9Njlb0,4753
+src/schemas/__init__.py,sha256=rdw4M8Gm95XN5sPgfReQO0WLePty-OE-4OYjSFrGlBM,163
+src/schemas/models.py,sha256=aIO8qtG0gdL6pWc0cyhYC1jqevpNIfkOQJYSA3Lc_Ew,1011
+vibe_engineering-0.1.7.dist-info/METADATA,sha256=4qsfe3zn4Ln8TQ3l6z17azo6i9Pn4zW9jrJGbI48n98,7650
+vibe_engineering-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vibe_engineering-0.1.7.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+vibe_engineering-0.1.7.dist-info/RECORD,,

vibe_engineering-0.1.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vibe_engineering-0.1.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+src