mfcli 0.2.1__py3-none-any.whl

mfcli/mcp/state_manager.py

@@ -0,0 +1,51 @@
+"""State manager for MCP server to persist state between calls."""
+import json
+from pathlib import Path
+from typing import Optional
+
+from mfcli.utils.directory_manager import app_dirs
+
+
+class MCPStateManager:
+    """Manages persistent state for the MCP server."""
+    
+    def __init__(self):
+        state_dir = Path(app_dirs.app_data_dir)
+        try:
+            state_dir.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            # If we can't create the directory, we'll operate with in-memory state only.
+            pass
+        self.state_file = state_dir / "mcp_state.json"
+        self._state = self._load_state()
+    
+    def _load_state(self) -> dict:
+        """Load state from disk."""
+        if self.state_file.exists():
+            try:
+                with open(self.state_file, 'r') as f:
+                    return json.load(f)
+            except Exception:
+                return {}
+        return {}
+    
+    def _save_state(self):
+        """Save state to disk."""
+        try:
+            with open(self.state_file, 'w') as f:
+                json.dump(self._state, f, indent=2)
+        except Exception:
+            pass  # Silently fail if we can't save state
+    
+    def get_last_project_name(self) -> Optional[str]:
+        """Get the last used project name."""
+        return self._state.get('last_project_name')
+    
+    def set_last_project_name(self, project_name: str):
+        """Set the last used project name."""
+        self._state['last_project_name'] = project_name
+        self._save_state()
+
+
+# Singleton instance
+state_manager = MCPStateManager()

mfcli/mcp/tools/query_knowledgebase.py

@@ -0,0 +1,108 @@
+import chromadb
+from chromadb.utils import embedding_functions
+from typing import Annotated, Optional
+
+from mfcli.crud.project import get_project_by_name
+from mfcli.mcp.mcp_instance import mcp
+from mfcli.mcp.state_manager import state_manager
+from mfcli.utils.config import get_config
+from mfcli.utils.directory_manager import app_dirs
+from mfcli.utils.orm import Session
+
+
+def get_chroma_index(index_name: str):
+    config = get_config()
+    chroma_client = chromadb.PersistentClient(path=app_dirs.chroma_db_dir)
+    openai_ef = embedding_functions.OpenAIEmbeddingFunction(
+        api_key=config.openai_api_key,
+        model_name=config.embedding_model
+    )
+    return chroma_client.get_collection(index_name, embedding_function=openai_ef)
+
+
+def get_index_id_for_project_name(project_name: str):
+    with Session() as db:
+        project = get_project_by_name(db, project_name)
+        return project.index_id
+
+
+@mcp.tool()
+def query_local_rag(
+    query: Annotated[str, "Search query for engineering documentation (e.g., 'IEC 61000-4-2', 'power management')"],
+    project_name: Annotated[Optional[str], "The name of the project. RECOMMENDED: Provide this parameter even though it's optional. The project name can be found in the config.json file located in the .multifactor folder. If not provided, uses the last known project name."] = None,
+    n_results: Annotated[int, "Number of results to return (1-20, default: 8)"] = 8,
+    task_progress: Annotated[Optional[str], "A checklist showing task progress after this tool use is completed"] = None
+) -> dict:
+    """Query local hardware engineering documentation.
+
+    Use this tool to search for engineering documentation, design patterns,
+    technical specifications, and best practices from the local knowledge base.
+
+    Args:
+        query: Search query for engineering documentation (e.g., "IEC 61000-4-2", "power management")
+        project_name: RECOMMENDED - The name of the project. Although optional, it is recommended to provide this parameter. 
+                     The project name can be found in the config.json file located in the .multifactor folder. 
+                     If not provided, uses the last known project name.
+        n_results: Number of results to return (1-20, default: 8)
+        task_progress: A checklist showing task progress after this tool use is completed
+
+    Returns:
+        Dictionary containing:
+        - documents: List of text chunks matching the query
+        - metadatas: Metadata for each document
+        - distances: Similarity distances (lower is more similar)
+        - count: Number of results returned
+        - chromadb_path: Path to the ChromaDB database
+        - project_name: The project name that was used for the query
+    """
+    
+    # If project_name is not provided, use the last known project name
+    if project_name is None:
+        project_name = state_manager.get_last_project_name()
+        if project_name is None:
+            return {
+                "error": "No project name provided and no previous project name found. Please provide a project_name parameter. The project name can be found in the config.json file located in the .multifactor folder.",
+                "documents": [],
+                "metadatas": [],
+                "distances": [],
+                "count": 0,
+                "chromadb_path": app_dirs.chroma_db_dir,
+                "project_name": None
+            }
+    
+    # Store the project name for future use
+    state_manager.set_last_project_name(project_name)
+    
+    collection = get_chroma_index(get_index_id_for_project_name(project_name))
+
+    # Clamp n_results between 1 and 20
+    n_results = min(max(n_results, 1), 20)
+
+    try:
+        results = collection.query(
+            query_texts=[query],
+            n_results=n_results
+        )
+
+        documents = results["documents"][0] if results["documents"] else []
+        metadatas = results["metadatas"][0] if results["metadatas"] else []
+        distances = results["distances"][0] if results["distances"] else []
+
+        return {
+            "documents": documents,
+            "metadatas": metadatas,
+            "distances": distances,
+            "count": len(documents),
+            "chromadb_path": app_dirs.chroma_db_dir,
+            "project_name": project_name
+        }
+    except Exception as e:
+        return {
+            "error": str(e),
+            "documents": [],
+            "metadatas": [],
+            "distances": [],
+            "count": 0,
+            "chromadb_path": app_dirs.chroma_db_dir,
+            "project_name": project_name
+        }

mfcli/models/__init__.py

@@ -0,0 +1,10 @@
+from mfcli.models.file import File
+from mfcli.models.pdf_parts import PDFPart
+from mfcli.models.pipeline_run import PipelineRun
+from mfcli.models.bom import BOM
+from mfcli.models.datasheet import Datasheet
+from mfcli.models.netlist import Netlist
+from mfcli.models.netlist import NetlistPin
+from mfcli.models.netlist import NetlistComponent
+from mfcli.models.project import Project
+from mfcli.models.functional_blocks import FunctionalBlock, FunctionalBlockComponent

mfcli/models/base.py

@@ -0,0 +1,10 @@
+from sqlalchemy.orm import declarative_base, configure_mappers
+from sqlmodel import SQLModel
+
+Base = declarative_base()
+
+import mfcli.models
+
+configure_mappers()
+
+target_metadata = SQLModel.metadata

mfcli/models/bom.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+from sqlalchemy import Column, func, TIMESTAMP
+
+from mfcli.models.file import File
+
+from sqlmodel import SQLModel, Field, Relationship
+from typing import Optional
+
+
+class BOMSchema(BaseModel):
+    # Required core fields
+    reference: str = Field(..., description="Reference designators (C1, R3, U2, etc.)")
+    value: str = Field(..., description="Electrical value or part name (10kΩ, MSPM0L1306)")
+    quantity: int = Field(..., description="Quantity of identical components")
+    description: str = Field(..., description="General text describing component")
+
+    # Optional fields
+    manufacturer: Optional[str] = Field(None, description="Manufacturer name")
+    mpn: Optional[str] = Field(None, description="Manufacturer part number")
+    lifecycle_status: Optional[str] = Field(None, description="Maturity (Active / NRND / Obsolete)")
+    supplier: Optional[str] = Field(None, description="Distributor / supplier")
+    supplier_part: Optional[str] = Field(None, description="Supplier SKU or catalog number")
+    supplier_unit_price: Optional[float] = Field(None, description="Unit cost")
+    supplier_subtotal: Optional[float] = Field(None, description="Quantity × unit cost")
+    revision_id: Optional[str] = Field(None, description="Design revision identifier")
+    revision_state: Optional[str] = Field(None, description="Engineering state (Released / Draft)")
+    revision_status: Optional[str] = Field(None, description="Workflow status (Approved / Pending)")
+
+
+class BOM(SQLModel, table=True):
+    __tablename__ = "bom"
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    file_id: int = Field(
+        foreign_key="files.id",
+        index=True,
+        nullable=False,
+        ondelete="CASCADE"
+    )
+
+    # Relationship
+    file: Optional["File"] = Relationship()
+
+    # Required core fields
+    reference: str = Field(max_length=100, nullable=False)
+    value: str = Field(max_length=255, nullable=False)
+    quantity: int = Field(nullable=False)
+    description: str = Field(max_length=600, nullable=False)
+
+    # Optional fields
+    manufacturer: Optional[str] = Field(default=None, max_length=255)
+    mpn: Optional[str] = Field(default=None, max_length=255)
+    lifecycle_status: Optional[str] = Field(default=None, max_length=50)
+    supplier: Optional[str] = Field(default=None, max_length=255)
+    supplier_part: Optional[str] = Field(default=None, max_length=255)
+    supplier_unit_price: Optional[float] = Field(default=None)
+    supplier_subtotal: Optional[float] = Field(default=None)
+    revision_id: Optional[str] = Field(default=None, max_length=50)
+    revision_state: Optional[str] = Field(default=None, max_length=50)
+    revision_status: Optional[str] = Field(default=None, max_length=100)
+    datasheet: Optional[str] = Field(default=None, nullable=True, max_length=500)
+
+    # Timestamps
+    created_at: datetime = Field(
+        sa_column=Column(TIMESTAMP(timezone=True), server_default=func.now(), nullable=False)
+    )
+    updated_at: datetime = Field(
+        sa_column=Column(TIMESTAMP(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False)
+    )

mfcli/models/datasheet.py

@@ -0,0 +1,10 @@
+from typing import Optional
+
+from sqlmodel import SQLModel, Field
+
+
+class Datasheet(SQLModel, table=True):
+    __tablename__ = "datasheets"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    part_number: str = Field(index=True, nullable=False, max_length=100, unique=False)
+    datasheet: str = Field(index=True, nullable=False, max_length=500, unique=False)

mfcli/models/debug_setup.py

@@ -0,0 +1,64 @@
+from typing import Dict, List, Any
+
+from pydantic import BaseModel, Field
+
+
+class DebugInterface(BaseModel):
+    """Debug interface configuration from schematic."""
+    interface_type: str = Field(..., description="Debug interface type: JTAG, SWD, ICSP, etc.")
+    pin_count: int = Field(0, description="Number of pins in debug connector")
+    pin_mapping: Dict[str, str] = Field(default_factory=dict,
+                                        description="Pin number to signal mapping (e.g., {'1': 'VCC', '2': 'SWDIO'})")
+    connector_type: str = Field("", description="Physical connector type (e.g., 10-pin Cortex, 20-pin JTAG)")
+    voltage_level: str = Field("", description="Target voltage level (3.3V, 5V, etc.)")
+
+
+class DebugTool(BaseModel):
+    """Recommended debug tool/probe."""
+    name: str = Field(..., description="Tool name (e.g., J-Link, ST-Link, CMSIS-DAP)")
+    model: str = Field("", description="Specific model recommendation")
+    purchase_links: List[str] = Field(default_factory=list, description="Where to buy")
+    compatibility_notes: str = Field("", description="Why this tool is recommended")
+    alternative_tools: List[str] = Field(default_factory=list, description="Alternative compatible tools")
+
+
+class DriverInfo(BaseModel):
+    """Driver installation information."""
+    windows: Dict[str, Any] = Field(default_factory=dict,
+                                    description="Windows driver info: download_url, installation_steps")
+    linux: Dict[str, Any] = Field(default_factory=dict,
+                                  description="Linux driver info: package_name, installation_steps")
+    macos: Dict[str, Any] = Field(default_factory=dict, description="macOS driver info (optional)")
+
+
+class VSCodeLaunchConfig(BaseModel):
+    """VS Code launch.json configuration."""
+    configuration_name: str = Field(..., description="Name for this configuration")
+    configuration_type: str = Field(..., description="Debugger type: cortex-debug, cppdbg, etc.")
+    launch_json: Dict[str, Any] = Field(default_factory=dict, description="Complete launch.json configuration")
+    extensions_required: List[str] = Field(default_factory=list, description="Required VS Code extensions")
+    setup_notes: str = Field("", description="Additional setup notes")
+
+
+class GDBServerConfig(BaseModel):
+    """GDB server configuration."""
+    server_name: str = Field(..., description="GDB server name (e.g., JLinkGDBServer, OpenOCD)")
+    command_line: str = Field("", description="Command to start GDB server")
+    config_file: str = Field("", description="Configuration file content or path")
+    port: int = Field(3333, description="GDB server port")
+
+
+class DSTargetMCU(BaseModel):
+    target_mcu: str = Field(..., description="Target MCU from schematic")
+
+
+class DSAdditionalTools(BaseModel):
+    additional_tools: List[str] = Field(default_factory=list, description="Additional helpful tools")
+
+
+class DSTroubleshootingGuide(BaseModel):
+    troubleshooting: List[str] = Field(default_factory=list, description="Common issues and solutions")
+
+
+class DSQuickStartGuide(BaseModel):
+    quick_start_guide: List[str] = Field(default_factory=list, description="Step-by-step quick start")

mfcli/models/file.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+from typing import Optional, List
+
+from sqlalchemy import func, UniqueConstraint, Column, DateTime
+from sqlmodel import SQLModel, Field, Relationship
+
+from mfcli.models.pipeline_run import PipelineRun
+
+
+class File(SQLModel, table=True):
+    __tablename__ = "files"
+
+    __table_args__ = (
+        UniqueConstraint("md5", "pipeline_run_id", name="uq_file_md5_pipeline_run"),
+    )
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    pipeline_run_id: int = Field(
+        foreign_key="pipeline_runs.id",
+        index=True,
+        nullable=False,
+        ondelete="CASCADE"
+    )
+    pipeline_run: Optional["PipelineRun"] = Relationship()
+    pdf_parts: List["PDFPart"] = Relationship(back_populates='file', cascade_delete=True)
+
+    name: str = Field(max_length=255, nullable=False, index=True)
+    type: int = Field(nullable=False, index=True)
+    sub_type: Optional[int] = Field(default=None, index=True)
+    mime_type: str = Field(max_length=255, nullable=False)
+    md5: str = Field(max_length=32, nullable=False, index=True)
+    ext: str = Field(max_length=10, min_length=2, index=True, nullable=True)
+    path: str = Field(max_length=600, nullable=True)
+    gemini_file_id: str = Field(max_length=40, nullable=True)
+    is_datasheet: int = Field(default=0, nullable=False, index=True)
+
+    # Database-managed timestamps
+    created_at: datetime = Field(
+        sa_column=Column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+    )
+    updated_at: datetime = Field(
+        sa_column=Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False)
+    )

mfcli/models/file_docket.py

@@ -0,0 +1,94 @@
+import json
+from pathlib import Path
+from typing import List, Dict, Optional
+
+from pydantic import BaseModel, Field
+
+
+class FileDocketEntry(BaseModel):
+    name: str
+    path: str
+    vectorize: bool
+    sub_type: str
+    md5: str | None = Field(default=None)
+    is_datasheet: bool = Field(default=False)
+
+
+class FileDocketEntries(BaseModel):
+    entries: List[FileDocketEntry] = Field(default_factory=list)
+
+    def add(self, entry: FileDocketEntry):
+        self.entries.append(entry)
+
+
+class FileDocket:
+    def __init__(self):
+        self._docket = FileDocketEntries()
+        self._md5_entry_map: Dict[str, FileDocketEntry] = {}
+        self._path_entry_map: Dict[str, FileDocketEntry] = {}
+
+    def add(self, entry: FileDocketEntry):
+        self._docket.add(entry)
+        if entry.md5:
+            self._md5_entry_map[entry.md5] = entry
+        # Use normalized path as key (convert to lowercase for case-insensitive comparison on Windows)
+        normalized_path = Path(entry.path).as_posix().lower()
+        self._path_entry_map[normalized_path] = entry
+
+    def get_by_md5(self, md5: str) -> Optional[FileDocketEntry]:
+        return self._md5_entry_map.get(md5)
+    
+    def get_by_path(self, path: str) -> Optional[FileDocketEntry]:
+        normalized_path = Path(path).as_posix().lower()
+        return self._path_entry_map.get(normalized_path)
+
+    def remove(self, entry: FileDocketEntry):
+        """Remove an entry from the docket"""
+        if entry in self._docket.entries:
+            self._docket.entries.remove(entry)
+        if entry.md5 and entry.md5 in self._md5_entry_map:
+            del self._md5_entry_map[entry.md5]
+        normalized_path = Path(entry.path).as_posix().lower()
+        if normalized_path in self._path_entry_map:
+            del self._path_entry_map[normalized_path]
+
+    def load_from_json(self, json_path: Path):
+        """Load existing file docket from JSON file"""
+        if not json_path.exists():
+            return
+        
+        try:
+            with open(json_path, 'r') as f:
+                data = json.load(f)
+            
+            # Convert the saved format back to entries
+            all_entries = []
+            for category in ['hw_files', 'datasheets', 'cheat_sheets']:
+                if category in data:
+                    all_entries.extend(data[category])
+            
+            # Create FileDocketEntry objects and add them
+            for entry_data in all_entries:
+                entry = FileDocketEntry(**entry_data)
+                self.add(entry)
+                
+        except Exception as e:
+            # If there's an error loading, just start fresh
+            print(f"Warning: Could not load existing file_docket.json: {e}")
+
+    def get_entries(self) -> Dict:
+        datasheets = []
+        cheat_sheets = []
+        hw_files = []
+        for entry in self._docket.entries:
+            if entry.is_datasheet:
+                datasheets.append(entry.model_dump())
+            elif entry.sub_type == "CHEAT_SHEET":
+                cheat_sheets.append(entry.model_dump())
+            else:
+                hw_files.append(entry.model_dump())
+        return {
+            "hw_files": hw_files,
+            "datasheets": datasheets,
+            "cheat_sheets": cheat_sheets
+        }

mfcli/models/file_metadata.py

@@ -0,0 +1,19 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from mfcli.constants.file_types import FileSubtypes, FileTypes
+
+
+class FileMetadata(BaseModel):
+    name: str
+    size: int
+    md5: str
+    path: str
+    mime: str
+    ext: str
+    type_id: FileTypes
+    type_name: str
+    subtype_id: Optional[FileSubtypes] = Field(None)
+    subtype_name: Optional[str] = Field(None)
+    is_datasheet: bool

mfcli/models/functional_blocks.py

@@ -0,0 +1,94 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+from sqlmodel import SQLModel, Field as DBField, Relationship
+
+from mfcli.models.pipeline_run import PipelineRun
+
+
+# DB Models
+
+class FunctionalBlock(SQLModel, table=True):
+    __tablename__ = 'functional_blocks'
+    id: Optional[int] = DBField(default=None, primary_key=True)
+    pipeline_run_id: int = DBField(
+        foreign_key="pipeline_runs.id",
+        index=True,
+        nullable=False,
+        ondelete="CASCADE"
+    )
+    pipeline_run: Optional["PipelineRun"] = Relationship()
+    name: str = DBField(max_length=255, nullable=False, index=True)
+    description: str = DBField(nullable=False)
+    components: List["FunctionalBlockComponent"] = Relationship(back_populates='functional_block', cascade_delete=True)
+
+
+class FunctionalBlockComponent(SQLModel, table=True):
+    __tablename__ = 'functional_block_components'
+    id: Optional[int] = DBField(default=None, primary_key=True)
+    functional_block_id: int = DBField(
+        foreign_key="functional_blocks.id",
+        index=True,
+        nullable=False,
+        ondelete="CASCADE"
+    )
+    functional_block: Optional["FunctionalBlock"] = Relationship(back_populates='components')
+    ref: str = DBField(max_length=45, nullable=False)
+
+
+class FunctionalBlocks(BaseModel):
+    functional_blocks: list[str] = Field(..., description="Names of functional blocks")
+
+
+# Pydantic models
+
+class PinInfo(BaseModel):
+    """Represents pin configuration information."""
+    pin_number: str = Field(..., description="Pin number or identifier")
+    pin_name: str = Field(..., description="Pin name or signal name")
+    direction: str = Field("", description="Pin direction: input, output, bidirectional, power, ground")
+    pull_config: str = Field("", description="Pull-up/pull-down configuration: pull-up, pull-down, none, external")
+    voltage_level: str = Field("", description="Voltage level (e.g., 3.3V, 5V, 1.8V)")
+    function: str = Field("", description="Pin function description")
+    connected_to: str = Field("", description="What this pin connects to")
+    alternate_functions: List[str] = Field(default_factory=list, description="Alternative pin functions")
+
+
+class ConnectorInfo(BaseModel):
+    """Represents connector information."""
+    connector_ref: str = Field(..., description="Connector reference designator (e.g., J1, P2)")
+    connector_type: str = Field("", description="Connector type (e.g., USB-C, JST-XH, header)")
+    pin_count: int = Field(0, description="Number of pins in connector")
+    pins: List[PinInfo] = Field(default_factory=list, description="Pin information for connector")
+    description: str = Field("", description="Connector description and purpose")
+
+
+class FunctionalBlockMeta(BaseModel):
+    name: str = Field(..., description="Name of the functional block (e.g., 'Power Supply', 'USB Interface')")
+    description: str = Field(..., description="Detailed description of what this block does")
+    components: List[str] = Field(default_factory=list, description="Reference designators of components in this block")
+
+
+class FBPins(BaseModel):
+    pins: List[PinInfo] = Field(default_factory=list, description="Pin information for this functional block")
+
+
+class FBConnectors(BaseModel):
+    connectors: List[ConnectorInfo] = Field(default_factory=list, description="Connectors associated with this block")
+
+
+class FBVoltageRails(BaseModel):
+    voltage_rails: List[str] = Field(default_factory=list,
+                                     description="Voltage rails used by this block (e.g., 3.3V, 5V)")
+
+
+class FBInitializationNotes(BaseModel):
+    initialization_notes: str = Field("", description="Notes on how to initialize/configure this block in firmware")
+
+
+class FBDependencies(BaseModel):
+    dependencies: List[str] = Field(default_factory=list, description="Other functional blocks this depends on")
+
+
+class FBFirmwareRequirements(BaseModel):
+    firmware_requirements: str = Field("", description="Key firmware requirements for this block")

mfcli/models/llm_response.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class LLMResponse(BaseModel):
+    text: str