synset 0.9.5 → 0.9.7

package/README.md

@@ -88,7 +88,7 @@ import { exportToSQLite } from 'synset'
 // Export to SQLite
 exportToSQLite(lexicon, 'dictionary.db', {
   onProgress: ({ phase, current, total }) => {
-    // phases: words, synsets, word_synsets, synset_relations
+    // phases: words, synsets, word_synsets, synset_relations, sense_relations
     console.log(`${phase}: ${current}/${total}`)
   }
 })
@@ -103,9 +103,11 @@ Tables:
 - `synsets` - definitions with part of speech
 - `word_synsets` - word → synset mappings
 - `synset_relations` - hypernym, hyponym, meronym, etc. links between synsets
+- `sense_relations` - antonym, derivation, pertainym, etc. links between word senses
 
-Example query for word hypernyms:
+Example queries:
 ```sql
+-- Hypernyms via synset relations (dog → canine, domestic animal)
 SELECT w2.word_display, s2.definition
 FROM words w
 JOIN word_synsets ws ON w.id = ws.word_id
@@ -114,7 +116,14 @@ JOIN synsets s2 ON sr.target_id = s2.id
 JOIN word_synsets ws2 ON s2.id = ws2.synset_id
 JOIN words w2 ON ws2.word_id = w2.id
 WHERE w.word = 'dog' AND sr.rel_type = 'hypernym';
--- Returns: canine, domestic animal, ...
+
+-- Antonyms via sense relations (happy → unhappy)
+SELECT w2.word_display, s2.definition
+FROM words w
+JOIN sense_relations sr ON w.id = sr.source_word_id
+JOIN words w2 ON sr.target_word_id = w2.id
+JOIN synsets s2 ON sr.target_synset_id = s2.id
+WHERE w.word = 'happy' AND sr.rel_type = 'antonym';
 ```
 
 ## Runtime

package/dist/cli.cjs

@@ -24,8 +24,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/export-sqlite.ts
+var import_node_fs = require("fs");
 var import_libsql = __toESM(require("libsql"), 1);
 
+// src/helpers.ts
+var import_entities = require("entities");
+
 // src/types.ts
 var import_zod = require("zod");
 var LexiconId = import_zod.z.string();
@@ -327,10 +331,7 @@ function LexiconNode(node) {
   };
   return Lexicon.parse(extendWithRestAttr(node, obj, (s) => s));
 }
-var decodeXmlEntities = (s) => {
-  if (s === void 0) return void 0;
-  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&apos;/g, "'").replace(/&quot;/g, '"');
-};
+var decodeXmlEntities = (s) => s === void 0 ? void 0 : (0, import_entities.decodeXML)(s);
 var attr = (node, attrName) => {
   const value = decodeXmlEntities(node.attributes[attrName]);
   if (value === void 0) {
@@ -387,9 +388,28 @@ CREATE TABLE IF NOT EXISTS synset_relations (
 );
 CREATE INDEX IF NOT EXISTS idx_sr_source ON synset_relations(source_id);
 CREATE INDEX IF NOT EXISTS idx_sr_target ON synset_relations(target_id);
+
+CREATE TABLE IF NOT EXISTS sense_relations (
+  source_word_id INTEGER NOT NULL,
+  source_synset_id TEXT NOT NULL,
+  target_word_id INTEGER NOT NULL,
+  target_synset_id TEXT NOT NULL,
+  rel_type TEXT NOT NULL,
+  PRIMARY KEY (source_word_id, source_synset_id, target_word_id, target_synset_id, rel_type)
+);
+CREATE INDEX IF NOT EXISTS idx_sense_rel_source ON sense_relations(source_word_id, source_synset_id);
 `;
 function exportToSQLite(lexicon, outputPath, options = {}) {
-  const { onProgress } = options;
+  const { onProgress, overwrite } = options;
+  if ((0, import_node_fs.existsSync)(outputPath)) {
+    if (overwrite) {
+      (0, import_node_fs.unlinkSync)(outputPath);
+    } else {
+      throw new Error(
+        `File already exists: ${outputPath}. Use --overwrite to replace it.`
+      );
+    }
+  }
   const db = new import_libsql.default(outputPath);
   db.exec("PRAGMA journal_mode = OFF");
   db.exec("PRAGMA synchronous = OFF");
@@ -516,6 +536,66 @@ function exportToSQLite(lexicon, outputPath, options = {}) {
     }
   }
   db.exec("COMMIT");
+  const senseToWordSynset = /* @__PURE__ */ new Map();
+  for (const [word, entries] of wordToEntries) {
+    const wId = wordIds.get(word);
+    if (!wId) continue;
+    for (const entry of entries) {
+      for (const sense of entry.senses) {
+        senseToWordSynset.set(sense.id, {
+          wordId: wId,
+          synsetId: sense.synset
+        });
+      }
+    }
+  }
+  const insertSenseRelation = db.prepare(
+    "INSERT OR IGNORE INTO sense_relations (source_word_id, source_synset_id, target_word_id, target_synset_id, rel_type) VALUES (?, ?, ?, ?, ?)"
+  );
+  let totalSenseRelations = 0;
+  for (const entries of wordToEntries.values()) {
+    for (const entry of entries) {
+      for (const sense of entry.senses) {
+        for (const rel of sense.senseRelations) {
+          if (senseToWordSynset.has(rel.target)) {
+            totalSenseRelations++;
+          }
+        }
+      }
+    }
+  }
+  db.exec("BEGIN TRANSACTION");
+  let senseRelCount = 0;
+  for (const [word, entries] of wordToEntries) {
+    const sourceWordId = wordIds.get(word);
+    if (!sourceWordId) continue;
+    for (const entry of entries) {
+      for (const sense of entry.senses) {
+        const sourceSynsetId = sense.synset;
+        for (const rel of sense.senseRelations) {
+          const target = senseToWordSynset.get(rel.target);
+          if (target) {
+            insertSenseRelation.run(
+              sourceWordId,
+              sourceSynsetId,
+              target.wordId,
+              target.synsetId,
+              rel.relType
+            );
+            senseRelCount++;
+            if (onProgress && senseRelCount % 1e4 === 0) {
+              onProgress({
+                phase: "sense_relations",
+                current: senseRelCount,
+                total: totalSenseRelations
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  db.exec("COMMIT");
   db.close();
 }
 
@@ -631,7 +711,7 @@ var SynsetRelationRelType2 = {
 };
 
 // src/loader.ts
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_node_path = __toESM(require("path"), 1);
 var import_node_stream = require("stream");
 
@@ -890,8 +970,8 @@ function getDefaultCacheDir() {
   return import_node_path.default.join(homeDir, ".cache", "synset");
 }
 function fileExists(filePath) {
-  if ((0, import_node_fs.existsSync)(filePath)) {
-    const stat = (0, import_node_fs.statSync)(filePath);
+  if ((0, import_node_fs2.existsSync)(filePath)) {
+    const stat = (0, import_node_fs2.statSync)(filePath);
     return stat.isFile();
   }
   return false;
@@ -909,8 +989,8 @@ function extractVersionFromFilename(filename) {
   return match ? parseInt(match[1], 10) : null;
 }
 function findCachedVersion(cacheDir) {
-  if (!(0, import_node_fs.existsSync)(cacheDir)) return null;
-  const files = (0, import_node_fs.readdirSync)(cacheDir);
+  if (!(0, import_node_fs2.existsSync)(cacheDir)) return null;
+  const files = (0, import_node_fs2.readdirSync)(cacheDir);
   const wordnetFiles = files.map((f) => ({ file: f, year: extractVersionFromFilename(f) })).filter((x) => x.year !== null).sort((a, b) => b.year - a.year);
   return wordnetFiles.length > 0 ? wordnetFiles[0].year.toString() : null;
 }
@@ -971,14 +1051,14 @@ async function downloadWordNet(version, destPath) {
   );
   const arrayBuffer = await new Response(decompressed).arrayBuffer();
   const dir = import_node_path.default.dirname(destPath);
-  if (!(0, import_node_fs.existsSync)(dir)) {
-    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_node_fs2.existsSync)(dir)) {
+    (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_node_fs.writeFileSync)(destPath, Buffer.from(arrayBuffer));
+  (0, import_node_fs2.writeFileSync)(destPath, Buffer.from(arrayBuffer));
 }
 function createParser(filePath) {
   const resolvedPath = import_node_path.default.resolve(filePath);
-  const nodeStream = (0, import_node_fs.createReadStream)(resolvedPath);
+  const nodeStream = (0, import_node_fs2.createReadStream)(resolvedPath);
   const webStream = import_node_stream.Readable.toWeb(nodeStream);
   return parse(webStream, {
     ignoreDeclaration: false,
@@ -1153,6 +1233,7 @@ Commands:
 
 Options:
   --file <path>       Use a local WordNet XML file instead of cache
+  --overwrite         Overwrite existing file (for export-sqlite)
   --help, -h          Show this help message
 
 Examples:
@@ -1188,10 +1269,12 @@ async function main() {
       console.error("Error: Missing output path for export-sqlite");
       process.exit(1);
     }
+    const overwrite = args.includes("--overwrite");
     console.log("Loading WordNet data...");
     const lexicon2 = filePath ? await loadWordNet(filePath) : (await fetchWordNet({ onProgress: console.log })).lexicon;
     console.log(`Exporting to ${outputPath}...`);
     exportToSQLite(lexicon2, outputPath, {
+      overwrite,
       onProgress: ({ phase, current, total }) => {
         process.stdout.write(`\r${phase}: ${current}/${total}`);
       }