trellis 3.1.35 → 3.2.0

package/dist/chunk-A3BONW34.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-AHMDVHBL.js

@@ -0,0 +1,141 @@
+import {
+  SqliteKernelBackend
+} from "./chunk-XMQ7G77X.js";
+import {
+  TrellisKernel
+} from "./chunk-LZR3VIFU.js";
+
+// src/server/tenancy.ts
+import { existsSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+var DEFAULT_TENANT = "default";
+var TENANTS_DIR = "tenants";
+var TenantPool = class {
+  pool = /* @__PURE__ */ new Map();
+  dbPath;
+  agentId;
+  backendOpts;
+  constructor(dbPath, agentIdOrOpts = "trellis-db") {
+    this.dbPath = resolve(dbPath);
+    if (typeof agentIdOrOpts === "string") {
+      this.agentId = agentIdOrOpts;
+      this.backendOpts = void 0;
+    } else {
+      this.agentId = agentIdOrOpts.agentId ?? "trellis-db";
+      this.backendOpts = agentIdOrOpts.backend;
+    }
+    this._ensureDirs();
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /**
+   * Get (or create) the kernel for a tenant.
+   * Pass `null` or `undefined` to get the default tenant.
+   *
+   * Uses the synchronous bun:sqlite backend. To use an async backend
+   * (better-sqlite3, sql.js) call `preload(tenantId)` first; subsequent
+   * `get()` calls will return the preloaded kernel from the pool.
+   */
+  get(tenantId) {
+    const id = tenantId ?? DEFAULT_TENANT;
+    if (!this.pool.has(id)) {
+      this.pool.set(id, this._createKernelSync(id));
+    }
+    return this.pool.get(id);
+  }
+  /**
+   * Pre-create a tenant's kernel using the runtime-selected backend.
+   * Required when running with an async-only backend (sql.js / WebContainer
+   * / browser). Idempotent — safe to call multiple times.
+   *
+   * After `preload()`, subsequent `get(tenantId)` returns the same kernel
+   * synchronously from the pool.
+   */
+  async preload(tenantId) {
+    const id = tenantId ?? DEFAULT_TENANT;
+    const cached = this.pool.get(id);
+    if (cached) return cached;
+    const kernel = await this._createKernelAsync(id);
+    this.pool.set(id, kernel);
+    return kernel;
+  }
+  /**
+   * Check whether a tenant has been initialized (kernel created).
+   */
+  has(tenantId) {
+    return this.pool.has(tenantId);
+  }
+  /**
+   * List all active tenant IDs (those with open kernels).
+   */
+  activeTenants() {
+    return Array.from(this.pool.keys());
+  }
+  /**
+   * Close a specific tenant's kernel and remove it from the pool.
+   */
+  close(tenantId) {
+    const kernel = this.pool.get(tenantId);
+    if (kernel) {
+      kernel.close();
+      this.pool.delete(tenantId);
+    }
+  }
+  /**
+   * Close all kernels and clear the pool.
+   */
+  closeAll() {
+    for (const kernel of this.pool.values()) {
+      kernel.close();
+    }
+    this.pool.clear();
+  }
+  /**
+   * Return the SQLite file path for a given tenant.
+   */
+  dbFilePath(tenantId) {
+    const id = tenantId ?? DEFAULT_TENANT;
+    if (id === DEFAULT_TENANT) {
+      return join(this.dbPath, "default.sqlite");
+    }
+    return join(this.dbPath, TENANTS_DIR, `${id}.sqlite`);
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  _createKernelSync(tenantId) {
+    const sqlitePath = this.dbFilePath(tenantId);
+    const backend = new SqliteKernelBackend(sqlitePath);
+    return this._wrapKernel(backend);
+  }
+  async _createKernelAsync(tenantId) {
+    const sqlitePath = this.dbFilePath(tenantId);
+    const { createKernelBackend } = await import("./core/persist/factory.js");
+    const backend = await createKernelBackend(sqlitePath, this.backendOpts);
+    return this._wrapKernel(backend);
+  }
+  _wrapKernel(backend) {
+    const kernel = new TrellisKernel({
+      backend,
+      agentId: this.agentId,
+      snapshotThreshold: 1e3
+    });
+    kernel.boot();
+    return kernel;
+  }
+  _ensureDirs() {
+    if (!existsSync(this.dbPath)) {
+      mkdirSync(this.dbPath, { recursive: true });
+    }
+    const tenantsPath = join(this.dbPath, TENANTS_DIR);
+    if (!existsSync(tenantsPath)) {
+      mkdirSync(tenantsPath, { recursive: true });
+    }
+  }
+};
+
+export {
+  DEFAULT_TENANT,
+  TenantPool
+};

package/dist/chunk-AW6A4OZY.js

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