trellis 3.1.35 → 3.2.0

package/dist/chunk-SIAA4J6H.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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 });
+};
+
+export {
+  __require,
+  __commonJS,
+  __export
+};

package/dist/chunk-SPSPV5BC.js

@@ -0,0 +1,390 @@
+// src/core/computation/expr-evaluator.ts
+var ExprEvaluator = class {
+  functions;
+  constructor() {
+    this.functions = /* @__PURE__ */ new Map([
+      ["$if", this.if.bind(this)],
+      ["$round", this.round.bind(this)],
+      ["$concat", this.concat.bind(this)],
+      ["$len", this.len.bind(this)],
+      ["$lower", this.lower.bind(this)],
+      ["$upper", this.upper.bind(this)],
+      ["$trim", this.trim.bind(this)],
+      ["$now", this.now.bind(this)],
+      ["$uuid", this.uuid.bind(this)],
+      ["$add", this.add.bind(this)],
+      ["$sub", this.sub.bind(this)],
+      ["$mul", this.mul.bind(this)],
+      ["$div", this.div.bind(this)],
+      ["$mod", this.mod.bind(this)],
+      ["$eq", this.eq.bind(this)],
+      ["$ne", this.ne.bind(this)],
+      ["$gt", this.gt.bind(this)],
+      ["$gte", this.gte.bind(this)],
+      ["$lt", this.lt.bind(this)],
+      ["$lte", this.lte.bind(this)],
+      ["$and", this.and.bind(this)],
+      ["$or", this.or.bind(this)],
+      ["$not", this.not.bind(this)],
+      ["$coalesce", this.coalesce.bind(this)],
+      ["$contains", this.contains.bind(this)],
+      ["$startsWith", this.startsWith.bind(this)],
+      ["$endsWith", this.endsWith.bind(this)]
+    ]);
+  }
+  /**
+   * Evaluate an expression string against a context.
+   */
+  eval(expr, context) {
+    const trimmed = expr.trim();
+    const fnMatch = trimmed.match(/^(\$\w+)\((.*)\)$/s);
+    if (fnMatch) {
+      const fnName = fnMatch[1];
+      const argsStr = fnMatch[2];
+      const fn = this.functions.get(fnName);
+      if (!fn) {
+        throw new Error(`Unknown function: ${fnName}`);
+      }
+      return this.evalFunction(fn, argsStr, context);
+    }
+    if (trimmed.startsWith("$")) {
+      const field = trimmed.slice(1);
+      return context[field];
+    }
+    if (trimmed === "true") return true;
+    if (trimmed === "false") return false;
+    if (trimmed === "null") return null;
+    const num = Number(trimmed);
+    if (!isNaN(num) && trimmed !== "") return num;
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed.slice(1, -1);
+    }
+    return trimmed;
+  }
+  evalFunction(fn, argsStr, context) {
+    const args = this.parseArgs(argsStr, context);
+    return fn(...args);
+  }
+  parseArgs(argsStr, context) {
+    const args = [];
+    let depth = 0;
+    let current = "";
+    for (let i = 0; i < argsStr.length; i++) {
+      const char = argsStr[i];
+      if (char === "(" || char === "[" || char === "{") depth++;
+      else if (char === ")" || char === "]" || char === "}") depth--;
+      else if (char === "," && depth === 0) {
+        args.push(this.eval(current.trim(), context));
+        current = "";
+        continue;
+      }
+      current += char;
+    }
+    if (current.trim()) {
+      args.push(this.eval(current.trim(), context));
+    }
+    return args;
+  }
+  // Built-in functions
+  if(cond, trueVal, falseVal) {
+    return cond ? trueVal : falseVal;
+  }
+  round(value, decimals = 0) {
+    const n = Number(value);
+    const factor = Math.pow(10, Number(decimals));
+    return Math.round(n * factor) / factor;
+  }
+  concat(...args) {
+    return args.map((a) => String(a ?? "")).join("");
+  }
+  len(value) {
+    if (typeof value === "string") return value.length;
+    if (Array.isArray(value)) return value.length;
+    return 0;
+  }
+  lower(value) {
+    return String(value ?? "").toLowerCase();
+  }
+  upper(value) {
+    return String(value ?? "").toUpperCase();
+  }
+  trim(value) {
+    return String(value ?? "").trim();
+  }
+  now() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  uuid() {
+    return crypto.randomUUID();
+  }
+  add(...args) {
+    return args.reduce((sum, a) => sum + Number(a), 0);
+  }
+  sub(a, b) {
+    return Number(a) - Number(b);
+  }
+  mul(...args) {
+    return args.reduce((prod, a) => prod * Number(a), 1);
+  }
+  div(a, b) {
+    return Number(a) / Number(b);
+  }
+  mod(a, b) {
+    return Number(a) % Number(b);
+  }
+  eq(a, b) {
+    return a === b;
+  }
+  ne(a, b) {
+    return a !== b;
+  }
+  gt(a, b) {
+    return Number(a) > Number(b);
+  }
+  gte(a, b) {
+    return Number(a) >= Number(b);
+  }
+  lt(a, b) {
+    return Number(a) < Number(b);
+  }
+  lte(a, b) {
+    return Number(a) <= Number(b);
+  }
+  and(...args) {
+    return args.every(Boolean);
+  }
+  or(...args) {
+    return args.some(Boolean);
+  }
+  not(value) {
+    return !value;
+  }
+  coalesce(...args) {
+    for (const arg of args) {
+      if (arg !== null && arg !== void 0) return arg;
+    }
+    return null;
+  }
+  contains(haystack, needle) {
+    return String(haystack ?? "").includes(String(needle ?? ""));
+  }
+  startsWith(str, prefix) {
+    return String(str ?? "").startsWith(String(prefix ?? ""));
+  }
+  endsWith(str, suffix) {
+    return String(str ?? "").endsWith(String(suffix ?? ""));
+  }
+};
+function evalExpr(expr, context) {
+  const result = new ExprEvaluator().eval(expr, context);
+  if (result === null || result === void 0) return "";
+  if (typeof result === "boolean") return result ? "true" : "false";
+  if (typeof result === "number") return result;
+  if (typeof result === "string") return result;
+  if (typeof result === "object") return JSON.stringify(result);
+  return String(result);
+}
+
+// src/core/computation/rollup.ts
+function collectRollupRelatedIds(rollup, ctx) {
+  if (rollup.joinEntity) {
+    const { type, foreignKey } = rollup.joinEntity;
+    const facts = ctx.store.getFactsByAttribute(foreignKey);
+    const ids = [];
+    for (const fact of facts) {
+      if (fact.v !== ctx.entityId) continue;
+      const typeFacts = ctx.store.getFactsByEntity(fact.e);
+      const entityType = typeFacts.find((f) => f.a === "type")?.v;
+      if (entityType === type) ids.push(fact.e);
+    }
+    return ids;
+  }
+  const linkAttr = resolveLinkAttribute(rollup.relationProperty, ctx.schema);
+  const links = ctx.store.getLinksByEntityAndAttribute(ctx.entityId, linkAttr);
+  if (links.length > 0) return links.map((l) => l.e2);
+  return [];
+}
+function resolveLinkAttribute(relationProperty, schema) {
+  const field = schema?.fields.find((f) => f.name === relationProperty);
+  if (field?.valueType === "relation") return relationProperty;
+  return relationProperty;
+}
+function readTargetValue(store, entityId, targetProperty) {
+  if (targetProperty === "id") return entityId;
+  const facts = store.getFactsByEntity(entityId);
+  return facts.find((f) => f.a === targetProperty)?.v;
+}
+function toNumbers(values) {
+  const nums = [];
+  for (const v of values) {
+    if (typeof v === "number" && Number.isFinite(v)) nums.push(v);
+  }
+  return nums;
+}
+function evaluateRollup(rollup, ctx) {
+  const related = collectRollupRelatedIds(rollup, ctx);
+  if (rollup.aggregation === "count") {
+    return related.length;
+  }
+  const values = related.map((id) => readTargetValue(ctx.store, id, rollup.targetProperty)).filter((v) => v !== void 0);
+  const nums = toNumbers(values);
+  if (nums.length === 0) return 0;
+  switch (rollup.aggregation) {
+    case "sum":
+      return nums.reduce((a, b) => a + b, 0);
+    case "avg":
+      return nums.reduce((a, b) => a + b, 0) / nums.length;
+    case "min":
+      return Math.min(...nums);
+    case "max":
+      return Math.max(...nums);
+    case "median": {
+      const sorted = [...nums].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+    }
+    case "mode": {
+      const freq = /* @__PURE__ */ new Map();
+      for (const n of nums) freq.set(n, (freq.get(n) ?? 0) + 1);
+      let best = nums[0];
+      let bestCount = 0;
+      for (const [n, c] of freq) {
+        if (c > bestCount) {
+          best = n;
+          bestCount = c;
+        }
+      }
+      return best;
+    }
+    default:
+      return 0;
+  }
+}
+function projectRelationFields(binding, schema, store, entityId) {
+  for (const field of schema.fields) {
+    if (field.valueType !== "relation" || field.name in binding) continue;
+    const links = store.getLinksByEntityAndAttribute(entityId, field.name);
+    if (links.length === 0) continue;
+    const cardinality = field.relation?.cardinality ?? "many";
+    if (cardinality === "one") {
+      binding[field.name] = links[0].e2;
+    } else {
+      binding[field.name] = links.map((l) => l.e2).join(",");
+    }
+  }
+}
+
+// src/core/kernel/logic-middleware.ts
+function createLogicMiddleware(config) {
+  return {
+    name: "logic-computation",
+    handleQuery(query, ctx, next) {
+      const result = next(query);
+      if (result && Array.isArray(result.bindings)) {
+        const store = resolveStore(config, ctx);
+        for (const binding of result.bindings) {
+          enrichBinding(binding, config, store);
+        }
+      }
+      return result;
+    }
+  };
+}
+function resolveStore(config, ctx) {
+  if (config.getStore) return config.getStore();
+  return ctx.store;
+}
+function enrichBinding(binding, config, store) {
+  const row = binding;
+  const type = resolveEntityType(binding, config);
+  if (!type) return;
+  const schema = config.ontologies.get(type);
+  if (!schema) return;
+  const entityId = findEntityId(binding);
+  if (store && entityId) {
+    projectRelationFields(binding, schema, store, entityId);
+  }
+  for (const field of schema.fields) {
+    if (!(field.computed || field.formula || field.rollup || field.aiGenerated))
+      continue;
+    const fieldName = field.name;
+    if (fieldName in binding) continue;
+    if (field.formula) {
+      binding[fieldName] = evalExpr(field.formula, row);
+    }
+    if (field.rollup && store && entityId) {
+      binding[fieldName] = evaluateRollup(field.rollup, {
+        store,
+        entityId,
+        schema,
+        getEntityType: config.getEntityType
+      });
+    }
+    if (field.aiGenerated && config.generateAiField) {
+      const prompt = field.aiGenerated.prompt.replace(
+        /\{\{(\w+)\}\}/g,
+        (_, key) => String(row[key] ?? "")
+      );
+      config.generateAiField(prompt, row).then((value) => {
+        binding[fieldName] = value;
+      }).catch(() => {
+        binding[fieldName] = "";
+      });
+    }
+  }
+}
+function resolveEntityType(binding, config) {
+  const explicit = binding.type;
+  if (typeof explicit === "string" && explicit.length > 0) return explicit;
+  const entityId = findEntityId(binding);
+  if (entityId && config.getEntityType) {
+    return config.getEntityType(entityId);
+  }
+  return void 0;
+}
+function findEntityId(binding) {
+  for (const value of Object.values(binding)) {
+    if (typeof value === "string" && value.includes(":")) return value;
+  }
+  return void 0;
+}
+
+// src/core/kernel/boot-middleware.ts
+function buildOntologyIndex(schemas) {
+  const map = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    map.set(schema["@id"], schema);
+    const short = schema["@id"].includes(":") ? schema["@id"].split(":").pop() : schema["@id"];
+    if (short) {
+      map.set(short, schema);
+      map.set(short.toLowerCase(), schema);
+    }
+    if (schema.label) {
+      map.set(schema.label, schema);
+      map.set(schema.label.toLowerCase(), schema);
+    }
+  }
+  return map;
+}
+function attachStandardMiddleware(kernel) {
+  kernel.removeMiddleware("logic-computation");
+  const ontologies = buildOntologyIndex(kernel.listOntologies());
+  kernel.addMiddleware(
+    createLogicMiddleware({
+      ontologies,
+      getStore: () => kernel.getStore(),
+      getEntityType: (entityId) => kernel.getEntity(entityId)?.type
+    })
+  );
+}
+
+export {
+  ExprEvaluator,
+  evalExpr,
+  collectRollupRelatedIds,
+  evaluateRollup,
+  projectRelationFields,
+  createLogicMiddleware,
+  buildOntologyIndex,
+  attachStandardMiddleware
+};

package/dist/chunk-SQBNLUIA.js

@@ -0,0 +1,171 @@
+import {
+  inferProjectContext,
+  init_infer,
+  init_profile,
+  init_write,
+  loadProfile
+} from "./chunk-QERIS7QY.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
+};