opencode-rules-md 0.6.5

package/src/rule-metadata.ts

@@ -0,0 +1,161 @@
+/**
+ * Rule metadata parsing and frontmatter extraction
+ */
+
+const { parse: parseYaml } = await import('yaml');
+
+/**
+ * Metadata extracted from .mdc file frontmatter
+ */
+export interface RuleMetadata {
+  globs?: string[];
+  keywords?: string[];
+  tools?: string[];
+  model?: string[];
+  agent?: string[];
+  command?: string[];
+  project?: string[];
+  branch?: string[];
+  os?: string[];
+  ci?: boolean;
+  match?: 'any' | 'all';
+}
+
+/**
+ * Raw parsed YAML frontmatter structure
+ */
+interface ParsedFrontmatter {
+  globs?: unknown;
+  keywords?: unknown;
+  tools?: unknown;
+  model?: unknown;
+  agent?: unknown;
+  command?: unknown;
+  project?: unknown;
+  branch?: unknown;
+  os?: unknown;
+  ci?: unknown;
+  match?: unknown;
+}
+
+/** Field names in ParsedFrontmatter that are string arrays */
+type StringArrayField =
+  | 'globs'
+  | 'keywords'
+  | 'tools'
+  | 'model'
+  | 'agent'
+  | 'command'
+  | 'project'
+  | 'branch'
+  | 'os';
+
+/**
+ * Extract and normalize a string array from parsed frontmatter.
+ * Filters non-strings, trims whitespace, and removes empty values.
+ *
+ * @param value - Raw value from parsed YAML (may be array or undefined)
+ * @returns Normalized string array, or undefined if empty after filtering
+ */
+function extractStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  const result = value
+    .filter((v): v is string => typeof v === 'string')
+    .map(v => v.trim())
+    .filter(v => v.length > 0);
+  return result.length > 0 ? result : undefined;
+}
+
+/**
+ * Parse YAML metadata from rule file content using the yaml package.
+ * Extracts frontmatter (---) and returns metadata object.
+ */
+export function parseRuleMetadata(content: string): RuleMetadata | undefined {
+  // Check if content starts with frontmatter
+  if (!content.startsWith('---')) {
+    return undefined;
+  }
+
+  // Find the closing --- marker
+  const endIndex = content.indexOf('---', 3);
+  if (endIndex === -1) {
+    return undefined;
+  }
+
+  // Extract the YAML frontmatter
+  const frontmatter = content.substring(3, endIndex).trim();
+  if (!frontmatter) {
+    return undefined;
+  }
+
+  try {
+    // Parse YAML using the yaml package
+    const parsed = parseYaml(frontmatter) as ParsedFrontmatter | null;
+    if (!parsed || typeof parsed !== 'object') {
+      return undefined;
+    }
+
+    const metadata: RuleMetadata = {};
+
+    // Array fields to extract using shared helper
+    const arrayFields: StringArrayField[] = [
+      'globs',
+      'keywords',
+      'tools',
+      'model',
+      'agent',
+      'command',
+      'project',
+      'branch',
+      'os',
+    ];
+
+    for (const field of arrayFields) {
+      const extracted = extractStringArray(parsed[field]);
+      if (extracted) {
+        metadata[field] = extracted;
+      }
+    }
+
+    // Extract ci boolean (only if strictly boolean)
+    if (typeof parsed.ci === 'boolean') {
+      metadata.ci = parsed.ci;
+    }
+
+    // Extract match (normalize to 'any' | 'all' only)
+    if (parsed.match === 'any' || parsed.match === 'all') {
+      metadata.match = parsed.match;
+    }
+
+    // Return metadata only if it has content
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+  } catch (error) {
+    // Log warning for YAML parsing errors
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(
+      `[opencode-rules-md] Warning: Failed to parse YAML frontmatter: ${message}`
+    );
+    return undefined;
+  }
+}
+
+/**
+ * Strip YAML frontmatter from rule content
+ */
+export function stripFrontmatter(content: string): string {
+  // Check if content starts with frontmatter
+  if (!content.startsWith('---')) {
+    return content;
+  }
+
+  // Find the closing --- marker
+  const endIndex = content.indexOf('---', 3);
+  if (endIndex === -1) {
+    return content;
+  }
+
+  // Return content after the closing marker, trimming leading newline
+  return content.substring(endIndex + 3).trimStart();
+}

package/src/runtime-chat.ts

@@ -0,0 +1,68 @@
+import { extractTextFromParts } from './message-context.js';
+import type { SessionStore } from './session-store.js';
+import type { DebugLog } from './debug.js';
+
+export interface ChatMessageInput {
+  sessionID?: string;
+  model?: { modelID?: string };
+  agent?: string;
+}
+
+export interface ChatMessageOutput {
+  message?: { role?: string };
+  parts?: Array<{ type?: string; text?: string; synthetic?: boolean }>;
+}
+
+/**
+ * Extract user prompt text from chat message parts.
+ * Returns empty string if no text parts found.
+ */
+export function extractUserPromptFromParts(
+  parts:
+    | Array<{ type?: string; text?: string; synthetic?: boolean }>
+    | undefined
+): string {
+  if (!parts) return '';
+  return extractTextFromParts(parts);
+}
+
+/**
+ * Handle incoming chat messages to update session state.
+ * Captures user prompts, model IDs, and agent types.
+ */
+export function handleChatMessage(
+  input: ChatMessageInput,
+  output: ChatMessageOutput,
+  sessionStore: SessionStore,
+  debugLog: DebugLog
+): void {
+  const sessionID = input?.sessionID;
+  if (!sessionID) {
+    debugLog('No sessionID in chat.message hook input');
+    return;
+  }
+
+  if (output?.message?.role !== 'user') {
+    return;
+  }
+
+  const userPrompt = extractUserPromptFromParts(output.parts);
+
+  sessionStore.upsert(sessionID, state => {
+    if (userPrompt) {
+      state.lastUserPrompt = userPrompt;
+      state.rulesInjected = false;
+    }
+
+    if (input.model?.modelID) {
+      state.lastModelID = input.model.modelID;
+    }
+    if (input.agent) {
+      state.lastAgentType = input.agent;
+    }
+  });
+
+  debugLog(
+    `Updated session ${sessionID} from chat.message (model=${input.model?.modelID ?? 'none'}, agent=${input.agent ?? 'none'})`
+  );
+}

package/src/runtime-context.ts

@@ -0,0 +1,136 @@
+import { extractSlashCommand } from './message-context.js';
+import { detectProjectTags } from './project-fingerprint.js';
+import { getGitBranch } from './git-branch.js';
+import type { RuleFilterContext } from './rule-filter.js';
+import type { DebugLog } from './debug.js';
+
+export interface BuildFilterContextOptions {
+  contextFilePaths: string[];
+  userPrompt: string | undefined;
+  availableToolIDs: string[];
+  modelID: string | undefined;
+  agentType: string | undefined;
+}
+
+/**
+ * Parse an env variable value semantically: 'false', '0', '' => false; other non-empty => true.
+ * Returns undefined if the variable is not set.
+ */
+function parseEnvBoolean(value: string | undefined): boolean | undefined {
+  if (value === undefined) return undefined;
+  if (value === '') return false;
+  const lower = value.toLowerCase();
+  if (lower === 'false' || lower === '0') return false;
+  return true;
+}
+
+/**
+ * Check if a string value represents a truthy CI environment variable.
+ * Treats 'false', '0', and empty strings as falsy; other non-empty values as truthy.
+ */
+function isTruthyEnvValue(value: string | undefined): boolean {
+  return parseEnvBoolean(value) === true;
+}
+
+/**
+ * Detect if running in a CI environment by checking common CI environment variables.
+ *
+ * If process.env.CI is explicitly set, it is treated as authoritative:
+ * - CI='false' or CI='0' or CI='' => return false (no provider var fallback)
+ * - CI='true' or CI='1' or any truthy value => return true
+ *
+ * If process.env.CI is not set (undefined), fall back to provider-specific detection.
+ */
+export function detectCiEnvironment(): boolean {
+  const env = process.env;
+
+  const ciExplicit = parseEnvBoolean(env.CI);
+  if (ciExplicit !== undefined) {
+    return ciExplicit;
+  }
+
+  return (
+    isTruthyEnvValue(env.CONTINUOUS_INTEGRATION) ||
+    isTruthyEnvValue(env.BUILD_NUMBER) ||
+    isTruthyEnvValue(env.GITHUB_ACTIONS) ||
+    isTruthyEnvValue(env.GITLAB_CI) ||
+    isTruthyEnvValue(env.CIRCLECI) ||
+    isTruthyEnvValue(env.TRAVIS) ||
+    isTruthyEnvValue(env.JENKINS_URL) ||
+    isTruthyEnvValue(env.BUILDKITE) ||
+    isTruthyEnvValue(env.TEAMCITY_VERSION)
+  );
+}
+
+/**
+ * Build the filter context object used for rule matching.
+ * Assembles runtime information from various sources.
+ */
+export async function buildFilterContext(
+  opts: BuildFilterContextOptions,
+  projectDirectory: string,
+  debugLog: DebugLog
+): Promise<RuleFilterContext> {
+  const { contextFilePaths, userPrompt, availableToolIDs, modelID, agentType } =
+    opts;
+
+  const command = extractSlashCommand(userPrompt);
+
+  let projectTags: string[] | undefined;
+  try {
+    projectTags = await detectProjectTags(projectDirectory);
+    if (projectTags.length === 0) {
+      projectTags = undefined;
+    }
+  } catch {
+    projectTags = undefined;
+  }
+
+  let gitBranch: string | undefined;
+  try {
+    gitBranch = await getGitBranch(projectDirectory);
+  } catch {
+    gitBranch = undefined;
+  }
+
+  const os = process.platform;
+  const ci = detectCiEnvironment();
+
+  const context: RuleFilterContext = {
+    os,
+    ci,
+  };
+
+  if (contextFilePaths.length > 0) {
+    context.contextFilePaths = contextFilePaths;
+  }
+  if (userPrompt !== undefined) {
+    context.userPrompt = userPrompt;
+  }
+  if (availableToolIDs.length > 0) {
+    context.availableToolIDs = availableToolIDs;
+  }
+  if (modelID !== undefined) {
+    context.modelID = modelID;
+  }
+  if (agentType !== undefined) {
+    context.agentType = agentType;
+  }
+  if (command !== undefined) {
+    context.command = command;
+  }
+  if (projectTags !== undefined) {
+    context.projectTags = projectTags;
+  }
+  if (gitBranch !== undefined) {
+    context.gitBranch = gitBranch;
+  }
+
+  debugLog(
+    `Filter context: model=${modelID ?? 'none'}, agent=${agentType ?? 'none'}, ` +
+      `command=${command ?? 'none'}, branch=${gitBranch ?? 'none'}, ` +
+      `os=${os}, ci=${ci}, projectTags=${projectTags?.join(',') ?? 'none'}`
+  );
+
+  return context;
+}