@mindfoldhq/trellis 0.6.7 → 0.6.9

package/dist/templates/kimi/index.js

@@ -0,0 +1,22 @@
+/**
+ * Kimi Code template module.
+ *
+ * Kimi Code is a class-2 pull-based platform:
+ * - Workflow/bundled skills go to the shared `.agents/skills/` root via the
+ *   neutral resolver (byte-identical to Codex/Gemini/Pi writes).
+ * - User-invocable entry points (`trellis-start` / `trellis-continue` /
+ *   `trellis-finish-work`, invoked as `/skill:trellis-<name>`) and the Trellis
+ *   agent prompts live under `.kimi-code/skills/<name>/SKILL.md`.
+ *
+ * Kimi has no project-level hooks/settings file Trellis may write and no
+ * custom sub-agent definitions (built-in coder/explore/plan only), so the
+ * Trellis agent prompts ship as skills; trellis-implement / trellis-check get
+ * the pull-based prelude, trellis-research stays standalone.
+ */
+import { createTemplateReader } from "../template-utils.js";
+const { listMdAgents } = createTemplateReader(import.meta.url);
+/** Trellis agent prompts (trellis-implement, trellis-check, trellis-research), installed as Kimi skills. */
+export function getAllAgents() {
+    return listMdAgents();
+}
+//# sourceMappingURL=index.js.map

package/dist/templates/kimi/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/kimi/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,oBAAoB,EAAsB,MAAM,sBAAsB,CAAC;AAEhF,MAAM,EAAE,YAAY,EAAE,GAAG,oBAAoB,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAE/D,4GAA4G;AAC5G,MAAM,UAAU,YAAY;IAC1B,OAAO,YAAY,EAAE,CAAC;AACxB,CAAC"}

package/dist/templates/omp/extensions/trellis/index.ts.txt

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
-import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import { join, dirname, isAbsolute, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
@@ -40,7 +40,7 @@ function buildContextKey(platformName: string, kind: string, value: string): str
    return safeValue ? `${platformName}_${safeValue}` : `${platformName}_${hashValue(value)}`;
 }
 
-function deriveContextKey(ctx?: { sessionManager?: { getSessionId?: () => string; getSessionFile?: () => string } }): string | null {
+function deriveContextKey(ctx?: { sessionManager?: { getSessionId?: () => string | undefined; getSessionFile?: () => string | undefined } }): string | null {
    const sessionId = ctx?.sessionManager?.getSessionId?.();
    if (sessionId) {
       return buildContextKey("omp", "session", sessionId);
@@ -58,11 +58,118 @@ function isInsideRoot(root: string, candidate: string): boolean {
    return rel === "" || (rel !== ".." && !rel.startsWith("../") && !rel.startsWith("..\\") && !isAbsolute(rel));
 }
 
-function resolveProjectFile(projectRoot: string, file: string): string | null {
+// ---------------------------------------------------------------------------
+// Trusted context roots (mirrors packages/cli/src/commands/channel/context-trust.ts;
+// standalone copy since templates don't import from the CLI package).
+// ---------------------------------------------------------------------------
+
+const AUTO_TRUST_ENTRIES = ["tasks", "workspace"];
+
+function stripTrustValue(s: string): string {
+   return s.trim().replace(/\s*#.*$/, "").trim().replace(/^['"]|['"]$/g, "");
+}
+
+function parseChannelTrustSection(content: string): { trustedDirs: string[]; autoTrustSymlinks?: boolean } {
+   const lines = content.split("\n");
+   const trustedDirs: string[] = [];
+   let autoTrustSymlinks: boolean | undefined;
+   let inChannel = false;
+   let inList = false;
+
+   for (const raw of lines) {
+      const line = raw.replace(/\r$/, "");
+      const trimmed = line.trimEnd();
+      if (trimmed.trim().startsWith("#")) continue;
+
+      if (/^channel:\s*$/.test(trimmed)) {
+         inChannel = true;
+         inList = false;
+         continue;
+      }
+      if (!inChannel) continue;
+
+      if (trimmed.trim() !== "" && /^\S/.test(line)) {
+         inChannel = false;
+         inList = false;
+         continue;
+      }
+      if (trimmed.trim() === "") continue;
+
+      if (inList) {
+         const item = trimmed.match(/^ {4}-\s*(.+)$/);
+         if (item) {
+            const val = stripTrustValue(item[1]!);
+            if (val) trustedDirs.push(val);
+            continue;
+         }
+         inList = false;
+      }
+
+      if (/^ {2}trusted_context_dirs:\s*$/.test(trimmed)) {
+         inList = true;
+         continue;
+      }
+
+      const boolMatch = trimmed.match(/^ {2}auto_trust_trellis_symlinks:\s*(.+)$/);
+      if (boolMatch) {
+         const val = stripTrustValue(boolMatch[1]!).toLowerCase();
+         if (val === "false") autoTrustSymlinks = false;
+         else if (val === "true") autoTrustSymlinks = true;
+         else process.stderr.write(`[channel] channel.auto_trust_trellis_symlinks: invalid value '${val}', ignoring\n`);
+         continue;
+      }
+   }
+
+   return { trustedDirs, autoTrustSymlinks };
+}
+
+function resolveTrustedRoots(projectRoot: string): string[] {
+   const configPath = join(projectRoot, ".trellis", "config.yaml");
+   let config: { trustedDirs: string[]; autoTrustSymlinks?: boolean } = { trustedDirs: [] };
+   if (existsSync(configPath)) {
+      try {
+         config = parseChannelTrustSection(readFileSync(configPath, "utf-8"));
+      } catch {
+         // ignore
+      }
+   }
+
+   const roots: string[] = [];
+   for (const entry of config.trustedDirs) {
+      try {
+         roots.push(realpathSync(resolve(projectRoot, entry)));
+      } catch {
+         // entry not found or invalid — skip
+      }
+   }
+
+   if (config.autoTrustSymlinks !== false) {
+      for (const entryName of AUTO_TRUST_ENTRIES) {
+         const entryPath = join(projectRoot, ".trellis", entryName);
+         try {
+            if (lstatSync(entryPath).isSymbolicLink()) {
+               roots.push(realpathSync(entryPath));
+            }
+         } catch {
+            // missing / broken symlink — nothing to trust
+         }
+      }
+   }
+
+   return [...new Set(roots)];
+}
+
+function resolveProjectFile(
+   projectRoot: string,
+   file: string,
+   trustedRoots: string[],
+): string | null {
    try {
       const rootReal = realpathSync(projectRoot);
       const targetReal = realpathSync(resolve(projectRoot, file));
-      return isInsideRoot(rootReal, targetReal) ? targetReal : null;
+      if (isInsideRoot(rootReal, targetReal)) return targetReal;
+      if (trustedRoots.some((root) => isInsideRoot(root, targetReal))) return targetReal;
+      return null;
    } catch {
       return null;
    }
@@ -171,6 +278,9 @@ type AgentType = "trellis-implement" | "trellis-check" | "trellis-research" | nu
 
 function buildTaskContext(projectRoot: string, taskDir: string, agentType?: AgentType): string {
    const parts: string[] = [];
+   // Resolved once per call (not per referenced file) — avoids re-parsing
+   // config.yaml for every jsonl row.
+   const trustedRoots = resolveTrustedRoots(projectRoot);
 
    // prd.md and info.md — always included
    let prd = "";
@@ -212,7 +322,7 @@ function buildTaskContext(projectRoot: string, taskDir: string, agentType?: Agen
             const row = JSON.parse(trimmed) as Record<string, unknown>;
             const file = typeof row.file === "string" ? row.file.trim() : "";
             if (!file) continue;
-            const targetPath = resolveProjectFile(projectRoot, file);
+            const targetPath = resolveProjectFile(projectRoot, file, trustedRoots);
             if (!targetPath) continue;
             let content = "";
             try { content = readFileSync(targetPath, "utf-8"); } catch { }
@@ -336,7 +446,7 @@ export default function(pi: ExtensionAPI): void {
    let lastCompactionTs = 0;
    let lastInjectionTs = 0;
 
-   const rememberContextKey = (ctx?: { sessionManager?: { getSessionId?: () => string; getSessionFile?: () => string } }): string | null => {
+   const rememberContextKey = (ctx?: { sessionManager?: { getSessionId?: () => string | undefined; getSessionFile?: () => string | undefined } }): string | null => {
       const key = deriveContextKey(ctx);
       if (!key) return null;
       return key;
@@ -439,24 +549,38 @@ export default function(pi: ExtensionAPI): void {
          messages: [
             ...event.messages,
             {
-               role: "custom",
+               role: "custom" as const,
                customType: "trellis-workflow-state",
                content: cached.workflowMsg,
+               display: false,
                timestamp: Date.now(),
             },
          ],
       };
    });
 
+   // OMP passes Bash event.input through to the tool execution parameters, so
+   // inject the session key through the shell-agnostic env field. An explicit
+   // per-call value wins over the derived key.
+   pi.on("tool_call", (event, ctx) => {
+      if (event.toolName !== "bash") return;
+      const contextKey = rememberContextKey(ctx);
+      if (!contextKey) return;
+      const input = event.input as { env?: Record<string, string> };
+      input.env = {
+         TRELLIS_CONTEXT_ID: contextKey,
+         ...input.env,
+      };
+   });
+
    pi.on("input", async (_event, ctx) => {
       if (!projectRoot) {
          projectRoot = findProjectRoot(ctx.cwd);
       }
       // Resolve projectRoot on first input if session_start missed it
-      if (!projectRoot) return { action: "continue" };
+      if (!projectRoot) return;
       const contextKey = rememberContextKey(ctx);
       // Pre-warm the cache so before_agent_start and context can use it
       turnCache.get(projectRoot, contextKey);
-      return { action: "continue" };
    });
 }

package/dist/templates/opencode/lib/session-utils.js

@@ -8,8 +8,14 @@ import { debugLog } from "./trellis-context.js"
 const PYTHON_CMD = platform() === "win32" ? "python" : "python3"
 
 const FIRST_REPLY_NOTICE = `<first-reply-notice>
-First visible reply: say once in Chinese that Trellis SessionStart context is loaded, then answer directly.
-This notice is one-shot: do not repeat it after the first assistant reply in the same session.
+On the first visible assistant reply in this session, briefly acknowledge that Trellis SessionStart context loaded.
+Choose the acknowledgment language in this order:
+1. Use the language of the user's current request (the user message that triggered this reply).
+2. If that request has no clear natural language, use an explicitly established project communication language.
+3. If neither provides a language, output the language-neutral fallback exactly: \`Trellis SessionStart ✓\`.
+Continue directly with the user's request after the acknowledgment.
+The acknowledgment must not alter the language used for the remainder of the response.
+This notice is one-shot: do not repeat it after the first visible assistant reply in this session.
 </first-reply-notice>`
 
 function hasCuratedJsonlEntry(jsonlPath) {

package/dist/templates/opencode/lib/trellis-context.js

@@ -5,11 +5,12 @@
  * JSONL parsing, and context building capabilities.
  */
 
-import { existsSync, readFileSync, appendFileSync, readdirSync } from "fs"
+import { existsSync, readFileSync, appendFileSync, readdirSync, statSync } from "fs"
 import { isAbsolute, join } from "path"
 import { platform } from "os"
 import { execSync } from "child_process"
 import { createHash } from "crypto"
+import { Buffer, isUtf8 } from "buffer"
 import process from "process"
 
 const PYTHON_CMD = platform() === "win32" ? "python" : "python3"
@@ -78,6 +79,240 @@ export function isTrellisSubagent(input) {
   return TRELLIS_SUBAGENT_RE.test(agent)
 }
 
+// ============================================================
+// Context Injection Limits (issue #441)
+//
+// Notice text and behavior mirrored byte-for-byte from the shared-hooks
+// Python sub-agent context injection hook and the Pi extension. Changing
+// wording here requires changing it there too.
+// ============================================================
+
+const DEFAULT_CONTEXT_INJECTION_LIMITS = {
+  max_file_bytes: 32768,
+  max_artifact_bytes: 65536,
+  max_total_bytes: 131072,
+}
+
+/**
+ * Truncate `buf` to at most `cap` bytes without splitting a UTF-8
+ * multi-byte sequence. `cap <= 0` means "no limit".
+ */
+function truncateUtf8(buf, cap) {
+  if (cap <= 0 || buf.length <= cap) return buf
+  let i = cap
+  // Back off over continuation bytes (10xxxxxx) to find the lead byte.
+  while (i > 0 && (buf[i - 1] & 0xc0) === 0x80) i--
+  if (i === 0) return Buffer.alloc(0)
+  const lead = buf[i - 1]
+  if (lead & 0x80) {
+    let seqLen = 1
+    if ((lead & 0xe0) === 0xc0) seqLen = 2
+    else if ((lead & 0xf0) === 0xe0) seqLen = 3
+    else if ((lead & 0xf8) === 0xf0) seqLen = 4
+    // Drop the lead byte too if its full sequence didn't fit.
+    if (i - 1 + seqLen > cap) i--
+  }
+  return buf.subarray(0, i)
+}
+
+function stripInlineComment(value) {
+  let inQuote = null
+  for (let idx = 0; idx < value.length; idx++) {
+    const ch = value[idx]
+    if (inQuote) {
+      if (ch === inQuote) inQuote = null
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch
+      continue
+    }
+    if (ch === "#" && (idx === 0 || /\s/.test(value[idx - 1]))) {
+      return value.slice(0, idx)
+    }
+  }
+  return value
+}
+
+function unquoteYaml(s) {
+  if (s.length >= 2 && s[0] === s[s.length - 1] && (s[0] === '"' || s[0] === "'")) {
+    return s.slice(1, -1)
+  }
+  return s
+}
+
+/**
+ * Line-based parser for ONLY the `context_injection:` block of
+ * `.trellis/config.yaml`. Not a general YAML parser — mirrors
+ * `common.config.get_context_injection_limits()` semantics for this
+ * section only (missing keys keep the default; invalid/negative values
+ * fall back to the default for that key with a debugLog warning).
+ */
+function readContextInjectionLimits(repoRoot) {
+  const limits = { ...DEFAULT_CONTEXT_INJECTION_LIMITS }
+  let text = null
+  try {
+    text = readFileSync(join(repoRoot, ".trellis", "config.yaml"), "utf-8")
+  } catch {
+    return limits
+  }
+  if (!text) return limits
+
+  let inSection = false
+  let sectionIndent = -1
+  for (const rawLine of text.split(/\r?\n/)) {
+    const trimmed = rawLine.trim()
+    if (!inSection) {
+      if (/^context_injection\s*:\s*(#.*)?$/.test(trimmed)) {
+        inSection = true
+        sectionIndent = rawLine.length - rawLine.trimStart().length
+      }
+      continue
+    }
+    if (!trimmed || trimmed.startsWith("#")) continue
+    const indent = rawLine.length - rawLine.trimStart().length
+    if (indent <= sectionIndent) break
+    const m = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.*)$/)
+    if (!m) continue
+    const key = m[1]
+    if (!(key in limits)) continue
+    const raw = unquoteYaml(stripInlineComment(m[2]).trim()).trim()
+    if (!/^-?\d+$/.test(raw) || parseInt(raw, 10) < 0) {
+      // invalid/negative -> keep default (Python warns on stderr)
+      debugLog("context", `invalid context_injection.${key} value: ${raw}; using default ${limits[key]}`)
+      continue
+    }
+    limits[key] = parseInt(raw, 10)
+  }
+  return limits
+}
+
+/** Tracks the running total of bytes emitted into the sub-agent context. */
+class ContextBudget {
+  constructor(maxTotalBytes) {
+    this.maxTotalBytes = maxTotalBytes
+    this.used = 0
+  }
+
+  hasRoom(size) {
+    if (this.maxTotalBytes <= 0) return true
+    return this.used + size <= this.maxTotalBytes
+  }
+
+  add(size) {
+    this.used += size
+  }
+}
+
+function truncateNotice(path, cap) {
+  return `\n[Trellis: truncated at ${cap} bytes — read ${path} for the full content]`
+}
+
+function isBinaryContent(data) {
+  return data.includes(0) || !isUtf8(data)
+}
+
+function binaryNotice(path, size, reason) {
+  return `[Trellis: not inlined (binary file) — ${path} (${size} bytes): ${reason}]`
+}
+
+function indexNotice(path, size, reason) {
+  return `[Trellis: not inlined (total context limit reached) — ${path} (${size} bytes): ${reason}]`
+}
+
+/**
+ * Return an inlined `=== header ===` block, or degrade to an index
+ * notice once the total context budget is exhausted.
+ */
+function budgetedBlock(budget, header, plainPath, content, reason, sizeForIndex) {
+  const block = `=== ${header} ===\n${content}`
+  const blockBytes = Buffer.byteLength(block, "utf-8")
+  if (!budget.hasRoom(blockBytes)) {
+    const notice = indexNotice(plainPath, sizeForIndex, reason)
+    budget.add(Buffer.byteLength(notice, "utf-8"))
+    return notice
+  }
+  budget.add(blockBytes)
+  return block
+}
+
+/** Read raw file bytes, return null if file doesn't exist. */
+function readFileBytes(basePath, filePath) {
+  const fullPath = isAbsolute(filePath) ? filePath : join(basePath, filePath)
+  try {
+    if (!statSync(fullPath).isFile()) return null
+  } catch {
+    return null
+  }
+  try {
+    return readFileSync(fullPath)
+  } catch {
+    return null
+  }
+}
+
+/** Read a JSONL-referenced file, apply the per-file cap, then budget it. */
+function materializeFile(basePath, filePath, reason, limits, budget) {
+  const data = readFileBytes(basePath, filePath)
+  if (data === null) return null
+
+  const size = data.length
+  if (isBinaryContent(data)) {
+    const notice = binaryNotice(filePath, size, reason)
+    budget.add(Buffer.byteLength(notice, "utf-8"))
+    return notice
+  }
+  const cap = limits.max_file_bytes
+  const truncated = truncateUtf8(data, cap)
+  let content = truncated.toString("utf-8")
+  if (truncated.length < size) content += truncateNotice(filePath, cap)
+
+  return budgetedBlock(budget, filePath, filePath, content, reason, size)
+}
+
+/**
+ * Read all .md files in a directory, applying the same per-file and
+ * total caps as a single-file JSONL entry.
+ */
+function materializeDirectory(basePath, dirPath, reason, limits, budget, maxFiles = 20) {
+  const blocks = []
+  const fullPath = isAbsolute(dirPath) ? dirPath : join(basePath, dirPath)
+
+  let files
+  try {
+    if (!statSync(fullPath).isDirectory()) return blocks
+    files = readdirSync(fullPath)
+      .filter(f => f.endsWith(".md") && statSync(join(fullPath, f)).isFile())
+      .sort()
+  } catch {
+    return blocks
+  }
+
+  for (const filename of files.slice(0, maxFiles)) {
+    const relativePath = join(dirPath, filename)
+    const block = materializeFile(basePath, relativePath, reason, limits, budget)
+    if (block) blocks.push(block)
+  }
+  return blocks
+}
+
+/**
+ * Read a task artifact (prd/design/implement.md), apply the per-artifact
+ * cap, then budget it.
+ */
+function materializeArtifact(basePath, filePath, headerLabel, reason, limits, budget) {
+  const data = readFileBytes(basePath, filePath)
+  if (data === null) return null
+
+  const size = data.length
+  const cap = limits.max_artifact_bytes
+  const truncated = truncateUtf8(data, cap)
+  let content = truncated.toString("utf-8")
+  if (truncated.length < size) content += truncateNotice(filePath, cap)
+
+  return budgetedBlock(budget, headerLabel, filePath, content, reason, size)
+}
+
 /**
  * Trellis Context Manager
  */
@@ -282,44 +517,21 @@ export class TrellisContext {
   // JSONL Reading
   // ============================================================
 
-  readDirectoryMdFiles(dirPath, maxFiles = 20) {
-    const results = []
-    const fullPath = join(this.directory, dirPath)
-
-    if (!existsSync(fullPath)) {
-      return results
-    }
-
-    try {
-      const files = readdirSync(fullPath)
-        .filter(f => f.endsWith(".md"))
-        .sort()
-        .slice(0, maxFiles)
-
-      for (const filename of files) {
-        const filePath = join(dirPath, filename)
-        const content = this.readProjectFile(filePath)
-        if (content) {
-          results.push({ path: filePath, content })
-        }
-      }
-    } catch {
-      // Ignore directory read errors
-    }
-
-    return results
-  }
-
   /**
-   * Read a JSONL file and load referenced files/directories
+   * Read a JSONL file and materialize referenced files/directories into
+   * context blocks, applying per-file caps and the shared total budget
+   * (issue #441). Mirrors Python `_materialize_jsonl_entries`.
    * Supports:
    *   {"file": "path/to/file.md", "reason": "..."}
    *   {"file": "path/to/dir/", "type": "directory", "reason": "..."}
+   *
+   * Missing referenced files are skipped silently (Python `_materialize_file`
+   * returns None for them).
    */
-  readJsonlWithFiles(jsonlPath) {
-    const results = []
+  readJsonlWithFiles(jsonlPath, limits, budget) {
+    const blocks = []
     const content = this.readFile(jsonlPath)
-    if (!content) return results
+    if (!content) return blocks
 
     for (const line of content.split("\n")) {
       if (!line.trim()) continue
@@ -327,28 +539,25 @@ export class TrellisContext {
         const item = JSON.parse(line)
         const file = item.file || item.path
         const entryType = item.type || "file"
+        const reason = item.reason || "-"
 
         if (!file) continue
 
         if (entryType === "directory") {
-          const dirEntries = this.readDirectoryMdFiles(file)
-          results.push(...dirEntries)
+          blocks.push(...materializeDirectory(this.directory, file, reason, limits, budget))
         } else {
-          const fullPath = join(this.directory, file)
-          const fileContent = this.readFile(fullPath)
-          if (fileContent) {
-            results.push({ path: file, content: fileContent })
-          }
+          const block = materializeFile(this.directory, file, reason, limits, budget)
+          if (block) blocks.push(block)
         }
       } catch {
         // Ignore parse errors for individual lines
       }
     }
-    return results
+    return blocks
   }
 
-  buildContextFromEntries(entries) {
-    return entries.map(e => `=== ${e.path} ===\n${e.content}`).join("\n\n")
+  buildContextFromEntries(blocks) {
+    return blocks.join("\n\n")
   }
 }
 
@@ -379,3 +588,14 @@ export const contextCollector = new ContextCollector()
 
 // Export debug log for plugins
 export { debugLog }
+
+// Context injection limits (issue #441) — exported for plugins and tests
+export {
+  DEFAULT_CONTEXT_INJECTION_LIMITS,
+  truncateUtf8,
+  readContextInjectionLimits,
+  ContextBudget,
+  materializeFile,
+  materializeDirectory,
+  materializeArtifact,
+}