opencode-rules-md 0.8.6 → 0.9.1

package/src/rule-filter.ts

@@ -59,12 +59,23 @@ export function toolsMatchAvailable(
   return requiredTools.some(tool => availableSet.has(tool));
 }
 
+/**
+ * Rough token estimate using the chars/4 heuristic.
+ * No external dependency; accurate enough for budget decisions.
+ */
+export function estimateTokens(text: string): number {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+
 /**
  * Result of reading and formatting rules
  */
 export interface FilterResult {
   formattedRules: string;
   matchedPaths: string[];
+  /** Estimated token count of formattedRules (0 when empty) */
+  tokenEstimate: number;
 }
 
 /**
@@ -91,6 +102,8 @@ export interface RuleFilterContext {
   os?: string;
   /** Whether running in CI environment */
   ci?: boolean;
+  /** Optional hard token cap; lowest-priority rules are dropped when exceeded. */
+  maxTokens?: number;
 }
 
 /**
@@ -103,16 +116,26 @@ export async function readAndFormatRules(
   context: RuleFilterContext = {}
 ): Promise<FilterResult> {
   if (files.length === 0) {
-    return { formattedRules: '', matchedPaths: [] };
+    return { formattedRules: '', matchedPaths: [], tokenEstimate: 0 };
   }
 
-  const ruleContents: string[] = [];
-  const matchedPaths: string[] = [];
   const availableToolSet =
     context.availableToolIDs && context.availableToolIDs.length > 0
       ? new Set(context.availableToolIDs)
       : undefined;
 
+  // Collect matched entries with priority and token count
+  type MatchedEntry = {
+    filePath: string;
+    relativePath: string;
+    strippedContent: string;
+    priority: number;
+    tokenCount: number;
+    index: number;
+  };
+  const entries: MatchedEntry[] = [];
+  let entryIndex = 0;
+
   for (const { filePath, relativePath } of files) {
     // Use cached rule data with mtime-based invalidation
     const cachedRule = await getCachedRule(filePath);
@@ -250,20 +273,58 @@ export async function readAndFormatRules(
       );
     }
 
-    // Use cached stripped content for output
-    // Use relativePath for unique headings instead of just filename
-    ruleContents.push(`## ${relativePath}\n\n${strippedContent}`);
-    matchedPaths.push(filePath);
+    // Extract priority (default 0 for selection; undefined in metadata means absent)
+    const priority = metadata?.priority ?? 0;
+
+    // Build formatted chunk for token counting
+    const formattedChunk = `## ${relativePath}\n\n${strippedContent}`;
+    const tokenCount = estimateTokens(formattedChunk);
+
+    entries.push({ filePath, relativePath, strippedContent, priority, tokenCount, index: entryIndex++ });
   }
 
-  if (ruleContents.length === 0) {
-    return { formattedRules: '', matchedPaths: [] };
+  if (entries.length === 0) {
+    return { formattedRules: '', matchedPaths: [], tokenEstimate: 0 };
   }
 
+  // Determine which entries to include based on budget
+  const maxTokens = context.maxTokens;
+  const hasValidBudget = typeof maxTokens === 'number' && maxTokens > 0 && Number.isFinite(maxTokens);
+
+  let survivors: MatchedEntry[];
+  if (!hasValidBudget) {
+    // No budget: use discovery order (existing behavior)
+    survivors = entries;
+  } else {
+    // Valid budget: stable sort by priority desc, index asc
+    const sorted = [...entries].sort((a, b) =>
+      (b.priority - a.priority) || (a.index - b.index)
+    );
+
+    // Greedy selection: always keep first (≥1 survivor invariant), then add while within budget
+    survivors = [sorted[0]];
+    let runningTokens = sorted[0].tokenCount;
+    for (let i = 1; i < sorted.length; i++) {
+      if (runningTokens + sorted[i].tokenCount <= maxTokens) {
+        survivors.push(sorted[i]);
+        runningTokens += sorted[i].tokenCount;
+      }
+    }
+  }
+
+  // Build output from survivors
+  const ruleContents = survivors.map(
+    entry => `## ${entry.relativePath}\n\n${entry.strippedContent}`
+  );
+  const matchedPaths = survivors.map(entry => entry.filePath);
+
+  const formattedRules =
+    `# OpenCode Rules\n\nPlease follow the following rules:\n\n` +
+    ruleContents.join('\n\n---\n\n');
+
   return {
-    formattedRules:
-      `# OpenCode Rules\n\nPlease follow the following rules:\n\n` +
-      ruleContents.join('\n\n---\n\n'),
+    formattedRules,
     matchedPaths,
+    tokenEstimate: estimateTokens(formattedRules),
   };
 }

package/src/rule-metadata.ts

@@ -19,6 +19,8 @@ export interface RuleMetadata {
   os?: string[];
   ci?: boolean;
   match?: 'any' | 'all';
+  /** Higher priority is kept first when a token budget is enforced. Default 0. */
+  priority?: number;
 }
 
 /**
@@ -36,6 +38,7 @@ interface ParsedFrontmatter {
   os?: unknown;
   ci?: unknown;
   match?: unknown;
+  priority?: unknown;
 }
 
 /** Field names in ParsedFrontmatter that are string arrays */
@@ -129,6 +132,11 @@ export function parseRuleMetadata(content: string): RuleMetadata | undefined {
       metadata.match = parsed.match;
     }
 
+    // Extract priority (finite numbers only; non-finite or absent becomes undefined, treated as 0 downstream)
+    if (typeof parsed.priority === 'number' && Number.isFinite(parsed.priority)) {
+      metadata.priority = parsed.priority;
+    }
+
     // Return metadata only if it has content
     return Object.keys(metadata).length > 0 ? metadata : undefined;
   } catch (error) {

package/src/runtime-context.ts

@@ -62,6 +62,18 @@ export function detectCiEnvironment(): boolean {
   );
 }
 
+/**
+ * Resolve the active token budget from the OPENCODE_RULES_MAX_TOKENS env var.
+ * Returns undefined when the env var is absent, empty, zero, negative, or non-finite.
+ * Positive finite numbers enable budget enforcement.
+ */
+export function resolveMaxTokens(): number | undefined {
+  const raw = process.env.OPENCODE_RULES_MAX_TOKENS;
+  if (!raw) return undefined;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+
 /**
  * Build the filter context object used for rule matching.
  * Assembles runtime information from various sources.
@@ -125,6 +137,10 @@ export async function buildFilterContext(
   if (gitBranch !== undefined) {
     context.gitBranch = gitBranch;
   }
+  const maxTokens = resolveMaxTokens();
+  if (maxTokens !== undefined) {
+    context.maxTokens = maxTokens;
+  }
 
   debugLog(
     `Filter context: model=${modelID ?? 'none'}, agent=${agentType ?? 'none'}, ` +

package/src/session-store.ts

@@ -108,6 +108,7 @@ export class SessionStore {
 
     this.upsert(sessionID, s => {
       s.isCompacting = false;
+      s.rulesInjected = false;
     });
 
     return false;