calcullm.py

"""
CalcuLLM - AI Assistant for LibreOffice Calc

Supports multiple AI providers: Claude (Anthropic), Venice.ai
"""

import sys
import os

# Logging to file for debugging
LOG_FILE = os.path.expanduser("~/calcullm-debug.log")

def log(msg):
    try:
        with open(LOG_FILE, "a") as f:
            f.write(f"{msg}\n")
    except:
        pass

log("=" * 50)
log("CalcuLLM Extension Loading")
log(f"Python version: {sys.version}")
log(f"__file__: {__file__}")

# Add pythonpath to sys.path for imports
extension_path = os.path.dirname(__file__)
pythonpath = os.path.join(extension_path, "pythonpath")
if pythonpath not in sys.path:
    sys.path.insert(0, pythonpath)
log(f"Added to path: {pythonpath}")

import unohelper
from com.sun.star.ui import XUIElementFactory, XUIElement
from com.sun.star.lang import XComponent

log("Imports successful")


def get_property_value(args, name, default=None):
    """Extract a property value from UNO args tuple."""
    for arg in args:
        if hasattr(arg, 'Name') and arg.Name == name:
            return arg.Value
    return default


class ToolPanelUIElement(unohelper.Base, XUIElement, XComponent):
    """
    Wrapper that implements XUIElement around an XToolPanel.
    This is what createUIElement must return.
    """

    def __init__(self, resource_url, frame, tool_panel):
        log("ToolPanelUIElement.__init__")
        self.resource_url = resource_url
        self.frame = frame
        self.tool_panel = tool_panel
        self.listeners = []

    # XUIElement interface
    def getFrame(self):
        log("ToolPanelUIElement.getFrame called")
        return self.frame

    def getResourceURL(self):
        log("ToolPanelUIElement.getResourceURL called")
        return self.resource_url

    def getType(self):
        log("ToolPanelUIElement.getType called")
        # UIElementType.TOOLPANEL = 7
        return 7

    def getRealInterface(self):
        log("ToolPanelUIElement.getRealInterface called")
        return self.tool_panel

    # XComponent interface
    def dispose(self):
        log("ToolPanelUIElement.dispose called")
        for listener in self.listeners:
            try:
                listener.disposing(self)
            except:
                pass
        self.listeners = []

    def addEventListener(self, listener):
        self.listeners.append(listener)

    def removeEventListener(self, listener):
        if listener in self.listeners:
            self.listeners.remove(listener)


class PanelFactory(unohelper.Base, XUIElementFactory):
    """Factory that creates AI sidebar panels."""

    def __init__(self, ctx):
        log("PanelFactory.__init__ called")
        self.ctx = ctx

    def createUIElement(self, resource_url, args):
        """Create a new panel instance."""
        log(f"createUIElement called with URL: {resource_url}")
        log(f"Args count: {len(args) if args else 0}")

        for i, arg in enumerate(args):
            if hasattr(arg, 'Name'):
                log(f"  Arg {i}: {arg.Name} = {type(arg.Value)}")

        if "CalcuLLMPanel" not in resource_url:
            log("URL doesn't contain CalcuLLMPanel, returning None")
            return None

        frame = get_property_value(args, "Frame")
        parent_window = get_property_value(args, "ParentWindow")

        log(f"Frame: {frame}")
        log(f"ParentWindow: {parent_window}")

        if parent_window is None:
            log("ParentWindow is None, returning None")
            return None

        try:
            log("Attempting to import AIToolPanel...")
            from calcullm.panel import AIToolPanel
            log("Import successful, creating panel...")
            tool_panel = AIToolPanel(self.ctx, frame, parent_window)
            log(f"ToolPanel created: {tool_panel}")
            log(f"ToolPanel.getWindow(): {tool_panel.getWindow()}")

            # Wrap in XUIElement
            log("Creating ToolPanelUIElement wrapper...")
            ui_element = ToolPanelUIElement(resource_url, frame, tool_panel)
            log(f"UIElement created: {ui_element}")
            return ui_element

        except Exception as e:
            log(f"ERROR creating panel: {e}")
            import traceback
            log(traceback.format_exc())
            return None


log("Registering PanelFactory...")

# Register the implementation with LibreOffice
g_ImplementationHelper = unohelper.ImplementationHelper()

g_ImplementationHelper.addImplementation(
    PanelFactory,
    "org.calcullm.PanelFactory",
    ("com.sun.star.ui.UIElementFactory",)
)

log("Registration complete")