ronin-skillforce 0.0.0-stage → 0.1.0

package/studio/src/lib/repo/memory-adapter.js

@@ -0,0 +1,115 @@
+/**
+ * In-memory StorageAdapter. Used directly in tests and as the fallback when IndexedDB is
+ * unavailable (private mode, some embedded webviews, vitest without fake-indexeddb).
+ *
+ * Contract (see remote-adapter.js): dumb table-level storage. No stamping, no business logic.
+ */
+import { TABLE_NAMES, SCHEMA_VERSION, tableSpec, assertIndexedField } from './schema.js';
+
+export const APP_ID = 'professor-studio';
+
+function applyList(rows, { where, includeDeleted = false, orderBy, limit } = {}) {
+  let out = rows;
+  if (where) {
+    for (const key of Object.keys(where)) {
+      out = out.filter((r) => r[key] === where[key]);
+    }
+  }
+  if (!includeDeleted) out = out.filter((r) => !r.deleted_at);
+  if (orderBy) {
+    const field = typeof orderBy === 'string' ? orderBy : orderBy.field;
+    const dir = typeof orderBy === 'string' ? 1 : orderBy.dir === 'desc' ? -1 : 1;
+    out = [...out].sort((a, b) => {
+      const av = a[field];
+      const bv = b[field];
+      if (av === bv) return 0;
+      return (av > bv ? 1 : -1) * dir;
+    });
+  }
+  if (typeof limit === 'number') out = out.slice(0, limit);
+  return out.map((r) => ({ ...r }));
+}
+
+/**
+ * @returns {import('./remote-adapter.js').StorageAdapter & { label: string }}
+ */
+export function createMemoryAdapter() {
+  /** @type {Record<string, Map<string, object>>} */
+  const stores = Object.fromEntries(TABLE_NAMES.map((t) => [t, new Map()]));
+
+  function store(table) {
+    const s = stores[table];
+    if (!s) throw new Error(`Unknown table: ${table}`);
+    return s;
+  }
+
+  return {
+    label: 'memory',
+    async get(table, id) {
+      const row = store(table).get(id);
+      return row ? { ...row } : null;
+    },
+    async put(table, row) {
+      const spec = tableSpec(table);
+      const id = row[spec.id];
+      if (id === undefined || id === null) throw new Error(`Row for "${table}" is missing "${spec.id}"`);
+      const next = { ...row, [spec.id]: id };
+      store(table).set(id, next);
+      return { ...next };
+    },
+    async putMany(table, rows) {
+      const out = [];
+      for (const row of rows || []) out.push(await this.put(table, row));
+      return out;
+    },
+    async list(table, opts = {}) {
+      if (opts.where) {
+        for (const field of Object.keys(opts.where)) assertIndexedField(table, field);
+      }
+      return applyList([...store(table).values()], opts);
+    },
+    async softDelete(table, id) {
+      const s = store(table);
+      const row = s.get(id);
+      if (!row) return null;
+      const next = { ...row, deleted_at: new Date().toISOString() };
+      s.set(id, next);
+      return { ...next };
+    },
+    async exportAll() {
+      const tables = {};
+      for (const t of TABLE_NAMES) tables[t] = [...stores[t].values()].map((r) => ({ ...r }));
+      return {
+        app: APP_ID,
+        version: 1,
+        schemaVersion: SCHEMA_VERSION,
+        exportedAt: new Date().toISOString(),
+        tables,
+      };
+    },
+    async importAll(dump) {
+      validateDump(dump);
+      for (const t of TABLE_NAMES) {
+        const s = stores[t];
+        for (const row of dump.tables[t] || []) {
+          const spec = tableSpec(t);
+          s.set(row[spec.id], { ...row });
+        }
+      }
+      return { imported: TABLE_NAMES.reduce((n, t) => n + (dump.tables[t]?.length || 0), 0) };
+    },
+    async info() {
+      return { kind: 'memory', persistent: false };
+    },
+    async clearAll() {
+      for (const t of TABLE_NAMES) stores[t].clear();
+      return { cleared: true };
+    },
+  };
+}
+
+/** @param {any} dump */
+export function validateDump(dump) {
+  if (!dump || dump.app !== APP_ID) throw new Error('Not a Professor Studio backup file');
+  if (!dump.tables || typeof dump.tables !== 'object') throw new Error('Backup file has no tables');
+}

package/studio/src/lib/repo/remote-adapter.js

@@ -0,0 +1,158 @@
+/**
+ * RemoteAdapter — talks to the local Studio server (`web/studio-api.js`) over HTTP, and to the
+ * future Cloudflare Worker + D1 backend unchanged (same contract, only base URL + token differ).
+ *
+ * The adapter is a dumb, table-level store: no business logic, no stamping. `repo/index.js` owns
+ * ids, owner_id, timestamps and tombstones. See the contract documented below.
+ *
+ * --- StorageAdapter contract (same as idb- and memory-adapter) ------------------------------
+ *   get(table, id)                         -> row | null
+ *   put(table, row)                        -> row            (upsert by row.id; adapter stamps nothing)
+ *   putMany(table, rows)                   -> rows
+ *   list(table, { where?, includeDeleted?, orderBy?, limit? }) -> rows
+ *                                            where: equality on indexed fields only (schema.js)
+ *                                            orderBy: field name | { field, dir: 'asc'|'desc' }
+ *   softDelete(table, id)                  -> row | null     (sets deleted_at = now, ISO-8601)
+ *   exportAll()                            -> { app, version, schemaVersion, exportedAt, tables }
+ *   importAll(dump)                        -> { imported }
+ *   clearAll()                             -> { cleared: true }   (removes every row — STORE-03)
+ *   info()                                 -> { kind: 'indexeddb'|'memory'|'remote', persistent, … }
+ * -------------------------------------------------------------------------------------------
+ *
+ * --- HTTP contract (implemented by web/studio-api.js; the D1 Worker reuses it) --------------
+ *   GET  {base}/api/studio/db/health   header X-Studio-Token
+ *        ->  { ok: true, kind: 'sqlite', path, schemaVersion }
+ *   POST {base}/api/studio/db          header X-Studio-Token
+ *        body    { op, table?, args: [ ...positional args ] }
+ *        ->  { ok: true,  result }
+ *         |  { ok: false, error: '<message>', code: '<code>' }
+ * -------------------------------------------------------------------------------------------
+ */
+import { tableSpec, assertIndexedField } from './schema.js';
+import { isLoopbackBridgeUrl } from '../settings.js';
+import { providerError } from '../ai/errors.js';
+
+/** Raised when the Studio server rejects a request (used so callers can distinguish from network). */
+export class RemoteAdapterError extends Error {
+  /** @param {string} message @param {{ code?: string, status?: number }} [info] */
+  constructor(message, { code = 'remote_error', status = 0 } = {}) {
+    super(message);
+    this.name = 'RemoteAdapterError';
+    this.code = code;
+    this.status = status;
+  }
+}
+
+/**
+ * @param {{ baseUrl: string, token?: string, fetchImpl?: typeof fetch }} opts
+ * @returns {import('./remote-adapter.js').StorageAdapter & { label: string, health: () => Promise<any> }}
+ */
+export function createRemoteAdapter({ baseUrl, token, fetchImpl = globalThis.fetch } = {}) {
+  const root = String(baseUrl || '').replace(/\/$/, '');
+  const headers = {
+    'Content-Type': 'application/json',
+    ...(token ? { 'X-Studio-Token': token } : {}),
+  };
+  /** @type {{ path?: string, schemaVersion?: number }|null} */
+  let cachedHealth = null;
+
+  function assertLocalEndpoint() {
+    if (!isLoopbackBridgeUrl(root)) throw providerError('loopback_required');
+  }
+
+  async function post(op, table, args = []) {
+    assertLocalEndpoint();
+    let res;
+    try {
+      res = await fetchImpl(`${root}/api/studio/db`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(table ? { op, table, args } : { op, args }),
+      });
+    } catch (err) {
+      throw new RemoteAdapterError(`Studio server not reachable at ${root}: ${err.message}`, { code: 'network' });
+    }
+    if (res.status === 401 || res.status === 403) {
+      throw new RemoteAdapterError(`Studio server rejected the pairing token (${res.status})`, {
+        code: 'auth',
+        status: res.status,
+      });
+    }
+    if (!res.ok) {
+      let payload = null;
+      try {
+        payload = await res.json();
+      } catch {
+        /* not JSON */
+      }
+      throw new RemoteAdapterError(payload?.error || `Studio server error ${res.status}`, {
+        code: payload?.code || 'server',
+        status: res.status,
+      });
+    }
+    const json = await res.json();
+    if (!json.ok) throw new RemoteAdapterError(json.error || 'Studio server error', { code: json.code || 'db_error' });
+    return json.result;
+  }
+
+  async function health() {
+    assertLocalEndpoint();
+    let res;
+    try {
+      res = await fetchImpl(`${root}/api/studio/db/health`, { headers });
+    } catch (err) {
+      throw new RemoteAdapterError(`Studio server not reachable at ${root}: ${err.message}`, { code: 'network' });
+    }
+    if (res.status === 401 || res.status === 403) {
+      throw new RemoteAdapterError(`Studio server rejected the pairing token (${res.status})`, { code: 'auth', status: res.status });
+    }
+    if (!res.ok) throw new RemoteAdapterError(`Studio server error ${res.status}`, { code: 'server', status: res.status });
+    const json = await res.json();
+    if (!json.ok) throw new RemoteAdapterError(json.error || 'Studio server error', { code: json.code || 'db_error' });
+    cachedHealth = { path: json.path, schemaVersion: json.schemaVersion };
+    return json;
+  }
+
+  return {
+    label: 'remote',
+    async get(table, id) {
+      tableSpec(table);
+      return post('get', table, [id]);
+    },
+    async put(table, row) {
+      tableSpec(table);
+      return post('put', table, [row]);
+    },
+    async putMany(table, rows) {
+      tableSpec(table);
+      return post('putMany', table, [rows]);
+    },
+    async list(table, opts = {}) {
+      tableSpec(table);
+      if (opts.where) for (const field of Object.keys(opts.where)) assertIndexedField(table, field);
+      return post('list', table, [opts]);
+    },
+    async softDelete(table, id) {
+      tableSpec(table);
+      return post('softDelete', table, [id]);
+    },
+    async exportAll() {
+      return post('exportAll');
+    },
+    async importAll(dump) {
+      return post('importAll', null, [dump]);
+    },
+    async clearAll() {
+      return post('clearAll');
+    },
+    async info() {
+      try {
+        const h = cachedHealth || (await health());
+        return { kind: 'remote', persistent: true, path: h.path, schemaVersion: h.schemaVersion };
+      } catch {
+        return { kind: 'remote', persistent: true };
+      }
+    },
+    health,
+  };
+}

package/studio/src/lib/repo/schema.js

@@ -0,0 +1,143 @@
+/**
+ * JS metadata mirroring migrations/0001_init.sql.
+ *
+ * The IndexedDB adapter creates one object store per table and one index per entry in
+ * `indexes`. Adapters only guarantee equality filtering on these fields (see StorageAdapter
+ * contract in remote-adapter.js) — richer queries live in repo/index.js so the SQLite/D1
+ * adapters stay generic.
+ *
+ * `fields` lists every column (documentation / the SQLite side); `indexes` are the only fields
+ * an adapter may use in `list({ where })`. `quiz_seed` is a demo-only convenience column
+ * (pre-written quiz so the bundled demo course is walkable with no provider).
+ */
+
+/** @typedef {{ id: string, fields: string[], indexes: string[] }} TableSpec */
+
+/** @type {Record<string, TableSpec>} */
+export const TABLES = {
+  courses: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'title', 'description', 'level', 'kind', 'goal', 'topics_json', 'source', 'status', 'language', 'external_id', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['external_id'],
+  },
+  lessons: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'course_id', 'position', 'title', 'summary', 'status', 'completed_at', 'current_version_id', 'quiz_seed', 'external_id', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['course_id', 'status', 'external_id'],
+  },
+  lesson_versions: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'lesson_id', 'version', 'content_md', 'model', 'provider', 'external_id', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['lesson_id', 'external_id'],
+  },
+  quiz_attempts: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'lesson_id', 'questions_json', 'answers_json', 'score', 'total', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['lesson_id'],
+  },
+  cards: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'course_id', 'lesson_id', 'front', 'back', 'ease', 'interval_days', 'reps', 'lapses', 'due_at', 'external_id', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['course_id', 'lesson_id', 'due_at', 'external_id'],
+  },
+  reviews: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'card_id', 'grade', 'reviewed_at', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['card_id'],
+  },
+  chat_messages: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'lesson_id', 'role', 'content', 'mode', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['lesson_id'],
+  },
+  reflections: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'lesson_id', 'hardest', 'confidence', 'note', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['lesson_id'],
+  },
+  notes: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'course_id', 'lesson_id', 'content_md', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['course_id', 'lesson_id'],
+  },
+  activity: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'day', 'kind', 'ref_id', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['day', 'kind'],
+  },
+  workspace_files: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'course_id', 'lesson_id', 'path', 'language', 'content', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['lesson_id'],
+  },
+  run_results: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'lesson_id', 'file_id', 'runner', 'language', 'stdout', 'stderr', 'exit_code', 'checks_json', 'duration_ms', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['lesson_id'],
+  },
+  exercises: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'course_id', 'lesson_id', 'position', 'type', 'spec_json', 'external_id', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['course_id', 'lesson_id', 'external_id'],
+  },
+  exercise_attempts: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'course_id', 'lesson_id', 'exercise_id', 'rows_json', 'result_json', 'correct', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['exercise_id', 'lesson_id', 'course_id'],
+  },
+  capstones: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'course_id', 'kind', 'brief_md', 'rubric_json', 'tests_json', 'hidden_answers_json', 'artifact_json', 'external_id', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['course_id', 'external_id'],
+  },
+  capstone_submissions: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'capstone_id', 'attempt', 'content_md', 'repo_url', 'files_json', 'test_results_json', 'review_json', 'verdict', 'external_id', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['capstone_id', 'external_id'],
+  },
+  learning_events: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'day', 'kind', 'surface', 'course_id', 'lesson_id', 'ref_id', 'meta_json', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['day', 'kind', 'surface', 'course_id', 'lesson_id'],
+  },
+  revision_links: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'surface', 'course_id', 'lesson_id', 'attempt_table', 'attempt_id', 'feedback_table', 'feedback_id', 'revised_table', 'revised_id', 'link_kind', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: ['surface', 'course_id', 'lesson_id', 'attempt_id', 'revised_id', 'link_kind'],
+  },
+  beta_profile: {
+    id: 'id',
+    fields: ['id', 'owner_id', 'participant_id', 'activated_at', 'activated_day', 'created_at', 'updated_at', 'deleted_at'],
+    indexes: [],
+  },
+};
+
+export const TABLE_NAMES = Object.keys(TABLES);
+
+/** Highest migration file shipped in `studio/migrations/` (D-12 single constant source). */
+export const LATEST_MIGRATION_VERSION = 6;
+
+export const SCHEMA_VERSION = LATEST_MIGRATION_VERSION;
+
+/**
+ * @param {string} table
+ * @returns {TableSpec}
+ */
+export function tableSpec(table) {
+  const spec = TABLES[table];
+  if (!spec) throw new Error(`Unknown table: ${table}`);
+  return spec;
+}
+
+/**
+ * Throw unless `field` is an equality-filterable (indexed) field of `table`.
+ * @param {string} table
+ * @param {string} field
+ */
+export function assertIndexedField(table, field) {
+  const spec = tableSpec(table);
+  if (field === spec.id) return;
+  if (!spec.indexes.includes(field)) {
+    throw new Error(`Field "${field}" is not indexed on table "${table}"`);
+  }
+}