Upload 193 files

app.py

@@ -1,5 +1,34 @@
 import os
+import asyncio
+from pathlib import Path
 from openspace.dashboard_server import create_app
+from openspace.skill_engine.registry import SkillRegistry
+from openspace.skill_engine.store import SkillStore
+
+def sync_local_skills():
+    try:
+        print("Starting local skill sync...")
+        registry = SkillRegistry()
+        skill_dir = Path(__file__).resolve().parent / "skills"
+        if skill_dir.exists() and skill_dir.is_dir():
+            added = registry.discover_from_dirs([skill_dir])
+            if added:
+                store = SkillStore()
+                # Run the async sync method in a synchronous context
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                count = loop.run_until_complete(store.sync_from_registry(added))
+                loop.close()
+                print(f"Successfully synced {count} skills from {skill_dir} into database.")
+            else:
+                print("No skills discovered in directory.")
+        else:
+            print(f"Skill directory not found at {skill_dir}")
+    except Exception as e:
+        print(f"Error syncing local skills: {e}")
+
+# Run sync before creating the app
+sync_local_skills()
 
 app = create_app()
 

openspace/dashboard_server.py

@@ -234,8 +234,18 @@ def create_app() -> Flask:
         if not stage_dir.exists():
             abort(404, description="Artifact not found")
             
-        # The skill folder name should ideally be the skill name
-        skill_name = data.get("name", artifact_id)
+        from openspace.skill_engine.skill_utils import parse_frontmatter
+        skill_file = stage_dir / "SKILL.md"
+        if not skill_file.exists():
+            abort(400, description="Missing SKILL.md")
+        
+        try:
+            content = skill_file.read_text(encoding="utf-8")
+            fm = parse_frontmatter(content)
+            skill_name = fm.get("name", artifact_id)
+        except Exception:
+            skill_name = artifact_id
+            
         final_dir = PROJECT_ROOT / "skills" / skill_name
         
         # If final_dir exists, we might need to overwrite or abort
@@ -260,21 +270,68 @@ def create_app() -> Flask:
             
         store = _get_store()
         
+        from openspace.skill_engine.types import SkillRecord, SkillLineage, SkillOrigin, SkillVisibility
+        from openspace.skill_engine.patch import collect_skill_snapshot, compute_unified_diff
+        
+        try:
+            origin_val = data.get("origin", "imported").upper()
+            origin = SkillOrigin[origin_val]
+        except KeyError:
+            origin = SkillOrigin.IMPORTED
+            
+        try:
+            vis_val = data.get("visibility", "public").upper()
+            if vis_val == "GROUP_ONLY":
+                vis_val = "PRIVATE"
+            visibility = SkillVisibility[vis_val]
+        except KeyError:
+            visibility = SkillVisibility.PUBLIC
+            
+        snapshot = {}
+        content_diff = ""
+        try:
+            snapshot = collect_skill_snapshot(final_dir)
+            content_diff = "\n".join(
+                compute_unified_diff("", text, filename=name)
+                for name, text in sorted(snapshot.items())
+                if compute_unified_diff("", text, filename=name)
+            )
+        except Exception:
+            pass
+
+        record = SkillRecord(
+            skill_id=meta.skill_id,
+            name=meta.name,
+            description=meta.description,
+            path=str(meta.path),
+            is_active=True,
+            visibility=visibility,
+            tags=set(data.get("tags", [])),
+            lineage=SkillLineage(
+                origin=origin,
+                generation=0,
+                parent_skill_ids=data.get("parent_skill_ids", []),
+                content_snapshot=snapshot,
+                content_diff=content_diff,
+            ),
+        )
+        
         # Sync to DB
         import asyncio
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
         try:
-            loop.run_until_complete(store.sync_from_registry([meta]))
+            loop.run_until_complete(store.save_record(record))
         finally:
             loop.close()
             
         return jsonify({
             "status": "success",
+            "record_id": meta.skill_id,
             "skill_id": meta.skill_id,
             "name": meta.name,
             "local_path": str(final_dir)
-        })
+        }), 201
 
     @app.route(f"{API_PREFIX}/workflows", methods=["GET"])
     def list_workflows() -> Any:

openspace/skill_engine/store.py

@@ -13,8 +13,7 @@ from __future__ import annotations
 
 import asyncio
 import json
-import os
-import libsql_experimental as sqlite3
+import sqlite3
 import threading
 import time
 from contextlib import contextmanager
@@ -58,26 +57,19 @@ def _db_retry(
             for attempt in range(max_retries):
                 try:
                     return func(*args, **kwargs)
-                except Exception as exc:
-                    # libsql_experimental might not have standard sqlite3 exceptions
-                    # so we catch Exception and check if it's a known database error string
-                    exc_str = str(exc).lower()
-                    if "locked" in exc_str or "database error" in exc_str or "operational error" in exc_str:
-                        if attempt == max_retries - 1:
-                            logger.error(
-                                f"DB {func.__name__} failed after "
-                                f"{max_retries} retries: {exc}"
-                            )
-                            raise
-                        logger.warning(
-                            f"DB {func.__name__} retry {attempt + 1}"
-                            f"/{max_retries}: {exc}"
+                except (sqlite3.OperationalError, sqlite3.DatabaseError) as exc:
+                    if attempt == max_retries - 1:
+                        logger.error(
+                            f"DB {func.__name__} failed after "
+                            f"{max_retries} retries: {exc}"
                         )
-                        time.sleep(delay)
-                        delay *= backoff
-                    else:
-                        # If it's not a known transient error, raise immediately
                         raise
+                    logger.warning(
+                        f"DB {func.__name__} retry {attempt + 1}"
+                        f"/{max_retries}: {exc}"
+                    )
+                    time.sleep(delay)
+                    delay *= backoff
 
         return wrapper
 
@@ -173,69 +165,6 @@ CREATE TABLE IF NOT EXISTS skill_tags (
 """
 
 
-class _DictCursorWrapper:
-    def __init__(self, cursor):
-        self._cursor = cursor
-        
-    def __getattr__(self, name):
-        return getattr(self._cursor, name)
-        
-    def _dict_factory(self, row):
-        if row is None:
-            return None
-        if self._cursor.description is None:
-            return row
-        fields = [column[0] for column in self._cursor.description]
-        return {key: value for key, value in zip(fields, row)}
-        
-    def fetchone(self):
-        return self._dict_factory(self._cursor.fetchone())
-        
-    def fetchall(self):
-        rows = self._cursor.fetchall()
-        if not rows:
-            return []
-        return [self._dict_factory(row) for row in rows]
-        
-    def fetchmany(self, size=None):
-        rows = self._cursor.fetchmany(size) if size is not None else self._cursor.fetchmany()
-        if not rows:
-            return []
-        return [self._dict_factory(row) for row in rows]
-        
-    def __iter__(self):
-        for row in self._cursor:
-            yield self._dict_factory(row)
-
-class _DictConnectionWrapper:
-    def __init__(self, conn):
-        self._conn = conn
-        
-    def __getattr__(self, name):
-        return getattr(self._conn, name)
-        
-    def cursor(self):
-        return _DictCursorWrapper(self._conn.cursor())
-        
-    def execute(self, *args, **kwargs):
-        return _DictCursorWrapper(self._conn.execute(*args, **kwargs))
-        
-    def executemany(self, *args, **kwargs):
-        return _DictCursorWrapper(self._conn.executemany(*args, **kwargs))
-        
-    def executescript(self, *args, **kwargs):
-        return _DictCursorWrapper(self._conn.executescript(*args, **kwargs))
-        
-    def __enter__(self):
-        if hasattr(self._conn, '__enter__'):
-            self._conn.__enter__()
-        return self
-        
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if hasattr(self._conn, '__exit__'):
-            return self._conn.__exit__(exc_type, exc_val, exc_tb)
-        return False
-
 class SkillStore:
     """SQLite persistence engine — Skill quality tracking and evolution ledger.
 
@@ -276,29 +205,21 @@ class SkillStore:
 
         Read connection: ``query_only=ON`` pragma for safety.
         """
-        db_url = os.environ.get("TURSO_DATABASE_URL")
-        auth_token = os.environ.get("TURSO_AUTH_TOKEN")
-
-        if db_url and auth_token:
-            conn = sqlite3.connect(db_url, auth_token=auth_token)
-        else:
-            conn = sqlite3.connect(
-                str(self._db_path),
-                timeout=30.0,
-                check_same_thread=False,
-            )
-            conn.execute("PRAGMA journal_mode=WAL")
-            conn.execute("PRAGMA busy_timeout=30000")
-            conn.execute("PRAGMA synchronous=NORMAL")
-            conn.execute("PRAGMA cache_size=-16000")  # 16 MB
-            conn.execute("PRAGMA temp_store=MEMORY")
-            conn.execute("PRAGMA foreign_keys=ON")
-            if read_only:
-                conn.execute("PRAGMA query_only=ON")
-        
-        # libsql-experimental doesn't support setting row_factory directly on the connection
-        # We wrap it to handle row-to-dict conversion manually where cursor.fetchall() is called
-        return _DictConnectionWrapper(conn)
+        conn = sqlite3.connect(
+            str(self._db_path),
+            timeout=30.0,
+            check_same_thread=False,
+        )
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA busy_timeout=30000")
+        conn.execute("PRAGMA synchronous=NORMAL")
+        conn.execute("PRAGMA cache_size=-16000")  # 16 MB
+        conn.execute("PRAGMA temp_store=MEMORY")
+        conn.execute("PRAGMA foreign_keys=ON")
+        if read_only:
+            conn.execute("PRAGMA query_only=ON")
+        conn.row_factory = sqlite3.Row
+        return conn
 
     @contextmanager
     def _reader(self) -> Generator[sqlite3.Connection, None, None]:
@@ -357,9 +278,7 @@ class SkillStore:
         self._closed = True
         try:
             # Flush WAL → main DB so external readers see all data
-            db_url = os.environ.get("TURSO_DATABASE_URL")
-            if not db_url:
-                self._conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+            self._conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
             self._conn.close()
         except Exception:
             pass
@@ -978,8 +897,8 @@ class SkillStore:
         with self._reader() as conn:
             where = " WHERE is_active=1" if active_only else ""
             total = conn.execute(
-                f"SELECT COUNT(*) as count FROM skill_records{where}"
-            ).fetchone()["count"]
+                f"SELECT COUNT(*) FROM skill_records{where}"
+            ).fetchone()[0]
 
             by_category = {
                 r["category"]: r["cnt"]
@@ -996,12 +915,12 @@ class SkillStore:
                 ).fetchall()
             }
             n_analyses = conn.execute(
-                "SELECT COUNT(*) as count FROM execution_analyses"
-            ).fetchone()["count"]
+                "SELECT COUNT(*) FROM execution_analyses"
+            ).fetchone()[0]
             n_candidates = conn.execute(
-                "SELECT COUNT(*) as count FROM execution_analyses "
+                "SELECT COUNT(*) FROM execution_analyses "
                 "WHERE candidate_for_evolution=1"
-            ).fetchone()["count"]
+            ).fetchone()[0]
             agg = conn.execute(
                 f"""
                 SELECT SUM(total_selections)  AS sel,
@@ -1014,8 +933,8 @@ class SkillStore:
 
             # Also report total (including inactive) for context
             total_all = conn.execute(
-                "SELECT COUNT(*) as count FROM skill_records"
-            ).fetchone()["count"]
+                "SELECT COUNT(*) FROM skill_records"
+            ).fetchone()[0]
 
             return {
                 "total_skills": total,

requirements.txt

@@ -12,7 +12,7 @@ colorama>=0.4.6
 # Local server dependencies (cross-platform)
 flask>=3.1.0
 flask-cors>=4.0.0
-pyautogui>=0.9.54
+# pyautogui>=0.9.54  # Removed for cloud deployment
 pydantic>=2.12.0
 requests>=2.32.0
 libsql-experimental