@hzhangxyz/ddss 0.0.10 → 0.0.29

package/dist/index.js

@@ -0,0 +1,617 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+import { Sequelize, DataTypes, Model, Op } from 'sequelize';
+import { Search as Search$1, Term, List, Rule } from 'atsds';
+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
+        },
+    });
+    Fact.init({
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+        data: { type: DataTypes.TEXT, unique: true, allowNull: false },
+    }, { sequelize, tableName: "facts" });
+    Idea.init({
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+        data: { type: DataTypes.TEXT, unique: true, allowNull: false },
+    }, { sequelize, tableName: "ideas" });
+    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) {
+        // 忽略重复键错误
+    }
+}
+
+function strRuleGetStrIdea(data) {
+    if (!data.startsWith("--")) {
+        const lines = data.split("\n");
+        if (lines.length > 0) {
+            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;
+    let isReprompting = false;
+    // @ts-ignore
+    process.stdout.write = (chunk, encoding, callback) => {
+        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);
+            isReprompting = true;
+            // Redraw the prompt and current input buffer on the NEW line
+            rl.prompt(true);
+            isReprompting = false;
+            return result;
+        }
+        return originalWrite.call(process.stdout, chunk, encoding, callback);
+    };
+    return () => {
+        // @ts-ignore
+        process.stdout.write = originalWrite;
+    };
+}
+
+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));
+            }
+        }
+    }
+    catch (err) {
+        // Handle error
+    }
+}
+
+function buildTermToRule(data) {
+    return new Rule(`----\n${data.toString()}\n`);
+}
+function extractLhsRhsFromRule(data) {
+    if (data.length() !== 0) {
+        return null;
+    }
+    const term = data.conclusion();
+    const inner = term.term();
+    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;
+    }
+    return [inner.getitem(2), inner.getitem(3)];
+}
+function buildLhsRhsToTerm(lhs, rhs) {
+    return new Term(`(binary == ${lhs.toString()} ${rhs.toString()})`);
+}
+class InternalEGraph {
+    core;
+    mapping;
+    constructor() {
+        this.core = new EGraph();
+        this.mapping = new Map();
+    }
+    getOrAdd(data) {
+        const key = data.toString();
+        if (!this.mapping.has(key)) {
+            this.mapping.set(key, this.core.add(data));
+        }
+        return this.mapping.get(key);
+    }
+    find(data) {
+        const dataId = this.getOrAdd(data);
+        return this.core.find(dataId);
+    }
+    setEquality(lhs, rhs) {
+        const lhsId = this.getOrAdd(lhs);
+        const rhsId = this.getOrAdd(rhs);
+        this.core.merge(lhsId, rhsId);
+    }
+    getEquality(lhs, rhs) {
+        const lhsId = this.getOrAdd(lhs);
+        const rhsId = this.getOrAdd(rhs);
+        return this.core.find(lhsId) === this.core.find(rhsId);
+    }
+    rebuild() {
+        this.core.rebuild();
+    }
+}
+class Search {
+    egraph;
+    terms;
+    facts;
+    newlyAddedTerms;
+    newlyAddedFacts;
+    factMatchingCache;
+    constructor() {
+        this.egraph = new InternalEGraph();
+        this.terms = new Set();
+        this.facts = new Set();
+        this.newlyAddedTerms = new Set();
+        this.newlyAddedFacts = new Set();
+        this.factMatchingCache = new Map();
+    }
+    rebuild() {
+        this.egraph.rebuild();
+        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)));
+            for (const c of candidates) {
+                this.factMatchingCache.get(factStr).add(c.toString());
+            }
+        }
+        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)));
+            for (const c of candidates) {
+                this.factMatchingCache.get(factStr).add(c.toString());
+            }
+        }
+        this.newlyAddedTerms.clear();
+        this.newlyAddedFacts.clear();
+    }
+    add(data) {
+        this.addExpr(data);
+        this.addFact(data);
+    }
+    addExpr(data) {
+        const lhsRhs = extractLhsRhsFromRule(data);
+        if (!lhsRhs)
+            return;
+        const [lhs, rhs] = lhsRhs;
+        this.terms.add(lhs.toString());
+        this.newlyAddedTerms.add(lhs.toString());
+        this.terms.add(rhs.toString());
+        this.newlyAddedTerms.add(rhs.toString());
+        this.egraph.setEquality(lhs, rhs);
+    }
+    addFact(data) {
+        if (data.length() !== 0)
+            return;
+        const term = data.conclusion();
+        this.terms.add(term.toString());
+        this.newlyAddedTerms.add(term.toString());
+        this.facts.add(term.toString());
+        this.newlyAddedFacts.add(term.toString());
+    }
+    *execute(data) {
+        yield* this.executeExpr(data);
+        yield* this.executeFact(data);
+    }
+    *executeExpr(data) {
+        const lhsRhs = extractLhsRhsFromRule(data);
+        if (!lhsRhs)
+            return;
+        const [lhs, rhs] = lhsRhs;
+        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)));
+        if (lhsPool.length === 0 || rhsPool.length === 0)
+            return;
+        const lhsGroups = this.groupByEquivalenceClass(lhsPool);
+        const rhsGroups = this.groupByEquivalenceClass(rhsPool);
+        for (const lhsGroup of lhsGroups) {
+            for (const rhsGroup of rhsGroups) {
+                if (lhsGroup.size > 0 && rhsGroup.size > 0) {
+                    const firstLhs = new Term(lhsGroup.values().next().value);
+                    const firstRhs = new Term(rhsGroup.values().next().value);
+                    if (this.egraph.getEquality(firstLhs, firstRhs)) {
+                        for (const xStr of lhsGroup) {
+                            for (const yStr of rhsGroup) {
+                                const x = new Term(xStr);
+                                const y = new Term(yStr);
+                                const target = buildLhsRhsToTerm(x, y);
+                                const query = data.conclusion();
+                                const unification = target.match(query);
+                                if (unification) {
+                                    const result = target.ground(unification, "1");
+                                    if (result) {
+                                        yield buildTermToRule(result);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    *executeFact(data) {
+        if (data.length() !== 0)
+            return;
+        const idea = data.conclusion();
+        for (const factStr of this.facts) {
+            if (this.egraph.getEquality(idea, new Term(factStr))) {
+                yield data;
+            }
+        }
+        const ideaPool = this.collectMatchingCandidates(idea, Array.from(this.terms).map((s) => new Term(s)));
+        if (ideaPool.length === 0)
+            return;
+        const ideaGroups = this.groupByEquivalenceClass(ideaPool);
+        for (const factStr of this.facts) {
+            const factPoolStr = this.factMatchingCache.get(factStr);
+            if (!factPoolStr || factPoolStr.size === 0)
+                continue;
+            const factPool = Array.from(factPoolStr).map((s) => new Term(s));
+            const factGroups = this.groupByEquivalenceClass(factPool);
+            for (const ideaGroup of ideaGroups) {
+                for (const factGroup of factGroups) {
+                    if (ideaGroup.size > 0 && factGroup.size > 0) {
+                        const firstIdea = new Term(ideaGroup.values().next().value);
+                        const firstFact = new Term(factGroup.values().next().value);
+                        if (this.egraph.getEquality(firstIdea, firstFact)) {
+                            for (const xStr of ideaGroup) {
+                                for (const yStr of factGroup) {
+                                    const x = new Term(xStr);
+                                    const y = new Term(yStr);
+                                    const target = buildLhsRhsToTerm(x, y);
+                                    const query = buildLhsRhsToTerm(idea, new Term(factStr));
+                                    const unification = target.match(query);
+                                    if (unification) {
+                                        const result = target.ground(unification, "1");
+                                        if (result) {
+                                            const inner = result.term();
+                                            if (inner instanceof List && inner.length() >= 3) {
+                                                yield buildTermToRule(inner.getitem(2));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    collectMatchingCandidates(pattern, candidates) {
+        return candidates.filter((c) => pattern.match(c) !== null);
+    }
+    groupByEquivalenceClass(terms) {
+        if (terms.length === 0)
+            return [];
+        const eidToTerms = new Map();
+        for (const term of terms) {
+            const eid = this.egraph.find(term);
+            if (!eidToTerms.has(eid)) {
+                eidToTerms.set(eid, new Set());
+            }
+            eidToTerms.get(eid).add(term.toString());
+        }
+        return Array.from(eidToTerms.values());
+    }
+}
+
+async function main$4(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);
+                }
+            }
+            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));
+            }
+        }
+    }
+    catch (err) {
+        // Handle error
+    }
+}
+
+async function main$3(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();
+        }
+    }
+    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));
+            }
+        }
+    }
+    catch (err) {
+        // Handle error
+    }
+}
+
+async function main$1(addr, sequelize) {
+    if (!sequelize) {
+        sequelize = await initializeDatabase(addr);
+    }
+    const rl = readline$1.createInterface({
+        input: process.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}`);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+
+async function main(addr, sequelize) {
+    if (!sequelize) {
+        sequelize = await initializeDatabase(addr);
+    }
+    try {
+        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));
+        }
+    }
+    finally {
+        // Session is handled by main or caller
+    }
+}
+
+const componentMap = {
+    ds: main$5,
+    egg: main$4,
+    input: main$3,
+    output: main$2,
+    load: main$1,
+    dump: main,
+};
+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();
+    }
+}
+function cli() {
+    const program = new Command();
+    program
+        .name("ddss")
+        .description("DDSS - Distributed Deductive System Sorts: Run DDSS with an interactive deductive environment.")
+        .option("-a, --addr <url>", "Database address URL. If not provided, uses a temporary SQLite database.")
+        .option("-c, --component <names...>", "Components to run.", ["input", "output", "ds", "egg"])
+        .action(async (options) => {
+        let addr = options.addr;
+        if (!addr) {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ddss-"));
+            const dbPath = path.join(tmpDir, "ddss.db");
+            addr = `sqlite:///${dbPath}`;
+        }
+        console.log(`addr: ${addr}`);
+        await run(addr, options.component);
+    });
+    program.parse();
+}
+if (import.meta.main) {
+    cli();
+}
+
+export { cli };

package/package.json

@@ -1,35 +1,36 @@
 {
     "name": "@hzhangxyz/ddss",
+    "description": "Distributed Deductive System Sorts",
+    "author": "Hao Zhang <hzhangxyz@outlook.com>",
     "license": "AGPL-3.0-or-later",
-    "version": "0.0.10",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/USTC-KnowledgeComputingLab/ddss.git"
+    },
     "type": "module",
-    "bin": "dist/main.js",
-    "main": "dist/main.js",
-    "module": "dist/main.js",
+    "bin": {
+        "ddss": "./dist/index.js"
+    },
     "files": [
-        "dist/main.js"
+        "dist/index.js"
     ],
     "scripts": {
-        "proto": "protoc --plugin=./node_modules/.bin/protoc-gen-ts_proto --ts_proto_out=. --ts_proto_opt=outputServices=grpc-js,env=node ./ddss.proto",
-        "rollup": "rollup -c rollup.config.js",
-        "build": "run-s proto rollup"
+        "build": "rollup --config rollup.config.js"
+    },
+    "dependencies": {
+        "atsds": "^0.0.12",
+        "atsds-bnf": "^0.0.12",
+        "atsds-egg": "^0.0.12",
+        "commander": "^14.0.2",
+        "sequelize": "^6.37.7",
+        "sqlite3": "^5.1.7"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.3.8",
-        "@bufbuild/protobuf": "^2.10.2",
-        "@grpc/grpc-js": "^1.14.3",
-        "@rollup/plugin-commonjs": "^29.0.0",
-        "@rollup/plugin-json": "^6.1.0",
-        "@rollup/plugin-node-resolve": "^16.0.3",
-        "@rollup/plugin-terser": "^0.4.4",
         "@rollup/plugin-typescript": "^12.3.0",
-        "@types/node": "^25.0.2",
-        "atsds": "^0.0.7",
-        "atsds-bnf": "^0.0.7",
-        "npm-run-all": "^4.1.5",
-        "rollup": "^4.53.3",
-        "ts-proto": "^2.8.3",
+        "@types/node": "^25.0.3",
+        "rollup": "^4.54.0",
         "tslib": "^2.8.1",
         "typescript": "^5.9.3"
-    }
+    },
+    "version": "0.0.29"
 }