trellis 3.2.0 → 3.2.3

package/dist/chunk-2CX5UCRV.js

@@ -1,111 +0,0 @@
-import {
-  entitiesQuery,
-  resolveRelations
-} from "./chunk-7QQQNUB5.js";
-import {
-  Signal
-} from "./chunk-UBGUDMUV.js";
-
-// src/client/live.ts
-function liveQuery(client, eql) {
-  const signal = new Signal({
-    data: [],
-    loading: true,
-    error: null
-  });
-  let sub = null;
-  return {
-    signal,
-    start() {
-      if (sub) return () => stop();
-      try {
-        sub = client.subscribe(eql, (rows) => {
-          signal.value = { data: rows, loading: false, error: null };
-        });
-      } catch (err) {
-        signal.value = {
-          data: [],
-          loading: false,
-          error: err instanceof Error ? err : new Error(String(err))
-        };
-      }
-      return () => stop();
-    }
-  };
-  function stop() {
-    sub?.unsubscribe();
-    sub = null;
-  }
-}
-function normalizeLiveEntitiesOpts(whereOrOpts) {
-  if (!whereOrOpts) return {};
-  if ("resolve" in whereOrOpts) return whereOrOpts;
-  return { where: whereOrOpts };
-}
-function liveEntities(client, typeOrSchema, whereOrOpts) {
-  const schema = typeof typeOrSchema === "string" ? void 0 : typeOrSchema;
-  const type = typeof typeOrSchema === "string" ? typeOrSchema : typeOrSchema.type;
-  const { where, resolve } = normalizeLiveEntitiesOpts(whereOrOpts);
-  const signal = new Signal({
-    data: [],
-    loading: true,
-    error: null
-  });
-  let sub = null;
-  let token = 0;
-  return {
-    signal,
-    start() {
-      if (sub) return () => stop();
-      try {
-        sub = client.subscribe(
-          entitiesQuery(type, where),
-          (rows) => {
-            const turn = ++token;
-            const ids = rows.map((r) => r.e).filter(Boolean);
-            Promise.all(ids.map((id) => client.read(id))).then(async (entities) => {
-              if (turn !== token) return;
-              let data = entities.filter(
-                (e) => e != null
-              );
-              if (schema && resolve && Object.keys(resolve).length > 0) {
-                data = await resolveRelations(
-                  client,
-                  schema,
-                  data,
-                  resolve
-                );
-              }
-              if (turn !== token) return;
-              signal.value = { data, loading: false, error: null };
-            }).catch((err) => {
-              if (turn !== token) return;
-              signal.value = {
-                data: signal.peek().data,
-                loading: false,
-                error: err instanceof Error ? err : new Error(String(err))
-              };
-            });
-          }
-        );
-      } catch (err) {
-        signal.value = {
-          data: [],
-          loading: false,
-          error: err instanceof Error ? err : new Error(String(err))
-        };
-      }
-      return () => stop();
-    }
-  };
-  function stop() {
-    token++;
-    sub?.unsubscribe();
-    sub = null;
-  }
-}
-
-export {
-  liveQuery,
-  liveEntities
-};

package/dist/chunk-2ESYSVXG.js

@@ -1,48 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-export {
-  __require,
-  __esm,
-  __commonJS,
-  __export,
-  __toESM,
-  __toCommonJS
-};

package/dist/chunk-2I5JU73Y.js

@@ -1,340 +0,0 @@
-// src/core/query/types.ts
-function isVariable(t) {
-  return t.kind === "variable";
-}
-function isLiteral(t) {
-  return t.kind === "literal";
-}
-function variable(name) {
-  return { kind: "variable", name };
-}
-function literal(value) {
-  return { kind: "literal", value };
-}
-
-// src/core/query/engine.ts
-var QueryEngine = class {
-  constructor(store) {
-    this.store = store;
-  }
-  rules = /* @__PURE__ */ new Map();
-  maxRuleDepth = 32;
-  /** Register a Datalog rule. Multiple rules with the same name = union. */
-  addRule(rule) {
-    const existing = this.rules.get(rule.name) ?? [];
-    existing.push(rule);
-    this.rules.set(rule.name, existing);
-  }
-  removeRule(name) {
-    this.rules.delete(name);
-  }
-  /** Execute a query against the store. */
-  execute(query) {
-    const start = performance.now();
-    let results = this._evaluatePatterns(query.where, [/* @__PURE__ */ new Map()]);
-    for (const filter of query.filters) {
-      results = results.filter((b) => this._evalFilter(filter, b));
-    }
-    if (query.aggregates.length > 0) {
-      results = this._aggregate(results, query.aggregates, query.select);
-    }
-    if (query.orderBy.length > 0) {
-      results = this._order(results, query.orderBy);
-    }
-    if (query.offset > 0) results = results.slice(query.offset);
-    if (query.limit > 0) results = results.slice(0, query.limit);
-    const projected = this._project(results, query.select);
-    return {
-      bindings: projected,
-      executionTime: performance.now() - start,
-      count: projected.length
-    };
-  }
-  // -------------------------------------------------------------------------
-  // Pattern evaluation
-  // -------------------------------------------------------------------------
-  _evaluatePatterns(patterns, bindings) {
-    let current = bindings;
-    for (const pattern of patterns) {
-      if (current.length === 0) break;
-      current = this._evaluatePattern(pattern, current);
-    }
-    return current;
-  }
-  _evaluatePattern(pattern, bindings) {
-    switch (pattern.kind) {
-      case "fact":
-        return this._evalFactPattern(pattern, bindings);
-      case "link":
-        return this._evalLinkPattern(pattern, bindings);
-      case "not":
-        return this._evalNotPattern(pattern, bindings);
-      case "or":
-        return this._evalOrPattern(pattern, bindings);
-      case "rule":
-        return this._evalRuleApplication(pattern, bindings);
-    }
-  }
-  _evalFactPattern(p, bindings) {
-    const results = [];
-    for (const b of bindings) {
-      const eResolved = this._resolve(p.entity, b);
-      const aResolved = this._resolve(p.attribute, b);
-      const vResolved = this._resolve(p.value, b);
-      let facts;
-      if (eResolved !== void 0 && aResolved !== void 0) {
-        facts = this.store.getFactsByEntity(String(eResolved)).filter((f) => f.a === aResolved);
-      } else if (eResolved !== void 0) {
-        facts = this.store.getFactsByEntity(String(eResolved));
-      } else if (aResolved !== void 0 && vResolved !== void 0) {
-        facts = this.store.getFactsByValue(String(aResolved), vResolved);
-      } else if (aResolved !== void 0) {
-        facts = this.store.getFactsByAttribute(String(aResolved));
-      } else {
-        facts = this.store.getAllFacts();
-      }
-      if (vResolved !== void 0) {
-        facts = facts.filter((f) => f.v === vResolved);
-      }
-      for (const fact of facts) {
-        const nb = new Map(b);
-        if (this._bind(p.entity, fact.e, nb) && this._bind(p.attribute, fact.a, nb) && this._bind(p.value, fact.v, nb)) {
-          results.push(nb);
-        }
-      }
-    }
-    return results;
-  }
-  _evalLinkPattern(p, bindings) {
-    const results = [];
-    for (const b of bindings) {
-      const srcResolved = this._resolve(p.source, b);
-      const attrResolved = this._resolve(p.attribute, b);
-      const tgtResolved = this._resolve(p.target, b);
-      let links;
-      if (srcResolved !== void 0 && attrResolved !== void 0) {
-        links = this.store.getLinksByEntityAndAttribute(
-          String(srcResolved),
-          String(attrResolved)
-        );
-      } else if (srcResolved !== void 0) {
-        links = this.store.getLinksByEntity(String(srcResolved));
-      } else if (attrResolved !== void 0) {
-        links = this.store.getLinksByAttribute(String(attrResolved));
-      } else {
-        links = this.store.getAllLinks();
-      }
-      if (tgtResolved !== void 0) {
-        links = links.filter((l) => l.e2 === tgtResolved);
-      }
-      for (const link of links) {
-        const nb = new Map(b);
-        if (this._bind(p.source, link.e1, nb) && this._bind(p.attribute, link.a, nb) && this._bind(p.target, link.e2, nb)) {
-          results.push(nb);
-        }
-      }
-    }
-    return results;
-  }
-  _evalNotPattern(p, bindings) {
-    return bindings.filter((b) => {
-      const matches = this._evaluatePattern(p.pattern, [b]);
-      return matches.length === 0;
-    });
-  }
-  _evalOrPattern(p, bindings) {
-    const results = [];
-    for (const branch of p.branches) {
-      const branchResults = this._evaluatePatterns(branch, bindings);
-      results.push(...branchResults);
-    }
-    return this._dedup(results);
-  }
-  _evalRuleApplication(p, bindings, depth = 0) {
-    if (depth > this.maxRuleDepth) return [];
-    const ruleDefs = this.rules.get(p.name);
-    if (!ruleDefs) return [];
-    const results = [];
-    for (const b of bindings) {
-      for (const rule of ruleDefs) {
-        const ruleBindings = new Map(b);
-        let ok = true;
-        for (let i = 0; i < rule.params.length && i < p.args.length; i++) {
-          const resolved = this._resolve(p.args[i], b);
-          if (resolved !== void 0) {
-            ruleBindings.set(rule.params[i], resolved);
-          } else if (isVariable(p.args[i])) {
-          }
-        }
-        if (!ok) continue;
-        let bodyResults = this._evaluatePatterns(rule.body, [ruleBindings]);
-        for (const f of rule.filters) {
-          bodyResults = bodyResults.filter((rb) => this._evalFilter(f, rb));
-        }
-        for (const rb of bodyResults) {
-          const nb = new Map(b);
-          for (let i = 0; i < rule.params.length && i < p.args.length; i++) {
-            if (isVariable(p.args[i])) {
-              const val = rb.get(rule.params[i]);
-              if (val !== void 0)
-                nb.set(p.args[i].name, val);
-            }
-          }
-          results.push(nb);
-        }
-      }
-    }
-    return this._dedup(results);
-  }
-  // -------------------------------------------------------------------------
-  // Filtering
-  // -------------------------------------------------------------------------
-  _evalFilter(filter, b) {
-    const left = this._resolve(filter.left, b);
-    const right = this._resolve(filter.right, b);
-    if (left === void 0 || right === void 0) return false;
-    switch (filter.op) {
-      case "=":
-        return left === right;
-      case "!=":
-        return left !== right;
-      case "<":
-        return left < right;
-      case "<=":
-        return left <= right;
-      case ">":
-        return left > right;
-      case ">=":
-        return left >= right;
-      case "contains":
-        return String(left).includes(String(right));
-      case "startsWith":
-        return String(left).startsWith(String(right));
-      case "endsWith":
-        return String(left).endsWith(String(right));
-      case "matches":
-        return new RegExp(String(right)).test(String(left));
-      default:
-        return false;
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Aggregation
-  // -------------------------------------------------------------------------
-  _aggregate(bindings, aggregates, groupBy) {
-    const aggVarNames = new Set(aggregates.map((a) => a.as));
-    const groupVars = groupBy.filter((v) => !aggVarNames.has(v));
-    const groups = /* @__PURE__ */ new Map();
-    for (const b of bindings) {
-      const key = groupVars.map((v) => String(b.get(v) ?? "")).join("\0");
-      const group = groups.get(key) ?? [];
-      group.push(b);
-      groups.set(key, group);
-    }
-    const results = [];
-    for (const [, group] of groups) {
-      const nb = new Map(group[0]);
-      for (const agg of aggregates) {
-        const vals = group.map((b) => b.get(agg.variable)).filter((v) => v !== void 0);
-        nb.set(agg.as, this._computeAggregate(agg.op, vals));
-      }
-      results.push(nb);
-    }
-    return results;
-  }
-  _computeAggregate(op, vals) {
-    switch (op) {
-      case "count":
-        return vals.length;
-      case "sum":
-        return vals.reduce(
-          (s, v) => s + (Number(v) || 0),
-          0
-        );
-      case "avg":
-        return vals.length ? vals.reduce(
-          (s, v) => s + (Number(v) || 0),
-          0
-        ) / vals.length : 0;
-      case "min":
-        return vals.reduce(
-          (m, v) => v < m ? v : m,
-          vals[0]
-        );
-      case "max":
-        return vals.reduce(
-          (m, v) => v > m ? v : m,
-          vals[0]
-        );
-      case "collect":
-        return JSON.stringify(vals);
-      default:
-        return vals.length;
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Ordering
-  // -------------------------------------------------------------------------
-  _order(bindings, orderBy) {
-    return [...bindings].sort((a, b) => {
-      for (const o of orderBy) {
-        const va = a.get(o.variable);
-        const vb = b.get(o.variable);
-        if (va === vb) continue;
-        if (va === void 0) return 1;
-        if (vb === void 0) return -1;
-        const cmp = va < vb ? -1 : 1;
-        return o.direction === "asc" ? cmp : -cmp;
-      }
-      return 0;
-    });
-  }
-  // -------------------------------------------------------------------------
-  // Projection
-  // -------------------------------------------------------------------------
-  _project(bindings, select) {
-    return bindings.map((b) => {
-      const row = {};
-      if (select.length === 0) {
-        for (const [k, v] of b) row[k] = v;
-      } else {
-        for (const s of select) {
-          const v = b.get(s);
-          if (v !== void 0) row[s] = v;
-        }
-      }
-      return row;
-    });
-  }
-  // -------------------------------------------------------------------------
-  // Helpers
-  // -------------------------------------------------------------------------
-  _resolve(term, bindings) {
-    if (isLiteral(term)) return term.value;
-    return bindings.get(term.name);
-  }
-  _bind(term, value, bindings) {
-    if (isLiteral(term)) return term.value === value;
-    const existing = bindings.get(term.name);
-    if (existing !== void 0) return existing === value;
-    bindings.set(term.name, value);
-    return true;
-  }
-  _dedup(bindings) {
-    const seen = /* @__PURE__ */ new Set();
-    return bindings.filter((b) => {
-      const key = [...b.entries()].sort(([a], [b2]) => a.localeCompare(b2)).map(([k, v]) => `${k}=${v}`).join("\0");
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-  }
-};
-
-export {
-  isVariable,
-  isLiteral,
-  variable,
-  literal,
-  QueryEngine
-};

package/dist/chunk-2UNSRRNB.js

@@ -1,171 +0,0 @@
-import {
-  inferProjectContext,
-  init_infer,
-  init_profile,
-  init_write,
-  loadProfile
-} from "./chunk-ZMN5LUB7.js";
-
-// src/scaffold/seed.ts
-init_profile();
-init_infer();
-import { existsSync, writeFileSync } from "fs";
-import { join } from "path";
-async function seedContext(opts) {
-  const { rootPath, ide = "none", force = false } = opts;
-  const filesUpdated = [];
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const profile = loadProfile();
-  const context = await inferProjectContext(rootPath);
-  const agentsDir = join(rootPath, ".trellis", "agents");
-  if (existsSync(agentsDir)) {
-    const agentsMdPath = join(agentsDir, "AGENTS.md");
-    if (existsSync(agentsMdPath) || force) {
-      const content = renderSeedAgentsMd(profile, context, timestamp);
-      writeFileSync(agentsMdPath, content, "utf-8");
-      filesUpdated.push(".trellis/agents/AGENTS.md");
-    }
-    const agentContextPath = join(agentsDir, "agent-context.json");
-    if (existsSync(agentContextPath) || force) {
-      const config = {
-        domain: context.domain,
-        ecosystem: context.ecosystem,
-        tools: [],
-        ontologies: [],
-        generatedAt: timestamp,
-        confidence: context.confidence,
-        lastSeed: timestamp
-      };
-      writeFileSync(
-        agentContextPath,
-        JSON.stringify(config, null, 2),
-        "utf-8"
-      );
-      filesUpdated.push(".trellis/agents/agent-context.json");
-    }
-  }
-  switch (ide) {
-    case "cursor": {
-      const cursorRulesPath = join(rootPath, ".cursor", "rules.md");
-      if (existsSync(cursorRulesPath) || force) {
-        const content = renderSeedIdeRules(profile, context, "cursor", timestamp);
-        writeFileSync(cursorRulesPath, content, "utf-8");
-        filesUpdated.push(".cursor/rules.md");
-      }
-      break;
-    }
-    case "windsurf": {
-      const windsurfRulesPath = join(rootPath, ".windsurf", "rules.md");
-      if (existsSync(windsurfRulesPath) || force) {
-        const content = renderSeedIdeRules(profile, context, "windsurf", timestamp);
-        writeFileSync(windsurfRulesPath, content, "utf-8");
-        filesUpdated.push(".windsurf/rules.md");
-      }
-      break;
-    }
-    case "claude": {
-      const claudeSettingsPath = join(rootPath, ".claude", "settings.md");
-      if (existsSync(claudeSettingsPath) || force) {
-        const content = renderSeedIdeRules(profile, context, "claude", timestamp);
-        writeFileSync(claudeSettingsPath, content, "utf-8");
-        filesUpdated.push(".claude/settings.md");
-      }
-      break;
-    }
-    case "none":
-      break;
-  }
-  return {
-    success: true,
-    filesUpdated,
-    timestamp
-  };
-}
-function renderSeedAgentsMd(profile, context, timestamp) {
-  const userName = profile?.name ?? "the user";
-  const userBio = profile?.bio ?? "(not provided)";
-  const userSkills = profile?.skills?.length ? profile.skills.join(", ") : "(not specified)";
-  return `# Trellis Agent Context
-
-> This file was seeded by \`trellis seed\` on ${timestamp}
-> Inference confidence: **${context.confidence}**
-
----
-
-## About the User
-
-| Field | Value |
-|-------|-------|
-| **Name** | ${userName} |
-| **Bio** | ${userBio} |
-| **Skills** | ${userSkills} |
-
----
-
-## About This Project
-
-| Field | Value |
-|-------|-------|
-| **Name** | ${context.name ?? "(unnamed)"} |
-| **Domain** | ${context.domain ?? "(not determined)"} |
-| **Description** | ${context.description ?? "(no description found)"} |
-| **Ecosystem** | ${context.ecosystem ?? "unknown"} |
-| **File count** | ~${context.fileCount} |
-
----
-
-## Agent Instructions
-
-You are operating in a Trellis-tracked repository. Follow these guidelines:
-
-1. **Read \`agent-context.json\`** in this directory for registered tools, ontologies, and domain settings.
-2. **Check \`skills/\`** for domain-specific operating instructions relevant to this project.
-3. **Check \`workflows/\`** for repeatable task procedures.
-4. **Run \`trellis seed\`** to refresh this context file when the project evolves.
-
----
-
-## Quick Reference
-
-\`\`\`bash
-trellis status          # Current repo state
-trellis log             # Causal operation history
-trellis seed            # Refresh this context
-trellis milestone       # Create narrative checkpoints
-\`\`\`
-`;
-}
-function renderSeedIdeRules(profile, context, ide, timestamp) {
-  const ideName = ide.charAt(0).toUpperCase() + ide.slice(1);
-  const projectName = context.name ?? "this project";
-  return `# ${ideName} Rules for ${projectName}
-
-> Generated by \`trellis seed\` on ${timestamp}
-
-## Project Context
-- **Domain**: ${context.domain ?? "(not determined)"}
-- **Ecosystem**: ${context.ecosystem ?? "unknown"}
-- **File count**: ~${context.fileCount}
-- **Confidence**: ${context.confidence}
-
-## Agent Instructions
-You are working in a Trellis-tracked repository. See \`.trellis/agents/AGENTS.md\` for full context.
-
-## Commands
-- \`trellis status\` \u2014 Check repo state
-- \`trellis seed\` \u2014 Refresh this context file
-- \`trellis log\` \u2014 View causal history
-
----
-*Auto-generated by Trellis. Run \`trellis seed\` to refresh context.*
-`;
-}
-
-// src/scaffold/index.ts
-init_infer();
-init_profile();
-init_write();
-
-export {
-  seedContext
-};