sonobat 0.1.0 → 0.2.0

package/dist/index.js

@@ -245,6 +245,22 @@ CREATE TABLE IF NOT EXISTS cves (
 
 CREATE INDEX IF NOT EXISTS idx_cves_vuln ON cves(vulnerability_id);
 CREATE INDEX IF NOT EXISTS idx_cves_cveid ON cves(cve_id);
+
+-- ============================================================
+-- Datalog \u30EB\u30FC\u30EB\u4FDD\u5B58
+-- ============================================================
+CREATE TABLE IF NOT EXISTS datalog_rules (
+  id            TEXT PRIMARY KEY,
+  name          TEXT NOT NULL UNIQUE,
+  description   TEXT,
+  rule_text     TEXT NOT NULL,
+  generated_by  TEXT NOT NULL,            -- "human" | "ai" | "preset"
+  is_preset     INTEGER NOT NULL DEFAULT 0,
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_datalog_rules_name ON datalog_rules(name);
 `;
 
 // src/db/migrate.ts
@@ -1667,8 +1683,8 @@ function processFinding(finding, result, seenHosts, seenServices) {
       const cve = {
         vulnerabilityTitle: info.name,
         cveId,
-        cvssScore: classification["cvss-score"],
-        cvssVector: classification["cvss-metrics"]
+        cvssScore: typeof classification["cvss-score"] === "number" ? classification["cvss-score"] : void 0,
+        cvssVector: typeof classification["cvss-metrics"] === "string" ? classification["cvss-metrics"] : void 0
       };
       result.cves.push(cve);
     }
@@ -2190,6 +2206,7 @@ function propose(db2, hostId) {
   const serviceRepo = new ServiceRepository(db2);
   const httpEndpointRepo = new HttpEndpointRepository(db2);
   const inputRepo = new InputRepository(db2);
+  const endpointInputRepo = new EndpointInputRepository(db2);
   const observationRepo = new ObservationRepository(db2);
   const vhostRepo = new VhostRepository(db2);
   const vulnRepo = new VulnerabilityRepository(db2);
@@ -2227,6 +2244,7 @@ function propose(db2, hostId) {
         baseUri,
         httpEndpointRepo,
         inputRepo,
+        endpointInputRepo,
         observationRepo,
         vhostRepo,
         vulnRepo
@@ -2235,7 +2253,7 @@ function propose(db2, hostId) {
   }
   return actions;
 }
-function proposeForHttpService(actions, host, service, baseUri, httpEndpointRepo, inputRepo, observationRepo, vhostRepo, vulnRepo) {
+function proposeForHttpService(actions, host, service, baseUri, httpEndpointRepo, inputRepo, endpointInputRepo, observationRepo, vhostRepo, vulnRepo) {
   const endpoints = httpEndpointRepo.findByServiceId(service.id);
   if (endpoints.length === 0) {
     actions.push({
@@ -2245,16 +2263,21 @@ function proposeForHttpService(actions, host, service, baseUri, httpEndpointRepo
       params: { hostId: host.id, serviceId: service.id }
     });
   }
+  const vulns = vulnRepo.findByServiceId(service.id);
   for (const endpoint of endpoints) {
-    const inputs = inputRepo.findByServiceId(service.id);
-    if (inputs.length === 0) {
+    const endpointInputs = endpointInputRepo.findByEndpointId(endpoint.id);
+    if (endpointInputs.length === 0) {
       actions.push({
         kind: "parameter_discovery",
         description: `Discover input parameters for ${baseUri}${endpoint.path}`,
         params: { hostId: host.id, serviceId: service.id, endpointId: endpoint.id }
       });
     }
-    for (const input of inputs) {
+    for (const ei of endpointInputs) {
+      const input = inputRepo.findById(ei.inputId);
+      if (input === void 0) {
+        continue;
+      }
       const observations = observationRepo.findByInputId(input.id);
       if (observations.length === 0) {
         actions.push({
@@ -2267,6 +2290,17 @@ function proposeForHttpService(actions, host, service, baseUri, httpEndpointRepo
             inputId: input.id
           }
         });
+      } else if (vulns.length === 0) {
+        actions.push({
+          kind: "value_fuzz",
+          description: `Fuzz input "${input.name}" (${input.location}) on ${baseUri}${endpoint.path}`,
+          params: {
+            hostId: host.id,
+            serviceId: service.id,
+            endpointId: endpoint.id,
+            inputId: input.id
+          }
+        });
       }
     }
   }
@@ -2278,7 +2312,6 @@ function proposeForHttpService(actions, host, service, baseUri, httpEndpointRepo
       params: { hostId: host.id, serviceId: service.id }
     });
   }
-  const vulns = vulnRepo.findByServiceId(service.id);
   if (vulns.length === 0) {
     actions.push({
       kind: "nuclei_scan",
@@ -2429,6 +2462,1220 @@ function registerMutationTools(server2, db2) {
   );
 }
 
+// src/mcp/tools/datalog.ts
+import { z as z5 } from "zod";
+
+// src/engine/datalog/types.ts
+var DEFAULT_EVAL_CONFIG = {
+  maxIterations: 1e3,
+  maxTuples: 1e5,
+  maxRules: 200,
+  timeoutMs: 5e3
+};
+var DatalogError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DatalogError";
+  }
+};
+var DatalogSyntaxError = class extends DatalogError {
+  line;
+  col;
+  constructor(message, line, col) {
+    super(`Syntax error at ${line}:${col}: ${message}`);
+    this.name = "DatalogSyntaxError";
+    this.line = line;
+    this.col = col;
+  }
+};
+var DatalogSafetyError = class extends DatalogError {
+  constructor(message) {
+    super(message);
+    this.name = "DatalogSafetyError";
+  }
+};
+var DatalogResourceError = class extends DatalogError {
+  constructor(message) {
+    super(message);
+    this.name = "DatalogResourceError";
+  }
+};
+
+// src/engine/datalog/tokenizer.ts
+function tokenize(source) {
+  const tokens = [];
+  let pos = 0;
+  let line = 1;
+  let col = 1;
+  while (pos < source.length) {
+    const ch = source[pos];
+    if (ch === " " || ch === "	" || ch === "\r") {
+      pos++;
+      col++;
+      continue;
+    }
+    if (ch === "\n") {
+      pos++;
+      line++;
+      col = 1;
+      continue;
+    }
+    if (ch === "%") {
+      while (pos < source.length && source[pos] !== "\n") {
+        pos++;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      const startCol2 = col;
+      pos++;
+      col++;
+      let value = "";
+      while (pos < source.length && source[pos] !== '"') {
+        if (source[pos] === "\n") {
+          throw new DatalogSyntaxError("Unterminated string literal", line, startCol2);
+        }
+        if (source[pos] === "\\" && pos + 1 < source.length) {
+          pos++;
+          col++;
+          const escaped = source[pos];
+          if (escaped === '"') value += '"';
+          else if (escaped === "\\") value += "\\";
+          else if (escaped === "n") value += "\n";
+          else if (escaped === "t") value += "	";
+          else value += escaped;
+        } else {
+          value += source[pos];
+        }
+        pos++;
+        col++;
+      }
+      if (pos >= source.length) {
+        throw new DatalogSyntaxError("Unterminated string literal", line, startCol2);
+      }
+      pos++;
+      col++;
+      tokens.push({ kind: "STRING", value, line, col: startCol2 });
+      continue;
+    }
+    if (ch >= "0" && ch <= "9") {
+      const startCol2 = col;
+      let value = "";
+      while (pos < source.length && source[pos] >= "0" && source[pos] <= "9") {
+        value += source[pos];
+        pos++;
+        col++;
+      }
+      if (pos < source.length && source[pos] === "." && pos + 1 < source.length && source[pos + 1] >= "0" && source[pos + 1] <= "9") {
+        value += ".";
+        pos++;
+        col++;
+        while (pos < source.length && source[pos] >= "0" && source[pos] <= "9") {
+          value += source[pos];
+          pos++;
+          col++;
+        }
+      }
+      tokens.push({ kind: "NUMBER", value, line, col: startCol2 });
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      const startCol2 = col;
+      let value = "";
+      while (pos < source.length && isIdentPart(source[pos])) {
+        value += source[pos];
+        pos++;
+        col++;
+      }
+      if (value === "not") {
+        tokens.push({ kind: "NOT", value, line, col: startCol2 });
+      } else if (value === "_") {
+        tokens.push({ kind: "UNDERSCORE", value, line, col: startCol2 });
+      } else if (ch >= "A" && ch <= "Z") {
+        tokens.push({ kind: "VARIABLE", value, line, col: startCol2 });
+      } else {
+        tokens.push({ kind: "IDENT", value, line, col: startCol2 });
+      }
+      continue;
+    }
+    if (ch === "_") {
+      const startCol2 = col;
+      let value = "_";
+      pos++;
+      col++;
+      while (pos < source.length && isIdentPart(source[pos])) {
+        value += source[pos];
+        pos++;
+        col++;
+      }
+      if (value === "_") {
+        tokens.push({ kind: "UNDERSCORE", value, line, col: startCol2 });
+      } else {
+        tokens.push({ kind: "VARIABLE", value, line, col: startCol2 });
+      }
+      continue;
+    }
+    const startCol = col;
+    if (ch === "(") {
+      tokens.push({ kind: "LPAREN", value: "(", line, col: startCol });
+      pos++;
+      col++;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ kind: "RPAREN", value: ")", line, col: startCol });
+      pos++;
+      col++;
+      continue;
+    }
+    if (ch === ",") {
+      tokens.push({ kind: "COMMA", value: ",", line, col: startCol });
+      pos++;
+      col++;
+      continue;
+    }
+    if (ch === ".") {
+      tokens.push({ kind: "DOT", value: ".", line, col: startCol });
+      pos++;
+      col++;
+      continue;
+    }
+    if (ch === ":" && pos + 1 < source.length && source[pos + 1] === "-") {
+      tokens.push({ kind: "COLON_DASH", value: ":-", line, col: startCol });
+      pos += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === "?" && pos + 1 < source.length && source[pos + 1] === "-") {
+      tokens.push({ kind: "QUERY", value: "?-", line, col: startCol });
+      pos += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === "!" && pos + 1 < source.length && source[pos + 1] === "=") {
+      tokens.push({ kind: "NEQ", value: "!=", line, col: startCol });
+      pos += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === "<" && pos + 1 < source.length && source[pos + 1] === "=") {
+      tokens.push({ kind: "LTE", value: "<=", line, col: startCol });
+      pos += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === ">" && pos + 1 < source.length && source[pos + 1] === "=") {
+      tokens.push({ kind: "GTE", value: ">=", line, col: startCol });
+      pos += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === "<") {
+      tokens.push({ kind: "LT", value: "<", line, col: startCol });
+      pos++;
+      col++;
+      continue;
+    }
+    if (ch === ">") {
+      tokens.push({ kind: "GT", value: ">", line, col: startCol });
+      pos++;
+      col++;
+      continue;
+    }
+    if (ch === "=") {
+      tokens.push({ kind: "EQ", value: "=", line, col: startCol });
+      pos++;
+      col++;
+      continue;
+    }
+    throw new DatalogSyntaxError(`Unexpected character '${ch}'`, line, col);
+  }
+  tokens.push({ kind: "EOF", value: "", line, col });
+  return tokens;
+}
+function isIdentStart(ch) {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z";
+}
+function isIdentPart(ch) {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_";
+}
+
+// src/engine/datalog/parser.ts
+var COMPARISON_OPS = /* @__PURE__ */ new Set([
+  "EQ",
+  "NEQ",
+  "LT",
+  "GT",
+  "LTE",
+  "GTE"
+]);
+var TOKEN_TO_COMP_OP = {
+  EQ: "=",
+  NEQ: "!=",
+  LT: "<",
+  GT: ">",
+  LTE: "<=",
+  GTE: ">="
+};
+function parse(source) {
+  const tokens = tokenize(source);
+  const parser = new Parser(tokens);
+  return parser.parseProgram();
+}
+var Parser = class {
+  tokens;
+  pos;
+  anonCounter;
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.pos = 0;
+    this.anonCounter = 0;
+  }
+  // ===========================================================
+  // Token stream helpers
+  // ===========================================================
+  /** Return the current token without advancing. */
+  peek() {
+    return this.tokens[this.pos];
+  }
+  /** Advance and return the consumed token. */
+  advance() {
+    const token = this.tokens[this.pos];
+    this.pos++;
+    return token;
+  }
+  /** If the current token matches `kind`, consume and return it; otherwise return null. */
+  match(kind) {
+    if (this.peek().kind === kind) {
+      return this.advance();
+    }
+    return null;
+  }
+  /** Consume the current token if it matches `kind`; throw if it does not. */
+  expect(kind) {
+    const token = this.peek();
+    if (token.kind !== kind) {
+      throw new DatalogSyntaxError(
+        `Expected ${kind}, got ${token.kind} ('${token.value}')`,
+        token.line,
+        token.col
+      );
+    }
+    return this.advance();
+  }
+  /** Generate a unique name for an anonymous variable. */
+  freshAnon() {
+    const name = `_anon_${this.anonCounter}`;
+    this.anonCounter++;
+    return name;
+  }
+  // ===========================================================
+  // Grammar productions
+  // ===========================================================
+  /** program = (rule | query)* EOF */
+  parseProgram() {
+    const rules = [];
+    const queries = [];
+    while (this.peek().kind !== "EOF") {
+      if (this.peek().kind === "QUERY") {
+        queries.push(this.parseQuery());
+      } else {
+        rules.push(this.parseRule());
+      }
+    }
+    return { rules, queries };
+  }
+  /** query = "?-" atom "." */
+  parseQuery() {
+    this.expect("QUERY");
+    const atom = this.parseAtom();
+    this.expect("DOT");
+    return { atom };
+  }
+  /**
+   * rule = atom ":-" body "." | atom "."
+   *
+   * A fact (atom followed by ".") is represented as a rule with an empty body.
+   * After parsing, safety validation is performed for non-fact rules.
+   */
+  parseRule() {
+    const head = this.parseAtom();
+    let body = [];
+    if (this.match("COLON_DASH")) {
+      body = this.parseBody();
+    }
+    this.expect("DOT");
+    const rule = { head, body };
+    this.validateSafety(rule);
+    return rule;
+  }
+  /** body = bodyLiteral ("," bodyLiteral)* */
+  parseBody() {
+    const literals = [];
+    literals.push(this.parseBodyLiteral());
+    while (this.match("COMMA")) {
+      literals.push(this.parseBodyLiteral());
+    }
+    return literals;
+  }
+  /**
+   * bodyLiteral = "not" atom | comparison | atom
+   *
+   * Disambiguation logic:
+   * - If the next token is NOT, parse a negated atom.
+   * - If the next token is a VARIABLE or constant that could start a comparison
+   *   (i.e. the token after it is a comparison operator), parse a comparison.
+   * - Otherwise, parse a positive atom.
+   */
+  parseBodyLiteral() {
+    if (this.peek().kind === "NOT") {
+      this.advance();
+      const atom2 = this.parseAtom();
+      return { kind: "negated", atom: atom2 };
+    }
+    if (this.isComparisonStart()) {
+      return this.parseComparison();
+    }
+    const atom = this.parseAtom();
+    return { kind: "positive", atom };
+  }
+  /**
+   * Detect whether the current position starts a comparison.
+   *
+   * A comparison starts with a term (VARIABLE, STRING, NUMBER, UNDERSCORE)
+   * followed by a comparison operator. We look ahead to distinguish this
+   * from an atom (which starts with IDENT followed by LPAREN).
+   */
+  isComparisonStart() {
+    const current = this.peek();
+    if (current.kind === "VARIABLE" || current.kind === "STRING" || current.kind === "NUMBER" || current.kind === "UNDERSCORE") {
+      if (this.pos + 1 < this.tokens.length) {
+        const next = this.tokens[this.pos + 1];
+        return COMPARISON_OPS.has(next.kind);
+      }
+    }
+    return false;
+  }
+  /** comparison = term compOp term */
+  parseComparison() {
+    const left = this.parseTerm();
+    const opToken = this.advance();
+    if (!COMPARISON_OPS.has(opToken.kind)) {
+      throw new DatalogSyntaxError(
+        `Expected comparison operator, got ${opToken.kind}`,
+        opToken.line,
+        opToken.col
+      );
+    }
+    const op = TOKEN_TO_COMP_OP[opToken.kind];
+    const right = this.parseTerm();
+    return { kind: "comparison", op, left, right };
+  }
+  /** atom = IDENT "(" termList ")" */
+  parseAtom() {
+    const identToken = this.expect("IDENT");
+    const predicate = identToken.value;
+    this.expect("LPAREN");
+    const args = this.parseTermList();
+    this.expect("RPAREN");
+    return { predicate, args };
+  }
+  /** termList = term ("," term)* */
+  parseTermList() {
+    const terms = [];
+    terms.push(this.parseTerm());
+    while (this.match("COMMA")) {
+      terms.push(this.parseTerm());
+    }
+    return terms;
+  }
+  /** term = VARIABLE | STRING | NUMBER | UNDERSCORE */
+  parseTerm() {
+    const token = this.peek();
+    if (token.kind === "VARIABLE") {
+      this.advance();
+      return { kind: "variable", name: token.value };
+    }
+    if (token.kind === "STRING") {
+      this.advance();
+      return { kind: "constant", value: token.value };
+    }
+    if (token.kind === "NUMBER") {
+      this.advance();
+      return { kind: "constant", value: Number(token.value) };
+    }
+    if (token.kind === "UNDERSCORE") {
+      this.advance();
+      return { kind: "variable", name: this.freshAnon() };
+    }
+    throw new DatalogSyntaxError(
+      `Expected term (variable, string, number, or _), got ${token.kind} ('${token.value}')`,
+      token.line,
+      token.col
+    );
+  }
+  // ===========================================================
+  // Safety validation
+  // ===========================================================
+  /**
+   * Validate that every variable in the rule head appears in at least
+   * one positive body literal.
+   *
+   * Facts (rules with empty body) are exempt: their head may only
+   * contain constants, or variables that are trivially safe because
+   * there is no body at all. In standard Datalog, facts should only
+   * have constants, but we allow variable-free heads to pass.
+   *
+   * @throws DatalogSafetyError if a head variable is not grounded
+   */
+  validateSafety(rule) {
+    if (rule.body.length === 0) {
+      return;
+    }
+    const positiveVars = /* @__PURE__ */ new Set();
+    for (const literal of rule.body) {
+      if (literal.kind === "positive") {
+        for (const arg of literal.atom.args) {
+          if (arg.kind === "variable") {
+            positiveVars.add(arg.name);
+          }
+        }
+      }
+    }
+    for (const arg of rule.head.args) {
+      if (arg.kind === "variable") {
+        if (!positiveVars.has(arg.name)) {
+          throw new DatalogSafetyError(
+            `Unsafe variable '${arg.name}' in head of rule '${rule.head.predicate}': it does not appear in any positive body literal`
+          );
+        }
+      }
+    }
+  }
+};
+
+// src/engine/datalog/evaluator.ts
+var FactDB = class {
+  store = /* @__PURE__ */ new Map();
+  seen = /* @__PURE__ */ new Map();
+  totalCount = 0;
+  /** Get all tuples for a predicate. */
+  get(predicate) {
+    return this.store.get(predicate) ?? [];
+  }
+  /** Total number of stored tuples across all predicates. */
+  get size() {
+    return this.totalCount;
+  }
+  /**
+   * Add a tuple for a predicate. Returns true if it was new.
+   * Uses a serialized key for deduplication.
+   */
+  add(predicate, tuple) {
+    const key = serializeTuple(tuple);
+    let seenSet = this.seen.get(predicate);
+    if (!seenSet) {
+      seenSet = /* @__PURE__ */ new Set();
+      this.seen.set(predicate, seenSet);
+    }
+    if (seenSet.has(key)) {
+      return false;
+    }
+    seenSet.add(key);
+    let tuples = this.store.get(predicate);
+    if (!tuples) {
+      tuples = [];
+      this.store.set(predicate, tuples);
+    }
+    tuples.push(tuple);
+    this.totalCount++;
+    return true;
+  }
+};
+function serializeTuple(tuple) {
+  return tuple.map((v) => typeof v === "number" ? `n:${v}` : `s:${v}`).join("\0");
+}
+function evaluate(program, baseFacts, config) {
+  const cfg = { ...DEFAULT_EVAL_CONFIG, ...config };
+  const startTime = performance.now();
+  const inlineFacts = [];
+  const realRules = [];
+  for (const rule of program.rules) {
+    if (rule.body.length === 0) {
+      inlineFacts.push(rule);
+    } else {
+      realRules.push(rule);
+    }
+  }
+  if (realRules.length > cfg.maxRules) {
+    throw new DatalogResourceError(
+      `Number of rules (${realRules.length}) exceeds maxRules limit (${cfg.maxRules})`
+    );
+  }
+  const db2 = new FactDB();
+  for (const fact of baseFacts) {
+    db2.add(fact.predicate, fact.values);
+  }
+  for (const rule of inlineFacts) {
+    const tuple = rule.head.args.map((arg) => {
+      if (arg.kind === "constant") {
+        return arg.value;
+      }
+      return arg.name;
+    });
+    db2.add(rule.head.predicate, tuple);
+  }
+  const stats = { iterations: 0, totalDerived: 0, elapsedMs: 0 };
+  if (realRules.length > 0) {
+    let changed = true;
+    while (changed) {
+      const elapsed = performance.now() - startTime;
+      if (elapsed > cfg.timeoutMs) {
+        throw new DatalogResourceError(
+          `Evaluation timeout: exceeded ${cfg.timeoutMs}ms`
+        );
+      }
+      if (stats.iterations >= cfg.maxIterations) {
+        throw new DatalogResourceError(
+          `Iteration limit exceeded: ${cfg.maxIterations}`
+        );
+      }
+      changed = false;
+      stats.iterations++;
+      for (const rule of realRules) {
+        const derivedTuples = evaluateRule(rule, db2);
+        for (const tuple of derivedTuples) {
+          if (db2.size >= cfg.maxTuples) {
+            throw new DatalogResourceError(
+              `Tuple limit exceeded: ${cfg.maxTuples}`
+            );
+          }
+          const isNew = db2.add(rule.head.predicate, tuple);
+          if (isNew) {
+            changed = true;
+            stats.totalDerived++;
+          }
+        }
+      }
+    }
+  }
+  stats.elapsedMs = performance.now() - startTime;
+  const answers = program.queries.map(
+    (q) => evaluateQuery(q.atom, db2)
+  );
+  return { answers, stats };
+}
+function evaluateRule(rule, db2) {
+  const bindings = evaluateBody(rule.body, 0, /* @__PURE__ */ new Map(), db2);
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    const tuple = instantiateHead(rule.head, binding);
+    const key = serializeTuple(tuple);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(tuple);
+    }
+  }
+  return result;
+}
+function evaluateBody(body, index, binding, db2) {
+  if (index >= body.length) {
+    return [binding];
+  }
+  const literal = body[index];
+  const results = [];
+  if (literal.kind === "positive") {
+    const facts = db2.get(literal.atom.predicate);
+    for (const factTuple of facts) {
+      const newBinding = unifyAtom(literal.atom, factTuple, binding);
+      if (newBinding !== null) {
+        const subResults = evaluateBody(body, index + 1, newBinding, db2);
+        for (const r of subResults) {
+          results.push(r);
+        }
+      }
+    }
+  } else if (literal.kind === "negated") {
+    const facts = db2.get(literal.atom.predicate);
+    let anyMatch = false;
+    for (const factTuple of facts) {
+      const newBinding = unifyAtom(literal.atom, factTuple, binding);
+      if (newBinding !== null) {
+        anyMatch = true;
+        break;
+      }
+    }
+    if (!anyMatch) {
+      const subResults = evaluateBody(body, index + 1, binding, db2);
+      for (const r of subResults) {
+        results.push(r);
+      }
+    }
+  } else if (literal.kind === "comparison") {
+    if (evaluateComparison(literal.op, literal.left, literal.right, binding)) {
+      const subResults = evaluateBody(body, index + 1, binding, db2);
+      for (const r of subResults) {
+        results.push(r);
+      }
+    }
+  }
+  return results;
+}
+function unifyAtom(atom, factTuple, binding) {
+  if (atom.args.length !== factTuple.length) {
+    return null;
+  }
+  let current = new Map(binding);
+  for (let i = 0; i < atom.args.length; i++) {
+    const term = atom.args[i];
+    const value = factTuple[i];
+    const result = unifyTerm(term, value, current);
+    if (result === null) {
+      return null;
+    }
+    current = result;
+  }
+  return current;
+}
+function unifyTerm(term, value, binding) {
+  if (term.kind === "constant") {
+    return term.value === value ? binding : null;
+  }
+  const existing = binding.get(term.name);
+  if (existing !== void 0) {
+    return existing === value ? binding : null;
+  }
+  const newBinding = new Map(binding);
+  newBinding.set(term.name, value);
+  return newBinding;
+}
+function evaluateComparison(op, left, right, binding) {
+  const leftVal = resolveTerm(left, binding);
+  const rightVal = resolveTerm(right, binding);
+  if (leftVal === null || rightVal === null) {
+    return false;
+  }
+  switch (op) {
+    case "=":
+      return leftVal === rightVal;
+    case "!=":
+      return leftVal !== rightVal;
+    case "<":
+      return leftVal < rightVal;
+    case ">":
+      return leftVal > rightVal;
+    case "<=":
+      return leftVal <= rightVal;
+    case ">=":
+      return leftVal >= rightVal;
+  }
+}
+function resolveTerm(term, binding) {
+  if (term.kind === "constant") {
+    return term.value;
+  }
+  const val = binding.get(term.name);
+  return val !== void 0 ? val : null;
+}
+function instantiateHead(head, binding) {
+  return head.args.map((term) => {
+    if (term.kind === "constant") {
+      return term.value;
+    }
+    const val = binding.get(term.name);
+    if (val === void 0) {
+      return term.name;
+    }
+    return val;
+  });
+}
+function evaluateQuery(atom, db2) {
+  const columns = [];
+  for (const arg of atom.args) {
+    if (arg.kind === "variable") {
+      columns.push(arg.name);
+    }
+  }
+  const facts = db2.get(atom.predicate);
+  const tuples = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const factTuple of facts) {
+    const binding = unifyAtom(atom, factTuple, /* @__PURE__ */ new Map());
+    if (binding !== null) {
+      const key = serializeTuple(factTuple);
+      if (!seen.has(key)) {
+        seen.add(key);
+        tuples.push(factTuple);
+      }
+    }
+  }
+  return {
+    query: atom,
+    tuples,
+    columns
+  };
+}
+
+// src/engine/datalog/fact-extractor.ts
+function extractHosts(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT id, authority, authority_kind FROM hosts LIMIT ?" : "SELECT id, authority, authority_kind FROM hosts";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "host",
+    values: [r.id, r.authority, r.authority_kind]
+  }));
+}
+function extractServices(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT host_id, id, transport, port, app_proto, state FROM services LIMIT ?" : "SELECT host_id, id, transport, port, app_proto, state FROM services";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "service",
+    values: [r.host_id, r.id, r.transport, r.port, r.app_proto, r.state]
+  }));
+}
+function extractHttpEndpoints(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT service_id, id, method, path, status_code FROM http_endpoints LIMIT ?" : "SELECT service_id, id, method, path, status_code FROM http_endpoints";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "http_endpoint",
+    values: [r.service_id, r.id, r.method, r.path, r.status_code ?? 0]
+  }));
+}
+function extractInputs(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT service_id, id, location, name FROM inputs LIMIT ?" : "SELECT service_id, id, location, name FROM inputs";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "input",
+    values: [r.service_id, r.id, r.location, r.name]
+  }));
+}
+function extractEndpointInputs(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT endpoint_id, input_id FROM endpoint_inputs LIMIT ?" : "SELECT endpoint_id, input_id FROM endpoint_inputs";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "endpoint_input",
+    values: [r.endpoint_id, r.input_id]
+  }));
+}
+function extractObservations(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT input_id, id, raw_value, source, confidence FROM observations LIMIT ?" : "SELECT input_id, id, raw_value, source, confidence FROM observations";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "observation",
+    values: [r.input_id, r.id, r.raw_value, r.source, r.confidence]
+  }));
+}
+function extractCredentials(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT service_id, id, username, secret_type, source, confidence FROM credentials LIMIT ?" : "SELECT service_id, id, username, secret_type, source, confidence FROM credentials";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "credential",
+    values: [r.service_id, r.id, r.username, r.secret_type, r.source, r.confidence]
+  }));
+}
+function extractVulnerabilities(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT service_id, id, vuln_type, title, severity, confidence, endpoint_id FROM vulnerabilities LIMIT ?" : "SELECT service_id, id, vuln_type, title, severity, confidence, endpoint_id FROM vulnerabilities";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  const facts = [];
+  for (const r of rows) {
+    facts.push({
+      predicate: "vulnerability",
+      values: [r.service_id, r.id, r.vuln_type, r.title, r.severity, r.confidence]
+    });
+  }
+  return facts;
+}
+function extractVulnerabilityEndpoints(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT id, endpoint_id FROM vulnerabilities WHERE endpoint_id IS NOT NULL LIMIT ?" : "SELECT id, endpoint_id FROM vulnerabilities WHERE endpoint_id IS NOT NULL";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "vulnerability_endpoint",
+    values: [r.id, r.endpoint_id]
+  }));
+}
+function extractCves(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT vulnerability_id, cve_id, cvss_score FROM cves LIMIT ?" : "SELECT vulnerability_id, cve_id, cvss_score FROM cves";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "cve",
+    values: [r.vulnerability_id, r.cve_id, r.cvss_score ?? 0]
+  }));
+}
+function extractVhosts(db2, limit) {
+  const sql = limit !== void 0 ? "SELECT host_id, id, hostname, source FROM vhosts LIMIT ?" : "SELECT host_id, id, hostname, source FROM vhosts";
+  const rows = limit !== void 0 ? db2.prepare(sql).all(limit) : db2.prepare(sql).all();
+  return rows.map((r) => ({
+    predicate: "vhost",
+    values: [r.host_id, r.id, r.hostname, r.source ?? ""]
+  }));
+}
+var EXTRACTORS = /* @__PURE__ */ new Map([
+  ["host", extractHosts],
+  ["service", extractServices],
+  ["http_endpoint", extractHttpEndpoints],
+  ["input", extractInputs],
+  ["endpoint_input", extractEndpointInputs],
+  ["observation", extractObservations],
+  ["credential", extractCredentials],
+  ["vulnerability", extractVulnerabilities],
+  ["vulnerability_endpoint", extractVulnerabilityEndpoints],
+  ["cve", extractCves],
+  ["vhost", extractVhosts]
+]);
+function extractFacts(db2) {
+  const facts = [];
+  for (const extractor of EXTRACTORS.values()) {
+    facts.push(...extractor(db2));
+  }
+  return facts;
+}
+function extractFactsByPredicate(db2, predicate, limit) {
+  const extractor = EXTRACTORS.get(predicate);
+  if (!extractor) {
+    return [];
+  }
+  return extractor(db2, limit);
+}
+
+// src/engine/datalog/preset-rules.ts
+var PRESET_RULES = [
+  {
+    name: "reachable_services",
+    description: "Find all open services on each host with their port and application protocol.",
+    ruleText: [
+      'reachable(Host, Port, AppProto) :- service(Host, _, _, Port, AppProto, "open").',
+      "?- reachable(Host, Port, AppProto)."
+    ].join("\n")
+  },
+  {
+    name: "authenticated_access",
+    description: "Services with discovered credentials, showing host, port, and username.",
+    ruleText: [
+      'auth_access(Host, Port, Username) :- service(Host, Svc, _, Port, _, "open"), credential(Svc, _, Username, _, _, _).',
+      "?- auth_access(Host, Port, Username)."
+    ].join("\n")
+  },
+  {
+    name: "exploitable_endpoints",
+    description: "HTTP endpoints with known vulnerabilities, including vulnerability type and severity.",
+    ruleText: [
+      "exploitable(Host, Port, Path, VulnType, Severity) :- service(Host, Svc, _, Port, _, _), http_endpoint(Svc, Ep, _, Path, _), vulnerability_endpoint(Vuln, Ep), vulnerability(Svc, Vuln, VulnType, _, Severity, _).",
+      "?- exploitable(Host, Port, Path, VulnType, Severity)."
+    ].join("\n")
+  },
+  {
+    name: "critical_vulns",
+    description: "Critical severity vulnerabilities with host, port, title, and type.",
+    ruleText: [
+      'critical(Host, Port, Title, VulnType) :- service(Host, Svc, _, Port, _, _), vulnerability(Svc, _, VulnType, Title, "critical", _).',
+      "?- critical(Host, Port, Title, VulnType)."
+    ].join("\n")
+  },
+  {
+    name: "attack_surface",
+    description: "Full attack surface overview combining host, port, endpoint path, input name, and input location.",
+    ruleText: [
+      'surface(Host, Port, Path, InputName, Location) :- service(Host, Svc, _, Port, _, "open"), http_endpoint(Svc, Ep, _, Path, _), endpoint_input(Ep, Inp), input(Svc, Inp, Location, InputName).',
+      "?- surface(Host, Port, Path, InputName, Location)."
+    ].join("\n")
+  },
+  {
+    name: "unfuzzed_inputs",
+    description: "Inputs with observations but no associated vulnerability endpoint \u2014 candidates for fuzzing.",
+    ruleText: [
+      'unfuzzed(Host, Port, Path, InputName) :- service(Host, Svc, _, Port, _, "open"), http_endpoint(Svc, Ep, _, Path, _), endpoint_input(Ep, Inp), input(Svc, Inp, _, InputName), observation(Inp, _, _, _, _), not vulnerability_endpoint(_, Ep).',
+      "?- unfuzzed(Host, Port, Path, InputName)."
+    ].join("\n")
+  }
+];
+function getPresetRules() {
+  return [...PRESET_RULES];
+}
+function getPresetRule(name) {
+  return PRESET_RULES.find((r) => r.name === name);
+}
+
+// src/db/repository/datalog-rule-repository.ts
+import crypto14 from "crypto";
+function rowToDatalogRule(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description ?? void 0,
+    ruleText: row.rule_text,
+    generatedBy: row.generated_by,
+    isPreset: row.is_preset === 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var DatalogRuleRepository = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  /** Insert a new DatalogRule and return the full entity. */
+  create(input) {
+    const id = crypto14.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = this.db.prepare(
+      `INSERT INTO datalog_rules (id, name, description, rule_text, generated_by, is_preset, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    stmt.run(
+      id,
+      input.name,
+      input.description ?? null,
+      input.ruleText,
+      input.generatedBy,
+      input.isPreset ? 1 : 0,
+      now,
+      now
+    );
+    return {
+      id,
+      name: input.name,
+      description: input.description,
+      ruleText: input.ruleText,
+      generatedBy: input.generatedBy,
+      isPreset: input.isPreset ?? false,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  /** Find a DatalogRule by its primary key. */
+  findById(id) {
+    const stmt = this.db.prepare(
+      `SELECT id, name, description, rule_text, generated_by, is_preset, created_at, updated_at
+       FROM datalog_rules WHERE id = ?`
+    );
+    const row = stmt.get(id);
+    return row ? rowToDatalogRule(row) : void 0;
+  }
+  /** Find a DatalogRule by name. */
+  findByName(name) {
+    const stmt = this.db.prepare(
+      `SELECT id, name, description, rule_text, generated_by, is_preset, created_at, updated_at
+       FROM datalog_rules WHERE name = ?`
+    );
+    const row = stmt.get(name);
+    return row ? rowToDatalogRule(row) : void 0;
+  }
+  /** Return all DatalogRules. */
+  findAll() {
+    const stmt = this.db.prepare(
+      `SELECT id, name, description, rule_text, generated_by, is_preset, created_at, updated_at
+       FROM datalog_rules ORDER BY created_at`
+    );
+    return stmt.all().map(rowToDatalogRule);
+  }
+  /** Delete a DatalogRule by id. Returns true if a row was deleted. */
+  delete(id) {
+    const stmt = this.db.prepare("DELETE FROM datalog_rules WHERE id = ?");
+    const result = stmt.run(id);
+    return result.changes > 0;
+  }
+};
+
+// src/engine/datalog/index.ts
+function listFacts(db2, predicate, limit) {
+  if (predicate !== void 0) {
+    return extractFactsByPredicate(db2, predicate, limit);
+  }
+  const facts = extractFacts(db2);
+  if (limit !== void 0 && limit > 0) {
+    return facts.slice(0, limit);
+  }
+  return facts;
+}
+function runDatalog(db2, program, options) {
+  const ast = parse(program);
+  const facts = extractFacts(db2);
+  const result = evaluate(ast, facts, options?.config);
+  if (options?.saveName !== void 0) {
+    const ruleRepo = new DatalogRuleRepository(db2);
+    ruleRepo.create({
+      name: options.saveName,
+      description: options.saveDescription,
+      ruleText: program,
+      generatedBy: options.generatedBy ?? "ai"
+    });
+  }
+  return result;
+}
+function queryAttackPaths(db2, pattern, config) {
+  const preset = getPresetRule(pattern);
+  if (preset !== void 0) {
+    const ast = parse(preset.ruleText);
+    const facts = extractFacts(db2);
+    return evaluate(ast, facts, config);
+  }
+  const ruleRepo = new DatalogRuleRepository(db2);
+  const savedRule = ruleRepo.findByName(pattern);
+  if (savedRule !== void 0) {
+    const ast = parse(savedRule.ruleText);
+    const facts = extractFacts(db2);
+    return evaluate(ast, facts, config);
+  }
+  return {
+    answers: [],
+    stats: { iterations: 0, totalDerived: 0, elapsedMs: 0 }
+  };
+}
+function listPatterns(db2) {
+  const presets = getPresetRules().map((p) => ({
+    name: p.name,
+    description: p.description,
+    source: "preset"
+  }));
+  const ruleRepo = new DatalogRuleRepository(db2);
+  const saved = ruleRepo.findAll().map((r) => ({
+    name: r.name,
+    description: r.description,
+    source: "saved",
+    generatedBy: r.generatedBy
+  }));
+  return [...presets, ...saved];
+}
+
+// src/mcp/tools/datalog.ts
+function formatFact(fact) {
+  const args = fact.values.map((v) => typeof v === "number" ? String(v) : `"${v}"`).join(", ");
+  return `${fact.predicate}(${args}).`;
+}
+function formatEvalResult(result) {
+  if (result.answers.length === 0) {
+    return `No query results.
+
+Stats: ${result.stats.iterations} iterations, ${result.stats.totalDerived} derived facts, ${result.stats.elapsedMs}ms`;
+  }
+  const sections = [];
+  for (const answer of result.answers) {
+    const queryArgs = answer.query.args.map((a) => a.kind === "variable" ? a.name : a.kind === "constant" ? String(a.value) : "_").join(", ");
+    const header = `Query: ${answer.query.predicate}(${queryArgs})`;
+    if (answer.tuples.length === 0) {
+      sections.push(`${header}
+Results: (empty)`);
+      continue;
+    }
+    const columns = answer.columns;
+    const widths = columns.map(
+      (col, i) => Math.max(
+        col.length,
+        ...answer.tuples.map((t) => String(t[i]).length)
+      )
+    );
+    const headerRow = columns.map((col, i) => col.padEnd(widths[i])).join(" | ");
+    const dataRows = answer.tuples.map(
+      (tuple) => "  " + tuple.map((val, i) => String(val).padEnd(widths[i])).join(" | ")
+    );
+    sections.push(
+      `${header}
+Results (${answer.tuples.length} rows):
+  ${headerRow}
+${dataRows.join("\n")}`
+    );
+  }
+  sections.push(
+    `
+Stats: ${result.stats.iterations} iterations, ${result.stats.totalDerived} derived facts, ${result.stats.elapsedMs}ms`
+  );
+  return sections.join("\n\n");
+}
+function registerDatalogTools(server2, db2) {
+  server2.tool(
+    "list_facts",
+    "List database contents as Datalog facts. Optionally filter by predicate name and limit the number of results.",
+    {
+      predicate: z5.string().optional().describe(
+        "Filter by predicate name (host, service, http_endpoint, input, endpoint_input, observation, credential, vulnerability, vulnerability_endpoint, cve, vhost)"
+      ),
+      limit: z5.number().optional().describe("Maximum number of facts to return")
+    },
+    async ({ predicate, limit }) => {
+      const facts = listFacts(db2, predicate, limit);
+      if (facts.length === 0) {
+        return {
+          content: [{ type: "text", text: "No facts found." }]
+        };
+      }
+      const text = facts.map(formatFact).join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server2.tool(
+    "run_datalog",
+    "Execute a custom Datalog program against the AttackDataGraph. Supports rules with :- and queries with ?-. Optionally save the program as a named rule for future reuse.",
+    {
+      program: z5.string().describe("Datalog program text (rules and queries)"),
+      save_name: z5.string().optional().describe("Save the program as a named rule for future reuse"),
+      save_description: z5.string().optional().describe("Description of the saved rule"),
+      generated_by: z5.string().optional().describe('Who generated this rule: "human" or "ai" (default: "ai")')
+    },
+    async ({ program, save_name, save_description, generated_by }) => {
+      try {
+        const generatedBy = generated_by === "human" ? "human" : "ai";
+        const result = runDatalog(db2, program, {
+          saveName: save_name,
+          saveDescription: save_description,
+          generatedBy
+        });
+        const text = formatEvalResult(result);
+        return { content: [{ type: "text", text }] };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Datalog error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "query_attack_paths",
+    'Run a preset or saved attack pattern query. Use pattern "list" to see all available patterns.',
+    {
+      pattern: z5.string().describe(
+        'Pattern name (e.g. "reachable_services", "critical_vulns") or "list" to see available patterns'
+      )
+    },
+    async ({ pattern }) => {
+      if (pattern === "list") {
+        const patterns = listPatterns(db2);
+        if (patterns.length === 0) {
+          return {
+            content: [{ type: "text", text: "No patterns available." }]
+          };
+        }
+        const lines = patterns.map(
+          (p) => `- ${p.name} [${p.source}]${p.description ? `: ${p.description}` : ""}${p.generatedBy ? ` (by ${p.generatedBy})` : ""}`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Available patterns:
+${lines.join("\n")}`
+            }
+          ]
+        };
+      }
+      try {
+        const result = queryAttackPaths(db2, pattern);
+        const text = formatEvalResult(result);
+        return { content: [{ type: "text", text }] };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Datalog error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/mcp/resources.ts
 function registerResources(server2, db2) {
   const hostRepo = new HostRepository(db2);
@@ -2526,12 +3773,13 @@ function registerResources(server2, db2) {
 function createMcpServer(db2) {
   const server2 = new McpServer({
     name: "sonobat",
-    version: "0.1.0"
+    version: "0.2.0"
   });
   registerQueryTools(server2, db2);
   registerIngestTool(server2, db2);
   registerProposeTool(server2, db2);
   registerMutationTools(server2, db2);
+  registerDatalogTools(server2, db2);
   registerResources(server2, db2);
   return server2;
 }