trellis 3.1.35 → 3.2.0

package/dist/chunk-FES3TC24.js

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

package/dist/chunk-FF36CQHZ.js

@@ -0,0 +1,61 @@
+// src/server/sprites.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function runSpriteCmd(args) {
+  try {
+    const { stdout } = await execFileAsync("sprite", args);
+    return stdout.trim();
+  } catch (err) {
+    throw new Error(
+      `sprite ${args[0]} failed (exit ${err.code ?? "?"}): ${err.stderr ?? err.message}`
+    );
+  }
+}
+async function runSpriteCopy(localPath, spriteName, remotePath) {
+  try {
+    await execFileAsync("sprite", [
+      "cp",
+      localPath,
+      `${spriteName}:${remotePath}`
+    ]);
+  } catch (err) {
+    throw new Error(
+      `sprite cp failed (exit ${err.code ?? "?"}): ${err.stderr ?? err.message}`
+    );
+  }
+}
+async function runSpriteInteractive(args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("sprite", args, { stdio: "inherit" });
+    proc.on("close", (code) => {
+      if (code !== 0)
+        reject(new Error(`sprite ${args[0]} failed (exit ${code})`));
+      else resolve();
+    });
+    proc.on("error", reject);
+  });
+}
+async function assertSpriteCli() {
+  await runSpriteCmd(["--version"]).catch(() => {
+    throw new Error(
+      "`sprite` CLI not found. Install it from https://docs.sprites.dev and authenticate."
+    );
+  });
+}
+function resolveSprite(explicitName) {
+  if (explicitName) {
+    return explicitName;
+  }
+  throw new Error(
+    "No sprite specified. Use --sprite <name> or set an active sprite with `trellis vm use <name>`"
+  );
+}
+
+export {
+  runSpriteCmd,
+  runSpriteCopy,
+  runSpriteInteractive,
+  assertSpriteCli,
+  resolveSprite
+};

package/dist/chunk-FKQO5A3H.js

@@ -0,0 +1,35 @@
+import {
+  __require
+} from "./chunk-KFQGP6VL.js";
+
+// src/core/persist/factory.ts
+async function createKernelBackend(dbPath, opts = {}) {
+  const choice = opts.backend ?? detectBackend();
+  if (choice === "better-sqlite") {
+    const { BetterSqliteKernelBackend } = await import("./better-sqlite-backend-2P4F6AOJ.js");
+    const backend2 = new BetterSqliteKernelBackend(dbPath);
+    backend2.init();
+    return backend2;
+  }
+  const { SqlJsKernelBackend } = await import("./core/persist/sqljs-backend.js");
+  const backend = await SqlJsKernelBackend.create({
+    dbPath,
+    autoFlushEvery: opts.sqljs?.autoFlushEvery
+  });
+  backend.init();
+  return backend;
+}
+function detectBackend() {
+  try {
+    const { createRequire } = __require("module");
+    const req = createRequire(import.meta.url);
+    req("better-sqlite3");
+    return "better-sqlite";
+  } catch {
+    return "sqljs";
+  }
+}
+
+export {
+  createKernelBackend
+};

package/dist/chunk-FOWKR5TW.js

@@ -0,0 +1,129 @@
+import {
+  bindingEntityId
+} from "./chunk-5CINODKT.js";
+
+// src/schema/eql.ts
+function escapeValue(v) {
+  return v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function entitiesQuery(type, where) {
+  const conds = [`type = "${escapeValue(type)}"`];
+  for (const [k, v] of Object.entries(where ?? {})) {
+    if (v === void 0 || v === null) continue;
+    conds.push(`${k} = "${escapeValue(String(v))}"`);
+  }
+  return `find ?e where ${conds.join(" and ")}`;
+}
+
+// src/schema/resolve.ts
+function isNestedResolveSpec(v) {
+  return typeof v === "object" && v !== null;
+}
+function relationTargetName(r) {
+  return typeof r.target === "string" ? r.target : r.target().type;
+}
+function relationTargetSchema(r) {
+  return typeof r.target === "string" ? null : r.target();
+}
+function inverseForeignKey(parent, relationName, child) {
+  for (const [key, r] of Object.entries(child.relations)) {
+    if (relationTargetName(r) === parent.type) return key;
+  }
+  return null;
+}
+async function loadByIds(client, ids, cache) {
+  const missing = ids.filter((id) => !cache.has(id));
+  if (missing.length === 0) return;
+  await Promise.all(
+    missing.map(async (id) => {
+      cache.set(id, await client.read(id));
+    })
+  );
+}
+async function resolveReverseMany(client, parent, relationName, parents, cache) {
+  const rel = parent.relations[relationName];
+  if (!rel || rel.cardinality !== "many") return;
+  const childSchema = relationTargetSchema(rel);
+  if (!childSchema) return;
+  const foreignKey = inverseForeignKey(parent, relationName, childSchema);
+  if (!foreignKey) return;
+  const parentIds = new Set(parents.map((p) => p.id));
+  const qr = await client.query(entitiesQuery(childSchema.type));
+  const childIds = qr.bindings.map((b) => bindingEntityId(b)).filter((id) => Boolean(id));
+  await loadByIds(client, childIds, cache);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const id of childIds) {
+    const child = cache.get(id);
+    if (!child) continue;
+    const fk = child[foreignKey];
+    if (typeof fk !== "string" || !parentIds.has(fk)) continue;
+    if (!grouped.has(fk)) grouped.set(fk, []);
+    grouped.get(fk).push(child);
+  }
+  for (const row of parents) {
+    row[relationName] = grouped.get(row.id) ?? [];
+  }
+}
+async function resolveForwardOne(client, parents, relationName, cache) {
+  const ids = parents.map((p) => p[relationName]).filter((v) => typeof v === "string" && v.length > 0);
+  await loadByIds(client, ids, cache);
+  for (const row of parents) {
+    const ref = row[relationName];
+    if (typeof ref !== "string") continue;
+    const loaded = cache.get(ref);
+    if (loaded) row[relationName] = loaded;
+  }
+}
+async function resolveRelations(client, schema, entities, spec, opts) {
+  if (entities.length === 0 || Object.keys(spec).length === 0) return entities;
+  const cache = /* @__PURE__ */ new Map();
+  const rows = opts?.copy === false ? entities : entities.map((e) => ({ ...e }));
+  for (const [name, enabled] of Object.entries(spec)) {
+    if (!enabled) continue;
+    const rel = schema.relations[name];
+    if (!rel) continue;
+    if (rel.cardinality === "many") {
+      await resolveReverseMany(client, schema, name, rows, cache);
+      if (isNestedResolveSpec(enabled)) {
+        const childSchema = relationTargetSchema(rel);
+        if (childSchema) {
+          for (const row of rows) {
+            const kids = row[name];
+            if (kids?.length) {
+              await resolveRelations(client, childSchema, kids, enabled, {
+                copy: false
+              });
+            }
+          }
+        }
+      }
+    } else if (isNestedResolveSpec(enabled)) {
+      await resolveForwardOne(client, rows, name, cache);
+      const childSchema = relationTargetSchema(rel);
+      if (childSchema) {
+        const nested = [];
+        for (const row of rows) {
+          const loaded = row[name];
+          if (loaded && typeof loaded === "object" && "id" in loaded) {
+            nested.push(loaded);
+          }
+        }
+        if (nested.length) {
+          await resolveRelations(client, childSchema, nested, enabled, {
+            copy: false
+          });
+        }
+      }
+    } else {
+      await resolveForwardOne(client, rows, name, cache);
+    }
+  }
+  return rows;
+}
+
+export {
+  escapeValue,
+  entitiesQuery,
+  inverseForeignKey,
+  resolveRelations
+};

package/dist/chunk-FZVCXDYW.js

@@ -0,0 +1,150 @@
+import {
+  runSpriteCmd,
+  runSpriteCopy
+} from "./chunk-FF36CQHZ.js";
+import {
+  updateConfig
+} from "./chunk-JA7AIHRK.js";
+import {
+  __require
+} from "./chunk-KFQGP6VL.js";
+
+// src/server/deploy.ts
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+async function deploy(opts) {
+  const { name, port = 3e3, configDir = ".", onProgress = () => {
+  } } = opts;
+  const apiKey = opts.apiKey ?? generateSecret("spk_");
+  const jwtSecret = opts.jwtSecret ?? generateSecret("jws_");
+  const url = `https://${name}.sprites.app`;
+  onProgress("Checking Sprites CLI...");
+  await runSpriteCmd(["--version"]).catch(() => {
+    throw new Error(
+      "`sprite` CLI not found. Install it from https://docs.sprites.dev and authenticate."
+    );
+  });
+  onProgress("Writing server entrypoint...");
+  const tmpDir = resolve(configDir, ".trellis-deploy");
+  if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true });
+  const entrypoint = join(tmpDir, "server-entry.ts");
+  writeFileSync(
+    entrypoint,
+    generateServerEntrypoint({ port, apiKey, jwtSecret })
+  );
+  onProgress("Bundling server with Bun...");
+  const bundlePath = join(tmpDir, "server.js");
+  await runBun([
+    "build",
+    entrypoint,
+    "--outfile",
+    bundlePath,
+    "--target",
+    "bun",
+    "--format",
+    "esm"
+  ]);
+  onProgress(`Uploading to Sprite: ${name}...`);
+  await runSpriteCmd([
+    "exec",
+    "--sprite",
+    name,
+    "mkdir",
+    "-p",
+    "/home/sprite/trellis-db"
+  ]);
+  await runSpriteCopy(bundlePath, name, "/home/sprite/trellis-db/server.js");
+  onProgress("Ensuring Bun is installed...");
+  await runSpriteCmd([
+    "exec",
+    "--sprite",
+    name,
+    "bash",
+    "-c",
+    "which bun || curl -fsSL https://bun.sh/install | bash"
+  ]).catch(() => {
+  });
+  onProgress("Starting server...");
+  await runSpriteCmd([
+    "exec",
+    "--sprite",
+    name,
+    "bash",
+    "-c",
+    "sprite sessions list 2>/dev/null | grep trellis-db | awk '{print $1}' | xargs -r sprite sessions kill"
+  ]).catch(() => {
+  });
+  await runSpriteCmd([
+    "exec",
+    "--sprite",
+    name,
+    "-tty",
+    "--detach",
+    "--session-name",
+    "trellis-db",
+    "bash",
+    "-c",
+    `cd /home/sprite/trellis-db && ~/.bun/bin/bun run server.js`
+  ]);
+  onProgress("Writing .trellis-db.json...");
+  updateConfig(
+    {
+      mode: "remote",
+      url,
+      apiKey,
+      spriteName: name,
+      deployedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    configDir
+  );
+  return { url, name, apiKey };
+}
+function generateSecret(prefix) {
+  const bytes = new Uint8Array(24);
+  crypto.getRandomValues(bytes);
+  const b64 = btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `${prefix}${b64}`;
+}
+async function runBun(args) {
+  const { execFile } = __require("child_process");
+  const { promisify } = __require("util");
+  const execFileAsync = promisify(execFile);
+  try {
+    await execFileAsync("bun", args);
+  } catch (err) {
+    throw new Error(
+      `bun ${args[0]} failed (exit ${err.code ?? "?"}): ${err.stderr ?? err.message}`
+    );
+  }
+}
+function generateServerEntrypoint(opts) {
+  return `
+import { TenantPool, startServer } from 'trellis/server';
+import { readConfig, defaultLocalConfig, writeConfig } from 'trellis/client';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+const dbPath = '/home/sprite/trellis-db/data';
+const configDir = '/home/sprite/trellis-db';
+
+if (!existsSync(join(configDir, '.trellis-db.json'))) {
+  writeConfig(defaultLocalConfig(dbPath, {
+    apiKey: '${opts.apiKey}',
+    jwtSecret: '${opts.jwtSecret}',
+    port: ${opts.port},
+  }), configDir);
+}
+
+const config = readConfig(configDir)!;
+const pool = new TenantPool(dbPath);
+
+const server = startServer({ port: ${opts.port}, config, pool });
+
+console.log('Trellis DB running on port ${opts.port}');
+console.log('URL: https://\${process.env.SPRITE_NAME ?? 'localhost'}.sprites.app');
+`;
+}
+
+export {
+  deploy
+};