@hzhangxyz/ddss 0.0.29 → 0.0.30

package/README.md

@@ -1,14 +1,14 @@
 # Distributed Deductive System Sorts (DDSS)
 
-DDSS is a distributed deductive system with a scalable architecture. It currently supports distributed engines including forward-chaining, E-graph, and more.
+DDSS is a distributed deductive system with a scalable architecture, providing identical implementations in both **Python** and **TypeScript**. It currently supports distributed engines including forward-chaining, E-graph, and more.
 
 ## Design Philosophy
 
 DDSS adopts a modular architecture that decomposes the deductive system into independent but collaborative sub-systems:
 
-1. **Separation of Concerns**: Each module focuses on a specific reasoning task
-2. **Concurrent Execution**: All modules collaborate asynchronously through a shared database, fully utilizing system resources
-3. **Persistent Storage**: Uses a database to store facts and ideas, ensuring data consistency
+1. **Separation of Concerns**: Each module focuses on a specific reasoning task.
+2. **Concurrent Execution**: All modules collaborate asynchronously through a shared database, fully utilizing system resources.
+3. **Persistent Storage**: Uses a database to store facts and ideas, ensuring data consistency.
 
 The system uses a database as the central hub, with two tables (`facts` and `ideas`) for interaction between sub-systems:
 
@@ -18,34 +18,49 @@ The system uses a database as the central hub, with two tables (`facts` and `ide
 
 ## Modules
 
-- **Input** (`ddss/input.py`): Interactive input interface with BNF syntax parsing
-- **Output** (`ddss/output.py`): Real-time display of facts and ideas from the database
-- **Load** (`ddss/load.py`): Batch import of facts from standard input
-- **Dump** (`ddss/dump.py`): Export all facts and ideas to output
-- **DS** (`ddss/ds.py`): Forward-chaining deductive search engine
-- **Egg** (`ddss/egg.py`): E-graph based equality reasoning engine
+The system consists of the following modules, implemented symmetrically in `ddss/*.py` and `ddss/*.ts`:
+
+- **Input** (`ddss/input.py`, `ddss/input.ts`): Interactive input interface with BNF syntax parsing
+- **Output** (`ddss/output.py`, `ddss/output.ts`): Real-time display of facts and ideas from the database
+- **Load** (`ddss/load.py`, `ddss/load.ts`): Batch import of facts from standard input
+- **Dump** (`ddss/dump.py`, `ddss/dump.ts`): Export all facts and ideas to output
+- **DS** (`ddss/ds.py`, `ddss/ds.ts`): Forward-chaining deductive search engine
+- **Egg** (`ddss/egg.py`, `ddss/egg.ts`): E-graph based equality reasoning engine
 
 ## Installation
 
-### Using uvx (Recommended)
+You can choose either the Python or TypeScript version. Both provide the same `ddss` command-line interface.
 
-The simplest way is to run with `uvx`:
+### Python Version
 
+#### Using uvx (Recommended)
 ```bash
 uvx ddss
 ```
 
-This automatically installs all dependencies and starts the DDSS system.
+#### Using pip
+```bash
+pip install ddss
+ddss
+```
+
+### TypeScript Version
 
-### Using pip
+#### Using npx (Recommended)
+```bash
+npx @hzhangxyz/ddss
+```
 
+#### Using npm
 ```bash
-pip install ddss
+npm install -g @hzhangxyz/ddss
 ddss
 ```
 
 ## Usage
 
+The usage, command-line options, and interactive syntax are identical regardless of the implementation language used.
+
 ### Basic Usage
 
 Run DDSS with a temporary SQLite database:

package/dist/index.js

@@ -1,100 +1,74 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
-import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Command } from 'commander';
 import { Sequelize, DataTypes, Model, Op } from 'sequelize';
 import { Search as Search$1, Term, List, Rule } from 'atsds';
+import { stdout, stdin } from 'node:process';
+import { unparse, parse } from 'atsds-bnf';
 import { EGraph } from 'atsds-egg';
 import * as readline from 'node:readline/promises';
-import { stdout, stdin } from 'node:process';
-import { parse, unparse } from 'atsds-bnf';
-import * as readline$1 from 'node:readline';
 
-// 定义基础模型类
 class Fact extends Model {
 }
 class Idea extends Model {
 }
 async function initializeDatabase(addr) {
-    // 转换地址：Python 的 sqlite:///path 转为 Sequelize 的 sqlite:path
-    let sequelizeAddr = addr;
-    if (addr.startsWith("sqlite:///")) {
-        sequelizeAddr = `sqlite:${addr.replace("sqlite:///", "")}`;
-    }
-    const sequelize = new Sequelize(sequelizeAddr, {
-        logging: false,
-        define: {
-            timestamps: false, // 去掉 createdAt 和 updatedAt
-        },
-    });
+    const sequelize = new Sequelize(addr, { logging: false });
     Fact.init({
         id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
         data: { type: DataTypes.TEXT, unique: true, allowNull: false },
-    }, { sequelize, tableName: "facts" });
+    }, { sequelize, tableName: "facts", timestamps: false });
     Idea.init({
         id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
         data: { type: DataTypes.TEXT, unique: true, allowNull: false },
-    }, { sequelize, tableName: "ideas" });
+    }, { sequelize, tableName: "ideas", timestamps: false });
     await sequelize.sync();
     return sequelize;
 }
-/**
- * 对应 Python 中的 insert_or_ignore。
- * Sequelize 的 bulkCreate 配合 ignoreDuplicates 可以实现跨方言的“重复则跳过”。
- */
 async function insertOrIgnore(model, data) {
-    try {
-        await model.bulkCreate([{ data }], {
-            ignoreDuplicates: true,
-        });
-    }
-    catch (error) {
-        // 忽略重复键错误
-    }
+    await model.bulkCreate([{ data }], {
+        ignoreDuplicates: true,
+    });
 }
 
 function strRuleGetStrIdea(data) {
     if (!data.startsWith("--")) {
         const lines = data.split("\n");
-        if (lines.length > 0) {
-            return `----\n${lines[0]}\n`;
-        }
+        return `----\n${lines[0]}\n`;
     }
     return null;
 }
-/**
- * Patches process.stdout.write to prevent asynchronous logs from messing up the readline prompt.
- */
 function patchStdout(rl) {
-    const originalWrite = process.stdout.write;
+    const originalWrite = stdout.write;
     let isReprompting = false;
     // @ts-ignore
-    process.stdout.write = (chunk, encoding, callback) => {
+    stdout.write = (chunk, encoding, callback) => {
+        // (1) Use original write when reprompting to avoid infinite recursion
+        // since rl.prompt() internally calls stdout.write.
         if (isReprompting) {
-            return originalWrite.call(process.stdout, chunk, encoding, callback);
-        }
-        const str = chunk.toString();
-        // If it's just a newline (like when the user hits Enter), let it pass through.
-        // This allows the input line to stay in the terminal history.
-        if (str === "\n" || str === "\r\n") {
-            return originalWrite.call(process.stdout, chunk, encoding, callback);
-        }
-        if (str.includes("\n")) {
-            // Move to start of line and clear it (wiping the current prompt display)
-            originalWrite.call(process.stdout, "\r\x1b[K");
-            const result = originalWrite.call(process.stdout, chunk, encoding, callback);
+            return originalWrite.call(stdout, chunk, encoding, callback);
+        }
+        // (2) Let normal newlines (e.g., from user pressing Enter) pass through
+        // without triggering the reprompting logic.
+        if (chunk === "\n" || chunk === "\r\n") {
+            return originalWrite.call(stdout, chunk, encoding, callback);
+        }
+        if (chunk.includes("\n")) {
+            // Move cursor to the start of the line.
+            originalWrite.call(stdout, "\r");
+            const result = originalWrite.call(stdout, chunk, encoding, callback);
             isReprompting = true;
-            // Redraw the prompt and current input buffer on the NEW line
-            rl.prompt(true);
+            rl.prompt();
             isReprompting = false;
             return result;
         }
-        return originalWrite.call(process.stdout, chunk, encoding, callback);
+        return originalWrite.call(stdout, chunk, encoding, callback);
     };
     return () => {
         // @ts-ignore
-        process.stdout.write = originalWrite;
+        stdout.write = originalWrite;
     };
 }
 
@@ -102,42 +76,50 @@ async function main$5(addr, sequelize) {
     if (!sequelize) {
         sequelize = await initializeDatabase(addr);
     }
-    try {
-        const search = new Search$1();
-        let maxFact = -1;
-        while (true) {
-            const begin = Date.now();
-            let count = 0;
-            const newFacts = await Fact.findAll({
-                where: { id: { [Op.gt]: maxFact } },
-                order: [["id", "ASC"]],
-            });
-            for (const fact of newFacts) {
-                maxFact = Math.max(maxFact, fact.id);
-                search.add(fact.data);
-            }
-            const tasks = [];
-            const handler = (rule) => {
-                const dsStr = rule.toString();
-                tasks.push(insertOrIgnore(Fact, dsStr));
-                const idea = strRuleGetStrIdea(dsStr);
-                if (idea) {
-                    tasks.push(insertOrIgnore(Idea, idea));
-                }
-                return false;
-            };
-            count = search.execute(handler);
-            await Promise.all(tasks);
-            const end = Date.now();
-            const duration = (end - begin) / 1000;
-            if (count === 0) {
-                const delay = Math.max(0, 0.1 - duration);
-                await new Promise((resolve) => setTimeout(resolve, delay * 1000));
+    const search = new Search$1();
+    let maxFact = -1;
+    while (true) {
+        const begin = Date.now();
+        let count = 0;
+        const newFacts = await Fact.findAll({
+            where: { id: { [Op.gt]: maxFact } },
+        });
+        for (const fact of newFacts) {
+            maxFact = Math.max(maxFact, fact.id);
+            search.add(fact.data);
+        }
+        const tasks = [];
+        const handler = (rule) => {
+            const dsStr = rule.toString();
+            tasks.push(insertOrIgnore(Fact, dsStr));
+            const idea = strRuleGetStrIdea(dsStr);
+            if (idea) {
+                tasks.push(insertOrIgnore(Idea, idea));
             }
+            return false;
+        };
+        count = search.execute(handler);
+        await Promise.all(tasks);
+        const end = Date.now();
+        const duration = (end - begin) / 1000;
+        if (count === 0) {
+            const delay = Math.max(0, 0.1 - duration);
+            await new Promise((resolve) => setTimeout(resolve, delay * 1000));
         }
     }
-    catch (err) {
-        // Handle error
+}
+
+async function main$4(addr, sequelize) {
+    if (!sequelize) {
+        sequelize = await initializeDatabase(addr);
+    }
+    const ideas = await Idea.findAll();
+    for (const idea of ideas) {
+        console.log("idea:", unparse(idea.data));
+    }
+    const facts = await Fact.findAll();
+    for (const fact of facts) {
+        console.log("fact:", unparse(fact.data));
     }
 }
 
@@ -153,7 +135,6 @@ function extractLhsRhsFromRule(data) {
     if (!(inner instanceof List)) {
         return null;
     }
-    // (binary == lhs rhs) -> list of 4 elements: "binary", "==", lhs, rhs
     if (!(inner.length() === 4 && inner.getitem(0).toString() === "binary" && inner.getitem(1).toString() === "==")) {
         return null;
     }
@@ -177,8 +158,7 @@ class InternalEGraph {
         return this.mapping.get(key);
     }
     find(data) {
-        const dataId = this.getOrAdd(data);
-        return this.core.find(dataId);
+        return this.core.find(this.getOrAdd(data));
     }
     setEquality(lhs, rhs) {
         const lhsId = this.getOrAdd(lhs);
@@ -211,22 +191,24 @@ class Search {
     }
     rebuild() {
         this.egraph.rebuild();
+        const newlyAddedTermsList = Array.from(this.newlyAddedTerms).map((s) => new Term(s));
         for (const factStr of this.facts) {
             const fact = new Term(factStr);
             if (!this.factMatchingCache.has(factStr)) {
                 this.factMatchingCache.set(factStr, new Set());
             }
-            const candidates = this.collectMatchingCandidates(fact, Array.from(this.newlyAddedTerms).map((s) => new Term(s)));
+            const candidates = this.collectMatchingCandidates(fact, newlyAddedTermsList);
             for (const c of candidates) {
                 this.factMatchingCache.get(factStr).add(c.toString());
             }
         }
+        const termsList = Array.from(this.terms).map((s) => new Term(s));
         for (const factStr of this.newlyAddedFacts) {
             const fact = new Term(factStr);
             if (!this.factMatchingCache.has(factStr)) {
                 this.factMatchingCache.set(factStr, new Set());
             }
-            const candidates = this.collectMatchingCandidates(fact, Array.from(this.terms).map((s) => new Term(s)));
+            const candidates = this.collectMatchingCandidates(fact, termsList);
             for (const c of candidates) {
                 this.factMatchingCache.get(factStr).add(c.toString());
             }
@@ -270,8 +252,9 @@ class Search {
         if (this.egraph.getEquality(lhs, rhs)) {
             yield data;
         }
-        const lhsPool = this.collectMatchingCandidates(lhs, Array.from(this.terms).map((s) => new Term(s)));
-        const rhsPool = this.collectMatchingCandidates(rhs, Array.from(this.terms).map((s) => new Term(s)));
+        const termsList = Array.from(this.terms).map((s) => new Term(s));
+        const lhsPool = this.collectMatchingCandidates(lhs, termsList);
+        const rhsPool = this.collectMatchingCandidates(rhs, termsList);
         if (lhsPool.length === 0 || rhsPool.length === 0)
             return;
         const lhsGroups = this.groupByEquivalenceClass(lhsPool);
@@ -311,7 +294,8 @@ class Search {
                 yield data;
             }
         }
-        const ideaPool = this.collectMatchingCandidates(idea, Array.from(this.terms).map((s) => new Term(s)));
+        const termsList = Array.from(this.terms).map((s) => new Term(s));
+        const ideaPool = this.collectMatchingCandidates(idea, termsList);
         if (ideaPool.length === 0)
             return;
         const ideaGroups = this.groupByEquivalenceClass(ideaPool);
@@ -338,7 +322,7 @@ class Search {
                                         const result = target.ground(unification, "1");
                                         if (result) {
                                             const inner = result.term();
-                                            if (inner instanceof List && inner.length() >= 3) {
+                                            if (inner instanceof List) {
                                                 yield buildTermToRule(inner.getitem(2));
                                             }
                                         }
@@ -359,7 +343,7 @@ class Search {
             return [];
         const eidToTerms = new Map();
         for (const term of terms) {
-            const eid = this.egraph.find(term);
+            const eid = this.egraph.find(term).toString();
             if (!eidToTerms.has(eid)) {
                 eidToTerms.set(eid, new Set());
             }
@@ -369,227 +353,176 @@ class Search {
     }
 }
 
-async function main$4(addr, sequelize) {
+async function main$3(addr, sequelize) {
     if (!sequelize) {
         sequelize = await initializeDatabase(addr);
     }
-    try {
-        const search = new Search();
-        let pool = [];
-        let maxFact = -1;
-        let maxIdea = -1;
-        while (true) {
-            const begin = Date.now();
-            let count = 0;
-            const newIdeas = await Idea.findAll({
-                where: { id: { [Op.gt]: maxIdea } },
-                order: [["id", "ASC"]],
-            });
-            for (const idea of newIdeas) {
-                maxIdea = Math.max(maxIdea, idea.id);
-                pool.push(new Rule(idea.data));
-            }
-            const newFacts = await Fact.findAll({
-                where: { id: { [Op.gt]: maxFact } },
-                order: [["id", "ASC"]],
-            });
-            for (const fact of newFacts) {
-                maxFact = Math.max(maxFact, fact.id);
-                search.add(new Rule(fact.data));
-            }
-            search.rebuild();
-            const tasks = [];
-            const nextPool = [];
-            for (const i of pool) {
-                let found = false;
-                for (const o of search.execute(i)) {
-                    tasks.push(insertOrIgnore(Fact, o.toString()));
-                    count++;
-                    if (i.toString() === o.toString()) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    nextPool.push(i);
+    const search = new Search();
+    let pool = [];
+    let maxFact = -1;
+    let maxIdea = -1;
+    while (true) {
+        const begin = Date.now();
+        let count = 0;
+        const newIdeas = await Idea.findAll({
+            where: { id: { [Op.gt]: maxIdea } },
+        });
+        for (const idea of newIdeas) {
+            maxIdea = Math.max(maxIdea, idea.id);
+            pool.push(new Rule(idea.data));
+        }
+        const newFacts = await Fact.findAll({
+            where: { id: { [Op.gt]: maxFact } },
+        });
+        for (const fact of newFacts) {
+            maxFact = Math.max(maxFact, fact.id);
+            search.add(new Rule(fact.data));
+        }
+        search.rebuild();
+        const tasks = [];
+        const nextPool = [];
+        for (const i of pool) {
+            let found = false;
+            for (const o of search.execute(i)) {
+                tasks.push(insertOrIgnore(Fact, o.toString()));
+                count++;
+                if (i.toString() === o.toString()) {
+                    found = true;
+                    break;
                 }
             }
-            pool = nextPool;
-            await Promise.all(tasks);
-            const end = Date.now();
-            const duration = (end - begin) / 1000;
-            if (count === 0) {
-                const delay = Math.max(0, 0.1 - duration);
-                await new Promise((resolve) => setTimeout(resolve, delay * 1000));
+            if (!found) {
+                nextPool.push(i);
             }
         }
-    }
-    catch (err) {
-        // Handle error
+        pool = nextPool;
+        await Promise.all(tasks);
+        const end = Date.now();
+        const duration = (end - begin) / 1000;
+        if (count === 0) {
+            const delay = Math.max(0, 0.1 - duration);
+            await new Promise((resolve) => setTimeout(resolve, delay * 1000));
+        }
     }
 }
 
-async function main$3(addr, sequelize) {
+async function main$2(addr, sequelize) {
     if (!sequelize) {
         sequelize = await initializeDatabase(addr);
     }
     const rl = readline.createInterface({ input: stdin, output: stdout });
     rl.setPrompt("input: ");
     const unpatch = patchStdout(rl);
-    try {
-        rl.prompt(); // Initial prompt
-        for await (const line of rl) {
-            const data = line.trim();
-            if (data === "" || data.startsWith("//")) {
-                rl.prompt();
-                continue;
-            }
-            try {
-                const ds = parse(data);
-                const dsStr = ds.toString();
-                await insertOrIgnore(Fact, dsStr);
-                const idea = strRuleGetStrIdea(dsStr);
-                if (idea) {
-                    await insertOrIgnore(Idea, idea);
-                }
-            }
-            catch (e) {
-                console.error(`error: ${e}`);
-            }
+    rl.prompt();
+    for await (const line of rl) {
+        const data = line.trim();
+        if (data === "" || data.startsWith("//")) {
             rl.prompt();
+            continue;
         }
-    }
-    catch (err) {
-        // Silent catch for unexpected termination
-    }
-    finally {
-        unpatch();
-        rl.close();
-    }
-}
-
-async function main$2(addr, sequelize) {
-    if (!sequelize) {
-        sequelize = await initializeDatabase(addr);
-    }
-    try {
-        let maxFact = -1;
-        let maxIdea = -1;
-        while (true) {
-            const begin = Date.now();
-            let count = 0;
-            const newIdeas = await Idea.findAll({
-                where: { id: { [Op.gt]: maxIdea } },
-                order: [["id", "ASC"]],
-            });
-            for (const idea of newIdeas) {
-                maxIdea = Math.max(maxIdea, idea.id);
-                console.log("idea:", unparse(idea.data));
-                count++;
-            }
-            const newFacts = await Fact.findAll({
-                where: { id: { [Op.gt]: maxFact } },
-                order: [["id", "ASC"]],
-            });
-            for (const fact of newFacts) {
-                maxFact = Math.max(maxFact, fact.id);
-                console.log("fact:", unparse(fact.data));
-                count++;
-            }
-            const end = Date.now();
-            const duration = (end - begin) / 1000;
-            if (count === 0) {
-                const delay = Math.max(0, 0.1 - duration);
-                await new Promise((resolve) => setTimeout(resolve, delay * 1000));
+        try {
+            const ds = parse(data);
+            const dsStr = ds.toString();
+            await insertOrIgnore(Fact, dsStr);
+            const idea = strRuleGetStrIdea(dsStr);
+            if (idea) {
+                await insertOrIgnore(Idea, idea);
             }
         }
+        catch (e) {
+            console.error(`error: ${e}`);
+        }
+        rl.prompt();
     }
-    catch (err) {
-        // Handle error
-    }
+    unpatch();
+    rl.close();
 }
 
 async function main$1(addr, sequelize) {
     if (!sequelize) {
         sequelize = await initializeDatabase(addr);
     }
-    const rl = readline$1.createInterface({
-        input: process.stdin,
+    const rl = readline.createInterface({
+        input: stdin,
         terminal: false,
     });
-    try {
-        for await (const line of rl) {
-            const data = line.trim();
-            if (data === "" || data.startsWith("//")) {
-                continue;
-            }
-            try {
-                const ds = parse(data);
-                const dsStr = ds.toString();
-                await insertOrIgnore(Fact, dsStr);
-                const idea = strRuleGetStrIdea(dsStr);
-                if (idea) {
-                    await insertOrIgnore(Idea, idea);
-                }
-            }
-            catch (e) {
-                console.error(`error: ${e}`);
+    for await (const line of rl) {
+        const data = line.trim();
+        if (data === "" || data.startsWith("//")) {
+            continue;
+        }
+        try {
+            const ds = parse(data);
+            const dsStr = ds.toString();
+            await insertOrIgnore(Fact, dsStr);
+            const idea = strRuleGetStrIdea(dsStr);
+            if (idea) {
+                await insertOrIgnore(Idea, idea);
             }
         }
+        catch (e) {
+            console.error(`error: ${e}`);
+        }
     }
-    finally {
-        rl.close();
-    }
+    rl.close();
 }
 
 async function main(addr, sequelize) {
     if (!sequelize) {
         sequelize = await initializeDatabase(addr);
     }
-    try {
-        const ideas = await Idea.findAll();
-        for (const idea of ideas) {
+    let maxFact = -1;
+    let maxIdea = -1;
+    while (true) {
+        const begin = Date.now();
+        let count = 0;
+        const newIdeas = await Idea.findAll({
+            where: { id: { [Op.gt]: maxIdea } },
+        });
+        for (const idea of newIdeas) {
+            maxIdea = Math.max(maxIdea, idea.id);
             console.log("idea:", unparse(idea.data));
+            count++;
         }
-        const facts = await Fact.findAll();
-        for (const fact of facts) {
+        const newFacts = await Fact.findAll({
+            where: { id: { [Op.gt]: maxFact } },
+        });
+        for (const fact of newFacts) {
+            maxFact = Math.max(maxFact, fact.id);
             console.log("fact:", unparse(fact.data));
+            count++;
+        }
+        const end = Date.now();
+        const duration = (end - begin) / 1000;
+        if (count === 0) {
+            const delay = Math.max(0, 0.1 - duration);
+            await new Promise((resolve) => setTimeout(resolve, delay * 1000));
         }
-    }
-    finally {
-        // Session is handled by main or caller
     }
 }
 
 const componentMap = {
     ds: main$5,
-    egg: main$4,
-    input: main$3,
-    output: main$2,
+    egg: main$3,
+    input: main$2,
+    output: main,
     load: main$1,
-    dump: main,
+    dump: main$4,
 };
 async function run(addr, components) {
-    const sequelize = await initializeDatabase(addr);
-    try {
-        const promises = components.map((name) => {
-            const component = componentMap[name];
-            if (!component) {
-                console.error(`error: unsupported component: ${name}`);
-                process.exit(1);
-            }
-            return component(addr, sequelize);
-        });
-        // Run all components in parallel.
-        // Note: Some components like input/output run forever.
-        await Promise.all(promises);
-    }
-    catch (err) {
-        // Handle error
-    }
-    finally {
-        await sequelize.close();
+    for (const name of components) {
+        if (!(name in componentMap)) {
+            console.error(`error: unsupported component: ${name}`);
+            return;
+        }
     }
+    const sequelize = await initializeDatabase(addr);
+    const promises = components.map((name) => {
+        const component = componentMap[name];
+        return component(addr, sequelize);
+    });
+    await Promise.race(promises);
+    await sequelize.close();
 }
 function cli() {
     const program = new Command();
@@ -600,13 +533,29 @@ function cli() {
         .option("-c, --component <names...>", "Components to run.", ["input", "output", "ds", "egg"])
         .action(async (options) => {
         let addr = options.addr;
+        let tmpDir;
         if (!addr) {
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ddss-"));
+            tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "ddss-"));
             const dbPath = path.join(tmpDir, "ddss.db");
             addr = `sqlite:///${dbPath}`;
         }
+        if (addr.startsWith("sqlite://")) {
+            addr = addr.replace("sqlite:///", "sqlite:");
+        }
+        else if (addr.startsWith("mysql:///")) ;
+        else if (addr.startsWith("mariadb://")) ;
+        else if (addr.startsWith("postgresql://")) {
+            addr = addr.replace("postgresql://", "postgres://");
+        }
+        else {
+            console.error(`error: unsupported database: ${addr}`);
+            return;
+        }
         console.log(`addr: ${addr}`);
         await run(addr, options.component);
+        if (tmpDir) {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
     });
     program.parse();
 }

package/package.json

@@ -15,22 +15,34 @@
         "dist/index.js"
     ],
     "scripts": {
-        "build": "rollup --config rollup.config.js"
+        "rollup": "rollup --config rollup.config.js",
+        "build": "run-s rollup",
+        "test": "cross-env NODE_OPTIONS='$NODE_OPTIONS --experimental-vm-modules' jest --config=jest.config.js",
+        "all": "run-s build test"
     },
     "dependencies": {
-        "atsds": "^0.0.12",
-        "atsds-bnf": "^0.0.12",
-        "atsds-egg": "^0.0.12",
+        "atsds": "^0.0.13",
+        "atsds-bnf": "^0.0.13",
+        "atsds-egg": "^0.0.13",
         "commander": "^14.0.2",
+        "mariadb": "^3.4.5",
+        "mysql2": "^3.16.0",
+        "pg": "^8.16.3",
         "sequelize": "^6.37.7",
         "sqlite3": "^5.1.7"
     },
     "devDependencies": {
         "@rollup/plugin-typescript": "^12.3.0",
+        "@types/jest": "^30.0.0",
         "@types/node": "^25.0.3",
+        "cross-env": "^10.1.0",
+        "jest": "^30.2.0",
+        "npm-run-all": "^4.1.5",
         "rollup": "^4.54.0",
+        "ts-jest": "^29.4.6",
+        "ts-node": "^10.9.2",
         "tslib": "^2.8.1",
         "typescript": "^5.9.3"
     },
-    "version": "0.0.29"
+    "version": "0.0.30"
 }