chishiki-sqlite 0.8.0

package/dist/lib/statements.js

@@ -0,0 +1,342 @@
+import { getDatabaseManager } from './database-manager.js';
+import { ManualSqliteClient } from './manual.js';
+const getDb = () => {
+    const client = ManualSqliteClient.getInstance();
+    return client.getDb();
+};
+const ensureDatabaseInitialized = async () => {
+    const dbManager = getDatabaseManager();
+    await dbManager.ensureInitialized();
+};
+/**
+ * Generate a UUID v4
+ */
+const generateUUID = () => 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+});
+/**
+ * Initialize the statements table
+ */
+const initializeStatementsTable = async () => {
+    const db = getDb();
+    if (!db)
+        return;
+    const tableExists = await db.introspection
+        .getTables()
+        .then((tables) => tables.some((table) => table.name === 'statements'));
+    if (!tableExists) {
+        await db.schema
+            .createTable('statements')
+            .ifNotExists()
+            .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+            .addColumn('statement_id', 'text', col => col.notNull().unique())
+            .addColumn('actor_id', 'integer', col => col.notNull())
+            .addColumn('verb_id', 'text', col => col.notNull())
+            .addColumn('activity_id', 'integer', col => col.notNull())
+            .addColumn('result', 'text')
+            .addColumn('context', 'text')
+            .addColumn('timestamp', 'text', col => col.notNull())
+            .addColumn('stored', 'text', col => col.notNull())
+            .execute();
+        // Create indexes for common queries
+        await db.schema.createIndex('idx_statements_actor').ifNotExists().on('statements').column('actor_id').execute();
+        await db.schema.createIndex('idx_statements_verb').ifNotExists().on('statements').column('verb_id').execute();
+        await db.schema
+            .createIndex('idx_statements_activity')
+            .ifNotExists()
+            .on('statements')
+            .column('activity_id')
+            .execute();
+        await db.schema
+            .createIndex('idx_statements_timestamp')
+            .ifNotExists()
+            .on('statements')
+            .column('timestamp')
+            .execute();
+        await db.schema.createIndex('idx_statements_stored').ifNotExists().on('statements').column('stored').execute();
+    }
+};
+/**
+ * Record a new xAPI statement
+ */
+const recordStatement = async (statement) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const now = new Date().toISOString();
+    const insertValues = {
+        statement_id: generateUUID(),
+        actor_id: statement.actor_id,
+        verb_id: statement.verb_id,
+        activity_id: statement.activity_id,
+        result: statement.result ? JSON.stringify(statement.result) : null,
+        context: statement.context ? JSON.stringify(statement.context) : null,
+        timestamp: statement.timestamp || now,
+        stored: now,
+    };
+    const result = await db.insertInto('statements').values(insertValues).returningAll().executeTakeFirstOrThrow();
+    return result;
+};
+/**
+ * Get statement by ID
+ */
+const getStatementById = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db.selectFrom('statements').selectAll().where('id', '=', id).executeTakeFirst();
+    return result || null;
+};
+/**
+ * Get statement by statement_id (UUID)
+ */
+const getStatementByStatementId = async (statementId) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db
+        .selectFrom('statements')
+        .selectAll()
+        .where('statement_id', '=', statementId)
+        .executeTakeFirst();
+    return result || null;
+};
+/**
+ * Get statements with filters and pagination
+ */
+const getStatements = async (page = 1, limit = 50, filters) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    let query = db.selectFrom('statements').selectAll().orderBy('timestamp', 'desc');
+    if (filters?.actor_id) {
+        query = query.where('actor_id', '=', filters.actor_id);
+    }
+    if (filters?.verb_id) {
+        query = query.where('verb_id', '=', filters.verb_id);
+    }
+    if (filters?.activity_id) {
+        query = query.where('activity_id', '=', filters.activity_id);
+    }
+    if (filters?.since) {
+        query = query.where('timestamp', '>=', filters.since);
+    }
+    if (filters?.until) {
+        query = query.where('timestamp', '<=', filters.until);
+    }
+    const results = await query
+        .offset((page - 1) * limit)
+        .limit(limit)
+        .execute();
+    return results;
+};
+/**
+ * Get statement count
+ */
+const getStatementCount = async (filters) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return 0;
+    let query = db.selectFrom('statements').select(db.fn.count('id').as('count'));
+    if (filters?.actor_id) {
+        query = query.where('actor_id', '=', filters.actor_id);
+    }
+    if (filters?.verb_id) {
+        query = query.where('verb_id', '=', filters.verb_id);
+    }
+    if (filters?.activity_id) {
+        query = query.where('activity_id', '=', filters.activity_id);
+    }
+    if (filters?.since) {
+        query = query.where('timestamp', '>=', filters.since);
+    }
+    if (filters?.until) {
+        query = query.where('timestamp', '<=', filters.until);
+    }
+    const result = await query.executeTakeFirst();
+    return result?.count || 0;
+};
+/**
+ * Get statements for an activity
+ */
+const getStatementsByActivityId = async (activityId) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    const results = await db
+        .selectFrom('statements')
+        .selectAll()
+        .where('activity_id', '=', activityId)
+        .orderBy('timestamp', 'desc')
+        .execute();
+    return results;
+};
+/**
+ * Get statements by verb
+ */
+const getStatementsByVerb = async (verbId, limit) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    let query = db.selectFrom('statements').selectAll().where('verb_id', '=', verbId).orderBy('timestamp', 'desc');
+    if (limit) {
+        query = query.limit(limit);
+    }
+    const results = await query.execute();
+    return results;
+};
+/**
+ * Get recent statements
+ */
+const getRecentStatements = async (days = 7, limit) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - days);
+    const cutoffISO = cutoffDate.toISOString();
+    let query = db.selectFrom('statements').selectAll().where('timestamp', '>=', cutoffISO).orderBy('timestamp', 'desc');
+    if (limit) {
+        query = query.limit(limit);
+    }
+    const results = await query.execute();
+    return results;
+};
+/**
+ * Get learning statistics
+ */
+const getLearningStats = async (actorId, since) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db) {
+        return {
+            totalStatements: 0,
+            completedActivities: 0,
+            passedActivities: 0,
+            failedActivities: 0,
+            averageScore: null,
+        };
+    }
+    let baseQuery = db.selectFrom('statements').where('actor_id', '=', actorId);
+    if (since) {
+        baseQuery = baseQuery.where('timestamp', '>=', since);
+    }
+    // Total statements
+    const totalResult = await baseQuery.select(db.fn.count('id').as('count')).executeTakeFirst();
+    const totalStatements = totalResult?.count || 0;
+    // Completed (using verb URI)
+    const completedResult = await baseQuery
+        .where('verb_id', '=', 'http://adlnet.gov/expapi/verbs/completed')
+        .select(db.fn.count('id').as('count'))
+        .executeTakeFirst();
+    const completedActivities = completedResult?.count || 0;
+    // Passed
+    const passedResult = await baseQuery
+        .where('verb_id', '=', 'http://adlnet.gov/expapi/verbs/passed')
+        .select(db.fn.count('id').as('count'))
+        .executeTakeFirst();
+    const passedActivities = passedResult?.count || 0;
+    // Failed
+    const failedResult = await baseQuery
+        .where('verb_id', '=', 'http://adlnet.gov/expapi/verbs/failed')
+        .select(db.fn.count('id').as('count'))
+        .executeTakeFirst();
+    const failedActivities = failedResult?.count || 0;
+    // Average score - need to parse JSON results
+    const statementsWithScores = await baseQuery.select(['result']).where('result', 'is not', null).execute();
+    let totalScore = 0;
+    let scoreCount = 0;
+    for (const stmt of statementsWithScores) {
+        if (stmt.result) {
+            try {
+                const result = JSON.parse(stmt.result);
+                if (result.score?.scaled !== undefined) {
+                    totalScore += result.score.scaled;
+                    scoreCount++;
+                }
+            }
+            catch {
+                // Ignore invalid JSON
+            }
+        }
+    }
+    const averageScore = scoreCount > 0 ? totalScore / scoreCount : null;
+    return {
+        totalStatements,
+        completedActivities,
+        passedActivities,
+        failedActivities,
+        averageScore,
+    };
+};
+/**
+ * Delete a statement
+ */
+const deleteStatement = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('statements').where('id', '=', id).execute();
+};
+/**
+ * Delete statements by activity ID
+ */
+const deleteStatementsByActivityId = async (activityId) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('statements').where('activity_id', '=', activityId).execute();
+};
+/**
+ * Reset the statements table
+ */
+const resetStatementsTable = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.schema.dropTable('statements').ifExists().execute();
+    await initializeStatementsTable();
+};
+/**
+ * Clear all statements
+ */
+const clearAllStatements = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('statements').execute();
+};
+/**
+ * Export statements in xAPI format (for external LRS compatibility)
+ */
+const exportStatementsAsXAPI = async (filters) => {
+    const statements = await getStatements(1, 10000, filters);
+    // This would need to be expanded to include full actor/activity details
+    // For now, return raw statements
+    return statements.map(s => ({
+        id: s.statement_id,
+        actor: { id: s.actor_id }, // Would need to fetch full actor
+        verb: { id: s.verb_id },
+        object: { id: s.activity_id }, // Would need to fetch full activity
+        result: s.result ? JSON.parse(s.result) : undefined,
+        context: s.context ? JSON.parse(s.context) : undefined,
+        timestamp: s.timestamp,
+        stored: s.stored,
+    }));
+};
+export { initializeStatementsTable, generateUUID, recordStatement, getStatementById, getStatementByStatementId, getStatements, getStatementCount, getStatementsByActivityId, getStatementsByVerb, getRecentStatements, getLearningStats, deleteStatement, deleteStatementsByActivityId, resetStatementsTable, clearAllStatements, exportStatementsAsXAPI, };

package/dist/lib/syllst-importer.js

@@ -0,0 +1,234 @@
+/**
+ * SYLLST Content Importer
+ *
+ * Imports learning content from SYLLST MDX format (polyglot-bundles packages)
+ * and creates corresponding flashcard activities in Chishiki.
+ */
+import { getDatabaseManager } from './database-manager.js';
+import { ManualSqliteClient } from './manual.js';
+import { addLearningContent } from './learning-content.js';
+import { createActivity } from './activities.js';
+import { storeGeneratedActivity } from './generated-activities.js';
+const getDb = () => {
+    const client = ManualSqliteClient.getInstance();
+    return client.getDb();
+};
+const ensureDatabaseInitialized = async () => {
+    const dbManager = getDatabaseManager();
+    await dbManager.ensureInitialized();
+};
+/**
+ * Parse SYLLST MDX content and extract frontmatter + learning items
+ */
+export function parseSyllstMdx(mdxContent) {
+    // Extract frontmatter (YAML between --- markers)
+    const frontmatterMatch = mdxContent.match(/^---\n([\s\S]*?)\n---/);
+    const frontmatterRaw = frontmatterMatch ? frontmatterMatch[1] : '';
+    // Simple YAML parsing for frontmatter
+    const frontmatter = {};
+    const lines = frontmatterRaw.split('\n');
+    let currentKey = null;
+    let currentArray = [];
+    let inArray = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Check for array start
+        if (trimmed.match(/^(\w+):\s*$/)) {
+            const keyMatch = trimmed.match(/^(\w+):\s*$/);
+            if (!keyMatch)
+                continue;
+            const key = keyMatch[1];
+            currentKey = key;
+            currentArray = [];
+            inArray = true;
+            continue;
+        }
+        // Check for array item
+        if (inArray && trimmed.startsWith('- ')) {
+            currentArray.push(trimmed.substring(2).trim());
+            continue;
+        }
+        // Check for key: value
+        const kvMatch = trimmed.match(/^(\w+):\s*(.+)$/);
+        if (kvMatch) {
+            const [, key, value] = kvMatch;
+            // Remove quotes if present
+            const cleanValue = value.replace(/^["']|["']$/g, '');
+            frontmatter[key] = cleanValue;
+            // Handle nested learningObjectives array
+            if (key === 'learningObjectives') {
+                frontmatter[key] = [];
+            }
+            currentKey = null;
+            inArray = false;
+        }
+        // End array on empty line or new key
+        if (inArray && (trimmed === '' || trimmed.match(/^\w+:/))) {
+            if (currentKey) {
+                frontmatter[currentKey] = currentArray;
+            }
+            inArray = false;
+        }
+    }
+    // Extract vocabulary items (look for ::vocabulary blocks)
+    const vocabularyItems = [];
+    const vocabBlockRegex = /::vocabulary\{([^}]+)\}/g;
+    let match;
+    while ((match = vocabBlockRegex.exec(mdxContent)) !== null) {
+        const attrs = match[1];
+        const idMatch = attrs.match(/id="([^"]+)"/);
+        const wordMatch = attrs.match(/word="([^"]+)"/);
+        const translationMatch = attrs.match(/translation="([^"]+)"/);
+        const romanizationMatch = attrs.match(/romanization="([^"]+)"/);
+        if (idMatch && wordMatch && translationMatch) {
+            vocabularyItems.push({
+                id: idMatch[1],
+                word: wordMatch[1],
+                translation: translationMatch[1],
+                romanization: romanizationMatch?.[1],
+            });
+        }
+    }
+    // Extract character items (look for ::character blocks)
+    const characterItems = [];
+    const charBlockRegex = /::character\{([^}]+)\}/g;
+    let charMatch;
+    while ((charMatch = charBlockRegex.exec(mdxContent)) !== null) {
+        const attrs = charMatch[1];
+        const idMatch = attrs.match(/id="([^"]+)"/);
+        const charMatchRegex = attrs.match(/char="([^"]+)"/);
+        const nameMatch = attrs.match(/name="([^"]+)"/);
+        const romanizationMatch = attrs.match(/romanization="([^"]+)"/);
+        const typeMatch = attrs.match(/type="([^"]+)"/);
+        if (idMatch && charMatchRegex && nameMatch) {
+            characterItems.push({
+                id: idMatch[1],
+                char: charMatchRegex[1],
+                name: nameMatch[1],
+                romanization: romanizationMatch?.[1],
+                charType: typeMatch?.[1] || 'unknown',
+            });
+        }
+    }
+    return {
+        frontmatter: frontmatter,
+        vocabularyItems,
+        characterItems,
+        rawMdx: mdxContent,
+    };
+}
+/**
+ * Import SYLLST MDX content into Chishiki
+ * Creates learning content and generates flashcard activities
+ */
+export async function importSyllstContent(mdxContent, syllabusId, lessonNumber) {
+    await ensureDatabaseInitialized();
+    const parsed = parseSyllstMdx(mdxContent);
+    const title = parsed.frontmatter.title || `Lesson ${lessonNumber}`;
+    const language = parsed.frontmatter.language || 'unknown';
+    // Create learning content entry
+    const content = await addLearningContent({
+        content_type: 'lesson',
+        raw_content: mdxContent,
+        title: `${syllabusId} - ${title}`,
+        metadata: {
+            title: `${syllabusId} - ${title}`,
+            source_url: undefined,
+            syllabusId,
+            lessonNumber,
+            language,
+            frontmatter: parsed.frontmatter,
+            extractedAt: new Date().toISOString(),
+        },
+        language,
+    });
+    const contentId = String(content.id);
+    const activityIds = [];
+    // Collect flashcards for vocabulary
+    const vocabFlashcards = [];
+    for (const vocab of parsed.vocabularyItems) {
+        vocabFlashcards.push({
+            id: vocab.id,
+            front: vocab.word,
+            back: vocab.translation,
+            tags: vocab.romanization ? [`roman:${vocab.romanization}`] : undefined,
+        });
+    }
+    // Store vocabulary flashcard activity
+    if (vocabFlashcards.length > 0) {
+        const vocabActivity = await createActivity({
+            activity_iri: `https://chishiki.app/activities/flashcard/${syllabusId}-vocab-${lessonNumber}`,
+            name: `Vocabulary Flashcards: ${title}`,
+            description: `Vocabulary flashcards for ${syllabusId} lesson ${lessonNumber}`,
+            activity_type: 'flashcard',
+            content_id: content.id,
+        });
+        activityIds.push(String(vocabActivity.id));
+        await storeGeneratedActivity({
+            content_id: content.id,
+            activity_type: 'flashcard',
+            activity_data: {
+                flashcards: vocabFlashcards,
+            },
+        });
+    }
+    // Collect flashcards for characters
+    const charFlashcards = [];
+    for (const char of parsed.characterItems) {
+        charFlashcards.push({
+            id: char.id,
+            front: char.char,
+            back: char.name,
+            tags: [
+                `type:${char.charType}`,
+                ...(char.romanization ? [`roman:${char.romanization}`] : []),
+            ],
+        });
+    }
+    // Store character flashcard activity
+    if (charFlashcards.length > 0) {
+        const charActivity = await createActivity({
+            activity_iri: `https://chishiki.app/activities/flashcard/${syllabusId}-char-${lessonNumber}`,
+            name: `Character Flashcards: ${title}`,
+            description: `Character flashcards for ${syllabusId} lesson ${lessonNumber}`,
+            activity_type: 'flashcard',
+            content_id: content.id,
+        });
+        activityIds.push(String(charActivity.id));
+        await storeGeneratedActivity({
+            content_id: content.id,
+            activity_type: 'flashcard',
+            activity_data: {
+                flashcards: charFlashcards,
+            },
+        });
+    }
+    return {
+        contentId,
+        activityIds,
+        vocabularyCount: parsed.vocabularyItems.length,
+        characterCount: parsed.characterItems.length,
+    };
+}
+/**
+ * Batch import multiple SYLLST lessons
+ */
+export async function batchImportSyllstLessons(lessons) {
+    const results = [];
+    let totalActivities = 0;
+    for (const lesson of lessons) {
+        const result = await importSyllstContent(lesson.mdx, lesson.syllabusId, lesson.lessonNumber);
+        results.push({
+            syllabusId: lesson.syllabusId,
+            lessonNumber: lesson.lessonNumber,
+            contentId: result.contentId,
+            activityCount: result.activityIds.length,
+        });
+        totalActivities += result.activityIds.length;
+    }
+    return {
+        totalContent: lessons.length,
+        totalActivities,
+        results,
+    };
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../index.mts","../lib/activities.ts","../lib/actors.ts","../lib/database-manager.ts","../lib/database-reset.ts","../lib/generated-activities.ts","../lib/index.ts","../lib/learning-content.ts","../lib/manual.ts","../lib/statements.ts","../lib/syllst-importer.ts","../lib/types.ts"],"version":"5.8.3"}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "chishiki-sqlite",
+  "version": "0.8.0",
+  "description": "chrome extension - sqlite opfs integration",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist/**"
+  ],
+  "types": "dist/index.d.mts",
+  "main": "dist/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "kysely": "^0.28.8",
+    "sqlocal": "^0.15.2",
+    "@extension/shared": "0.5.0"
+  },
+  "devDependencies": {
+    "tsc-alias": "^1.8.16",
+    "@extension/tsconfig": "0.6.0"
+  },
+  "scripts": {
+    "clean:bundle": "rimraf dist",
+    "clean:node_modules": "pnpx rimraf node_modules",
+    "clean:turbo": "rimraf .turbo",
+    "clean": "pnpm clean:bundle && pnpm clean:node_modules && pnpm clean:turbo",
+    "ready": "tsc -b && tsc-alias -p tsconfig.json",
+    "lint": "eslint .",
+    "lint:fix": "pnpm lint --fix",
+    "format": "prettier . --write --ignore-path ../../.prettierignore",
+    "type-check": "tsc --noEmit"
+  }
+}