rulix 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,298 @@
+/**
+ * Intermediate Representation (IR) types for Rulix.
+ *
+ * All logic operates on these types, never on raw tool-specific formats.
+ * This module defines the core contract between the engine and adapters.
+ */
+type RuleScope = "always" | "file-scoped" | "agent-selected";
+type RuleCategory = "style" | "security" | "testing" | "architecture" | "workflow" | "general";
+type ValidationSeverity = "error" | "warning" | "info";
+type ExportStrategy = "overwrite" | "merge";
+type TokenEstimation = "heuristic" | "tiktoken";
+type ClaudeMdStrategy = "concatenate" | "reference";
+/**
+ * Use for operations that can fail in predictable ways (parsing, validation).
+ * Reserve exceptions for unexpected errors (filesystem, permissions).
+ */
+type Result<T, E = RulixError> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: E;
+};
+/**
+ * Every error carries a machine-readable `code` so callers can handle
+ * specific failure modes programmatically without parsing message strings.
+ */
+declare class RulixError extends Error {
+    readonly code: string;
+    readonly cause?: unknown | undefined;
+    readonly name = "RulixError";
+    constructor(code: string, message: string, cause?: unknown | undefined);
+}
+/**
+ * Tracks where a rule was imported from so users can trace back
+ * to the original source file when debugging conflicts.
+ */
+interface RuleSource {
+    /** E.g. `"cursor"`, `"claude-code"`, `"rulix"`. */
+    readonly adapter: string;
+    /** Relative to the project root. */
+    readonly filePath: string;
+    /** ISO 8601 timestamp. */
+    readonly importedAt: string;
+}
+/**
+ * The fundamental unit of the Rulix IR. All adapters convert
+ * their tool-specific formats to and from this representation.
+ */
+interface Rule {
+    /** Kebab-case. Used for deduplication and preset composition. */
+    readonly id: string;
+    readonly scope: RuleScope;
+    /** Used by agent-selected rules to let the AI decide relevance. */
+    readonly description: string;
+    readonly content: string;
+    /** Required when `scope` is `"file-scoped"`. */
+    readonly globs?: string[];
+    readonly category: RuleCategory;
+    /** 1 (critical) to 5 (nice-to-have). Drives token budget optimization. */
+    readonly priority: number;
+    /** E.g. `"@rulix/typescript/strict"`. */
+    readonly extends?: string;
+    /** Auto-computed by the tokenizer. */
+    readonly estimatedTokens: number;
+    readonly source?: RuleSource;
+}
+interface RulixConfigOptions {
+    readonly tokenEstimation: TokenEstimation;
+    /** Controls the "Generated by Rulix" header in AGENTS.md output. */
+    readonly agentsMdHeader: boolean;
+    readonly claudeMdStrategy: ClaudeMdStrategy;
+    /** Used by the `watch` command. */
+    readonly syncOnSave: boolean;
+}
+/**
+ * Fully-resolved project configuration with all defaults applied.
+ */
+interface RulixConfig {
+    /** Adapter names, e.g. `["cursor", "claude-code", "agents-md"]`. */
+    readonly targets: string[];
+    /** npm packages or local paths to preset rule collections. */
+    readonly presets: string[];
+    /** Keyed by rule ID. */
+    readonly overrides: Record<string, Partial<Rule>>;
+    readonly options: RulixConfigOptions;
+}
+interface Ruleset {
+    /** Local + preset rules, after overrides are applied. */
+    readonly rules: Rule[];
+    readonly config: RulixConfig;
+}
+/**
+ * Each adapter provides its own budget based on the tool's known limits
+ * (e.g. Claude Code ~150 instructions, Cursor ~500).
+ */
+interface TokenBudget {
+    readonly maxTokens: number;
+    readonly maxInstructions: number;
+    /** Fraction of max (e.g. 0.8 for 80%). */
+    readonly warningThreshold: number;
+    /** Where the limit comes from (e.g. documentation URL). */
+    readonly source: string;
+}
+interface ExportOptions {
+    readonly strategy: ExportStrategy;
+    /** Preview changes without writing to disk. */
+    readonly dryRun?: boolean | undefined;
+}
+interface ImportWarning {
+    readonly ruleId?: string | undefined;
+    /** Source file that produced the warning. */
+    readonly filePath: string;
+    readonly message: string;
+}
+interface ExportWarning {
+    readonly ruleId?: string | undefined;
+    /** Target file that produced the warning. */
+    readonly filePath: string;
+    readonly message: string;
+}
+interface ImportResult {
+    readonly rules: Rule[];
+    readonly warnings: ImportWarning[];
+    /** E.g. `".cursor/rules/"`. */
+    readonly source: string;
+}
+interface ExportResult {
+    readonly filesWritten: string[];
+    /** Files removed because the corresponding rule was deleted from source. */
+    readonly filesDeleted: string[];
+    readonly warnings: ExportWarning[];
+}
+/**
+ * Contract that every tool-specific adapter must implement.
+ *
+ * Import reads tool-specific files into `Rule[]`; export writes `Rule[]`
+ * back to the tool's native format.
+ */
+interface RulixAdapter {
+    /** E.g. `"cursor"`, `"claude-code"`. */
+    readonly name: string;
+    /** E.g. `"Cursor"`, `"Claude Code"`. */
+    readonly displayName: string;
+    detect(projectRoot: string): Promise<boolean>;
+    import(projectRoot: string): Promise<ImportResult>;
+    export(rules: Rule[], projectRoot: string, options?: ExportOptions): Promise<ExportResult>;
+    getTokenBudget(): TokenBudget;
+}
+/**
+ * Codes follow the pattern `V001`–`V999` as defined in PRD section 11.1.
+ */
+interface ValidationIssue {
+    /** E.g. `"V001"`. */
+    readonly code: string;
+    readonly severity: ValidationSeverity;
+    readonly message: string;
+    readonly ruleId?: string | undefined;
+    readonly filePath?: string | undefined;
+    /** Actionable fix suggestion. */
+    readonly suggestion?: string | undefined;
+}
+interface ValidationResult {
+    /** `true` when no errors were found (warnings and info are allowed). */
+    readonly passed: boolean;
+    readonly errors: ValidationIssue[];
+    readonly warnings: ValidationIssue[];
+    readonly info: ValidationIssue[];
+}
+
+/**
+ * AGENTS.md adapter: export-only.
+ *
+ * Import is not supported in v0.1 because AGENTS.md is too
+ * unstructured to parse reliably into discrete rules.
+ */
+
+declare const agentsMdAdapter: RulixAdapter;
+
+/**
+ * Claude Code adapter: imports from `CLAUDE.md` and `.claude/rules/*.md`,
+ * exports IR rules to Claude Code format.
+ *
+ * Never touches `.claude/skills/`, `.claude/commands/`,
+ * `.claude/agents/`, or `.claude/settings.json`.
+ */
+
+declare const claudeCodeAdapter: RulixAdapter;
+
+/**
+ * Cursor adapter: imports from `.cursor/rules/*.mdc` and `.cursorrules`,
+ * exports IR rules to `.cursor/rules/*.mdc`.
+ */
+
+declare const cursorAdapter: RulixAdapter;
+
+/**
+ * Adapter registry: lookup by name and auto-detection.
+ */
+
+/** Returns all registered adapters. */
+declare function getAdapters(): RulixAdapter[];
+/** Returns an adapter by name, or `undefined` if not found. */
+declare function getAdapter(name: string): RulixAdapter | undefined;
+/** Returns all adapter names. */
+declare function getAdapterNames(): string[];
+/** Detects which adapters have existing rules in a project. */
+declare function detectAdapters(projectRoot: string): Promise<RulixAdapter[]>;
+
+/**
+ * Lightweight token estimation without external dependencies.
+ *
+ * Uses a character-based heuristic (~4 chars per token) that's accurate
+ * enough for budget warnings. Exact counting via tiktoken is planned for v0.2.
+ */
+/** Estimates token count using the ~4 chars/token heuristic for English/code. */
+declare function estimateTokens(text: string): number;
+/**
+ * Builds the full text that a rule contributes to a tool's context window:
+ * frontmatter metadata + markdown content.
+ */
+declare function estimateRuleTokens(content: string, description: string): number;
+/** Sums estimated tokens across multiple content strings. */
+declare function sumTokens(tokenCounts: number[]): number;
+interface TokenBudgetUsage {
+    readonly used: number;
+    readonly max: number;
+    readonly percentage: number;
+    readonly exceeded: boolean;
+}
+/** Computes usage against a budget, returning percentage and exceeded flag. */
+declare function computeBudgetUsage(used: number, max: number): TokenBudgetUsage;
+
+/**
+ * High-level convenience API for programmatic usage.
+ *
+ * These functions compose lower-level core and adapter APIs into
+ * ergonomic one-call operations. They throw RulixError on failure
+ * instead of returning Result, for simpler consumer code.
+ */
+
+/** Loads the full ruleset (config + rules) from a project directory. */
+declare function loadRuleset(projectRoot: string): Promise<Ruleset>;
+/** Imports rules from a specific tool adapter into canonical IR. */
+declare function importRules(adapterName: string, projectRoot: string): Promise<ImportResult>;
+/** Exports canonical rules to a specific tool's format. */
+declare function exportRules(adapterName: string, rules: Rule[], projectRoot: string, options?: ExportOptions): Promise<ExportResult>;
+/** Validates rules for structural issues. */
+declare function validateRuleset(ruleset: Ruleset): ValidationResult;
+/** Returns token budget usage for a specific adapter. */
+declare function getTokenBudget(adapterName: string, rules: Rule[]): TokenBudgetUsage;
+
+/**
+ * Schema, defaults, and loader for `.rulix/config.json`.
+ *
+ * Pure validation lives in `resolveConfig`; filesystem I/O lives in `loadConfig`.
+ */
+
+declare const RULIX_DIR = ".rulix";
+declare const CONFIG_FILENAME = "config.json";
+declare const RULES_DIR = "rules";
+declare function configPath(projectRoot: string): string;
+declare function rulesPath(projectRoot: string): string;
+declare function createDefaultConfig(): RulixConfig;
+/** Validates raw JSON and merges with defaults to produce a fully-resolved config. */
+declare function resolveConfig(raw: unknown): Result<RulixConfig>;
+/** Reads `.rulix/config.json` from disk. Returns defaults if file is missing. */
+declare function loadConfig(projectRoot: string): Promise<Result<RulixConfig>>;
+
+/**
+ * Hand-rolled frontmatter parser for `.rulix/rules/*.md`.
+ *
+ * Supports the subset of YAML needed by Rulix frontmatter:
+ * simple key-value pairs, quoted strings, numbers, and arrays
+ * (both inline `[a, b]` and multi-line `- a`).
+ */
+
+/** Parses a markdown file with YAML frontmatter into a Rule. */
+declare function parseRule(raw: string, filePath: string): Result<Rule>;
+/** Serializes a Rule back to markdown with YAML frontmatter. */
+declare function serializeRule(rule: Rule): string;
+/** Reads and parses all `.md` rule files from `.rulix/rules/`. */
+declare function loadRules(projectRoot: string): Promise<Result<Rule[]>>;
+/** Writes a single rule to `.rulix/rules/{id}.md`. Creates the directory if needed. */
+declare function writeRule(projectRoot: string, rule: Rule): Promise<void>;
+
+/**
+ * Validation engine for Rulix rules (V001–V010).
+ *
+ * Each check is a pure function that inspects rules structurally.
+ * V006 (token budgets) and V008 (agent-selected support) are deferred
+ * to the adapter layer where tool-specific limits are known.
+ */
+
+/** Validates rules for structural issues (V001–V005, V007, V009, V010). */
+declare function validateRules(rules: Rule[]): ValidationResult;
+
+export { CONFIG_FILENAME, type ClaudeMdStrategy, type ExportOptions, type ExportResult, type ExportStrategy, type ExportWarning, type ImportResult, type ImportWarning, RULES_DIR, RULIX_DIR, type Result, type Rule, type RuleCategory, type RuleScope, type RuleSource, type Ruleset, type RulixAdapter, type RulixConfig, type RulixConfigOptions, RulixError, type TokenBudget, type TokenBudgetUsage, type TokenEstimation, type ValidationIssue, type ValidationResult, type ValidationSeverity, agentsMdAdapter, claudeCodeAdapter, computeBudgetUsage, configPath, createDefaultConfig, cursorAdapter, detectAdapters, estimateRuleTokens, estimateTokens, exportRules, getAdapter, getAdapterNames, getAdapters, getTokenBudget, importRules, loadConfig, loadRules, loadRuleset, parseRule, resolveConfig, rulesPath, serializeRule, sumTokens, validateRules, validateRuleset, writeRule };

package/dist/index.d.ts

@@ -0,0 +1,298 @@
+/**
+ * Intermediate Representation (IR) types for Rulix.
+ *
+ * All logic operates on these types, never on raw tool-specific formats.
+ * This module defines the core contract between the engine and adapters.
+ */
+type RuleScope = "always" | "file-scoped" | "agent-selected";
+type RuleCategory = "style" | "security" | "testing" | "architecture" | "workflow" | "general";
+type ValidationSeverity = "error" | "warning" | "info";
+type ExportStrategy = "overwrite" | "merge";
+type TokenEstimation = "heuristic" | "tiktoken";
+type ClaudeMdStrategy = "concatenate" | "reference";
+/**
+ * Use for operations that can fail in predictable ways (parsing, validation).
+ * Reserve exceptions for unexpected errors (filesystem, permissions).
+ */
+type Result<T, E = RulixError> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: E;
+};
+/**
+ * Every error carries a machine-readable `code` so callers can handle
+ * specific failure modes programmatically without parsing message strings.
+ */
+declare class RulixError extends Error {
+    readonly code: string;
+    readonly cause?: unknown | undefined;
+    readonly name = "RulixError";
+    constructor(code: string, message: string, cause?: unknown | undefined);
+}
+/**
+ * Tracks where a rule was imported from so users can trace back
+ * to the original source file when debugging conflicts.
+ */
+interface RuleSource {
+    /** E.g. `"cursor"`, `"claude-code"`, `"rulix"`. */
+    readonly adapter: string;
+    /** Relative to the project root. */
+    readonly filePath: string;
+    /** ISO 8601 timestamp. */
+    readonly importedAt: string;
+}
+/**
+ * The fundamental unit of the Rulix IR. All adapters convert
+ * their tool-specific formats to and from this representation.
+ */
+interface Rule {
+    /** Kebab-case. Used for deduplication and preset composition. */
+    readonly id: string;
+    readonly scope: RuleScope;
+    /** Used by agent-selected rules to let the AI decide relevance. */
+    readonly description: string;
+    readonly content: string;
+    /** Required when `scope` is `"file-scoped"`. */
+    readonly globs?: string[];
+    readonly category: RuleCategory;
+    /** 1 (critical) to 5 (nice-to-have). Drives token budget optimization. */
+    readonly priority: number;
+    /** E.g. `"@rulix/typescript/strict"`. */
+    readonly extends?: string;
+    /** Auto-computed by the tokenizer. */
+    readonly estimatedTokens: number;
+    readonly source?: RuleSource;
+}
+interface RulixConfigOptions {
+    readonly tokenEstimation: TokenEstimation;
+    /** Controls the "Generated by Rulix" header in AGENTS.md output. */
+    readonly agentsMdHeader: boolean;
+    readonly claudeMdStrategy: ClaudeMdStrategy;
+    /** Used by the `watch` command. */
+    readonly syncOnSave: boolean;
+}
+/**
+ * Fully-resolved project configuration with all defaults applied.
+ */
+interface RulixConfig {
+    /** Adapter names, e.g. `["cursor", "claude-code", "agents-md"]`. */
+    readonly targets: string[];
+    /** npm packages or local paths to preset rule collections. */
+    readonly presets: string[];
+    /** Keyed by rule ID. */
+    readonly overrides: Record<string, Partial<Rule>>;
+    readonly options: RulixConfigOptions;
+}
+interface Ruleset {
+    /** Local + preset rules, after overrides are applied. */
+    readonly rules: Rule[];
+    readonly config: RulixConfig;
+}
+/**
+ * Each adapter provides its own budget based on the tool's known limits
+ * (e.g. Claude Code ~150 instructions, Cursor ~500).
+ */
+interface TokenBudget {
+    readonly maxTokens: number;
+    readonly maxInstructions: number;
+    /** Fraction of max (e.g. 0.8 for 80%). */
+    readonly warningThreshold: number;
+    /** Where the limit comes from (e.g. documentation URL). */
+    readonly source: string;
+}
+interface ExportOptions {
+    readonly strategy: ExportStrategy;
+    /** Preview changes without writing to disk. */
+    readonly dryRun?: boolean | undefined;
+}
+interface ImportWarning {
+    readonly ruleId?: string | undefined;
+    /** Source file that produced the warning. */
+    readonly filePath: string;
+    readonly message: string;
+}
+interface ExportWarning {
+    readonly ruleId?: string | undefined;
+    /** Target file that produced the warning. */
+    readonly filePath: string;
+    readonly message: string;
+}
+interface ImportResult {
+    readonly rules: Rule[];
+    readonly warnings: ImportWarning[];
+    /** E.g. `".cursor/rules/"`. */
+    readonly source: string;
+}
+interface ExportResult {
+    readonly filesWritten: string[];
+    /** Files removed because the corresponding rule was deleted from source. */
+    readonly filesDeleted: string[];
+    readonly warnings: ExportWarning[];
+}
+/**
+ * Contract that every tool-specific adapter must implement.
+ *
+ * Import reads tool-specific files into `Rule[]`; export writes `Rule[]`
+ * back to the tool's native format.
+ */
+interface RulixAdapter {
+    /** E.g. `"cursor"`, `"claude-code"`. */
+    readonly name: string;
+    /** E.g. `"Cursor"`, `"Claude Code"`. */
+    readonly displayName: string;
+    detect(projectRoot: string): Promise<boolean>;
+    import(projectRoot: string): Promise<ImportResult>;
+    export(rules: Rule[], projectRoot: string, options?: ExportOptions): Promise<ExportResult>;
+    getTokenBudget(): TokenBudget;
+}
+/**
+ * Codes follow the pattern `V001`–`V999` as defined in PRD section 11.1.
+ */
+interface ValidationIssue {
+    /** E.g. `"V001"`. */
+    readonly code: string;
+    readonly severity: ValidationSeverity;
+    readonly message: string;
+    readonly ruleId?: string | undefined;
+    readonly filePath?: string | undefined;
+    /** Actionable fix suggestion. */
+    readonly suggestion?: string | undefined;
+}
+interface ValidationResult {
+    /** `true` when no errors were found (warnings and info are allowed). */
+    readonly passed: boolean;
+    readonly errors: ValidationIssue[];
+    readonly warnings: ValidationIssue[];
+    readonly info: ValidationIssue[];
+}
+
+/**
+ * AGENTS.md adapter: export-only.
+ *
+ * Import is not supported in v0.1 because AGENTS.md is too
+ * unstructured to parse reliably into discrete rules.
+ */
+
+declare const agentsMdAdapter: RulixAdapter;
+
+/**
+ * Claude Code adapter: imports from `CLAUDE.md` and `.claude/rules/*.md`,
+ * exports IR rules to Claude Code format.
+ *
+ * Never touches `.claude/skills/`, `.claude/commands/`,
+ * `.claude/agents/`, or `.claude/settings.json`.
+ */
+
+declare const claudeCodeAdapter: RulixAdapter;
+
+/**
+ * Cursor adapter: imports from `.cursor/rules/*.mdc` and `.cursorrules`,
+ * exports IR rules to `.cursor/rules/*.mdc`.
+ */
+
+declare const cursorAdapter: RulixAdapter;
+
+/**
+ * Adapter registry: lookup by name and auto-detection.
+ */
+
+/** Returns all registered adapters. */
+declare function getAdapters(): RulixAdapter[];
+/** Returns an adapter by name, or `undefined` if not found. */
+declare function getAdapter(name: string): RulixAdapter | undefined;
+/** Returns all adapter names. */
+declare function getAdapterNames(): string[];
+/** Detects which adapters have existing rules in a project. */
+declare function detectAdapters(projectRoot: string): Promise<RulixAdapter[]>;
+
+/**
+ * Lightweight token estimation without external dependencies.
+ *
+ * Uses a character-based heuristic (~4 chars per token) that's accurate
+ * enough for budget warnings. Exact counting via tiktoken is planned for v0.2.
+ */
+/** Estimates token count using the ~4 chars/token heuristic for English/code. */
+declare function estimateTokens(text: string): number;
+/**
+ * Builds the full text that a rule contributes to a tool's context window:
+ * frontmatter metadata + markdown content.
+ */
+declare function estimateRuleTokens(content: string, description: string): number;
+/** Sums estimated tokens across multiple content strings. */
+declare function sumTokens(tokenCounts: number[]): number;
+interface TokenBudgetUsage {
+    readonly used: number;
+    readonly max: number;
+    readonly percentage: number;
+    readonly exceeded: boolean;
+}
+/** Computes usage against a budget, returning percentage and exceeded flag. */
+declare function computeBudgetUsage(used: number, max: number): TokenBudgetUsage;
+
+/**
+ * High-level convenience API for programmatic usage.
+ *
+ * These functions compose lower-level core and adapter APIs into
+ * ergonomic one-call operations. They throw RulixError on failure
+ * instead of returning Result, for simpler consumer code.
+ */
+
+/** Loads the full ruleset (config + rules) from a project directory. */
+declare function loadRuleset(projectRoot: string): Promise<Ruleset>;
+/** Imports rules from a specific tool adapter into canonical IR. */
+declare function importRules(adapterName: string, projectRoot: string): Promise<ImportResult>;
+/** Exports canonical rules to a specific tool's format. */
+declare function exportRules(adapterName: string, rules: Rule[], projectRoot: string, options?: ExportOptions): Promise<ExportResult>;
+/** Validates rules for structural issues. */
+declare function validateRuleset(ruleset: Ruleset): ValidationResult;
+/** Returns token budget usage for a specific adapter. */
+declare function getTokenBudget(adapterName: string, rules: Rule[]): TokenBudgetUsage;
+
+/**
+ * Schema, defaults, and loader for `.rulix/config.json`.
+ *
+ * Pure validation lives in `resolveConfig`; filesystem I/O lives in `loadConfig`.
+ */
+
+declare const RULIX_DIR = ".rulix";
+declare const CONFIG_FILENAME = "config.json";
+declare const RULES_DIR = "rules";
+declare function configPath(projectRoot: string): string;
+declare function rulesPath(projectRoot: string): string;
+declare function createDefaultConfig(): RulixConfig;
+/** Validates raw JSON and merges with defaults to produce a fully-resolved config. */
+declare function resolveConfig(raw: unknown): Result<RulixConfig>;
+/** Reads `.rulix/config.json` from disk. Returns defaults if file is missing. */
+declare function loadConfig(projectRoot: string): Promise<Result<RulixConfig>>;
+
+/**
+ * Hand-rolled frontmatter parser for `.rulix/rules/*.md`.
+ *
+ * Supports the subset of YAML needed by Rulix frontmatter:
+ * simple key-value pairs, quoted strings, numbers, and arrays
+ * (both inline `[a, b]` and multi-line `- a`).
+ */
+
+/** Parses a markdown file with YAML frontmatter into a Rule. */
+declare function parseRule(raw: string, filePath: string): Result<Rule>;
+/** Serializes a Rule back to markdown with YAML frontmatter. */
+declare function serializeRule(rule: Rule): string;
+/** Reads and parses all `.md` rule files from `.rulix/rules/`. */
+declare function loadRules(projectRoot: string): Promise<Result<Rule[]>>;
+/** Writes a single rule to `.rulix/rules/{id}.md`. Creates the directory if needed. */
+declare function writeRule(projectRoot: string, rule: Rule): Promise<void>;
+
+/**
+ * Validation engine for Rulix rules (V001–V010).
+ *
+ * Each check is a pure function that inspects rules structurally.
+ * V006 (token budgets) and V008 (agent-selected support) are deferred
+ * to the adapter layer where tool-specific limits are known.
+ */
+
+/** Validates rules for structural issues (V001–V005, V007, V009, V010). */
+declare function validateRules(rules: Rule[]): ValidationResult;
+
+export { CONFIG_FILENAME, type ClaudeMdStrategy, type ExportOptions, type ExportResult, type ExportStrategy, type ExportWarning, type ImportResult, type ImportWarning, RULES_DIR, RULIX_DIR, type Result, type Rule, type RuleCategory, type RuleScope, type RuleSource, type Ruleset, type RulixAdapter, type RulixConfig, type RulixConfigOptions, RulixError, type TokenBudget, type TokenBudgetUsage, type TokenEstimation, type ValidationIssue, type ValidationResult, type ValidationSeverity, agentsMdAdapter, claudeCodeAdapter, computeBudgetUsage, configPath, createDefaultConfig, cursorAdapter, detectAdapters, estimateRuleTokens, estimateTokens, exportRules, getAdapter, getAdapterNames, getAdapters, getTokenBudget, importRules, loadConfig, loadRules, loadRuleset, parseRule, resolveConfig, rulesPath, serializeRule, sumTokens, validateRules, validateRuleset, writeRule };

package/dist/index.js

@@ -0,0 +1,91 @@
+import {
+  CONFIG_FILENAME,
+  RULES_DIR,
+  RULIX_DIR,
+  RulixError,
+  agentsMdAdapter,
+  claudeCodeAdapter,
+  computeBudgetUsage,
+  configPath,
+  createDefaultConfig,
+  cursorAdapter,
+  detectAdapters,
+  estimateRuleTokens,
+  estimateTokens,
+  getAdapter,
+  getAdapterNames,
+  getAdapters,
+  loadConfig,
+  loadRules,
+  parseRule,
+  resolveConfig,
+  rulesPath,
+  serializeRule,
+  sumTokens,
+  validateRules,
+  writeRule
+} from "./chunk-IX4ZOAKV.js";
+
+// src/api.ts
+function requireAdapter(name) {
+  const adapter = getAdapter(name);
+  if (!adapter) {
+    throw new RulixError("UNKNOWN_ADAPTER", `Unknown adapter: "${name}"`);
+  }
+  return adapter;
+}
+async function loadRuleset(projectRoot) {
+  const configResult = await loadConfig(projectRoot);
+  if (!configResult.ok) throw configResult.error;
+  const rulesResult = await loadRules(projectRoot);
+  if (!rulesResult.ok) throw rulesResult.error;
+  return { rules: rulesResult.value, config: configResult.value };
+}
+async function importRules(adapterName, projectRoot) {
+  return requireAdapter(adapterName).import(projectRoot);
+}
+async function exportRules(adapterName, rules, projectRoot, options) {
+  return requireAdapter(adapterName).export(rules, projectRoot, options);
+}
+function validateRuleset(ruleset) {
+  return validateRules(ruleset.rules);
+}
+function getTokenBudget(adapterName, rules) {
+  const adapter = requireAdapter(adapterName);
+  const budget = adapter.getTokenBudget();
+  const used = sumTokens(rules.map((r) => r.estimatedTokens));
+  return computeBudgetUsage(used, budget.maxTokens);
+}
+export {
+  CONFIG_FILENAME,
+  RULES_DIR,
+  RULIX_DIR,
+  RulixError,
+  agentsMdAdapter,
+  claudeCodeAdapter,
+  computeBudgetUsage,
+  configPath,
+  createDefaultConfig,
+  cursorAdapter,
+  detectAdapters,
+  estimateRuleTokens,
+  estimateTokens,
+  exportRules,
+  getAdapter,
+  getAdapterNames,
+  getAdapters,
+  getTokenBudget,
+  importRules,
+  loadConfig,
+  loadRules,
+  loadRuleset,
+  parseRule,
+  resolveConfig,
+  rulesPath,
+  serializeRule,
+  sumTokens,
+  validateRules,
+  validateRuleset,
+  writeRule
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/api.ts"],"sourcesContent":["/**\n * High-level convenience API for programmatic usage.\n *\n * These functions compose lower-level core and adapter APIs into\n * ergonomic one-call operations. They throw RulixError on failure\n * instead of returning Result, for simpler consumer code.\n */\n\nimport { getAdapter } from \"./adapters/registry.js\";\nimport { loadConfig } from \"./core/config.js\";\nimport type {\n\tExportOptions,\n\tExportResult,\n\tImportResult,\n\tRule,\n\tRuleset,\n\tValidationResult,\n} from \"./core/ir.js\";\nimport { RulixError } from \"./core/ir.js\";\nimport { loadRules } from \"./core/parser.js\";\nimport type { TokenBudgetUsage } from \"./core/tokenizer.js\";\nimport { computeBudgetUsage, sumTokens } from \"./core/tokenizer.js\";\nimport { validateRules } from \"./core/validator.js\";\n\nfunction requireAdapter(name: string) {\n\tconst adapter = getAdapter(name);\n\tif (!adapter) {\n\t\tthrow new RulixError(\"UNKNOWN_ADAPTER\", `Unknown adapter: \"${name}\"`);\n\t}\n\treturn adapter;\n}\n\n/** Loads the full ruleset (config + rules) from a project directory. */\nexport async function loadRuleset(projectRoot: string): Promise<Ruleset> {\n\tconst configResult = await loadConfig(projectRoot);\n\tif (!configResult.ok) throw configResult.error;\n\n\tconst rulesResult = await loadRules(projectRoot);\n\tif (!rulesResult.ok) throw rulesResult.error;\n\n\treturn { rules: rulesResult.value, config: configResult.value };\n}\n\n/** Imports rules from a specific tool adapter into canonical IR. */\nexport async function importRules(\n\tadapterName: string,\n\tprojectRoot: string,\n): Promise<ImportResult> {\n\treturn requireAdapter(adapterName).import(projectRoot);\n}\n\n/** Exports canonical rules to a specific tool's format. */\nexport async function exportRules(\n\tadapterName: string,\n\trules: Rule[],\n\tprojectRoot: string,\n\toptions?: ExportOptions,\n): Promise<ExportResult> {\n\treturn requireAdapter(adapterName).export(rules, projectRoot, options);\n}\n\n/** Validates rules for structural issues. */\nexport function validateRuleset(ruleset: Ruleset): ValidationResult {\n\treturn validateRules(ruleset.rules);\n}\n\n/** Returns token budget usage for a specific adapter. */\nexport function getTokenBudget(\n\tadapterName: string,\n\trules: Rule[],\n): TokenBudgetUsage {\n\tconst adapter = requireAdapter(adapterName);\n\tconst budget = adapter.getTokenBudget();\n\tconst used = sumTokens(rules.map((r) => r.estimatedTokens));\n\treturn computeBudgetUsage(used, budget.maxTokens);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAS,eAAe,MAAc;AACrC,QAAM,UAAU,WAAW,IAAI;AAC/B,MAAI,CAAC,SAAS;AACb,UAAM,IAAI,WAAW,mBAAmB,qBAAqB,IAAI,GAAG;AAAA,EACrE;AACA,SAAO;AACR;AAGA,eAAsB,YAAY,aAAuC;AACxE,QAAM,eAAe,MAAM,WAAW,WAAW;AACjD,MAAI,CAAC,aAAa,GAAI,OAAM,aAAa;AAEzC,QAAM,cAAc,MAAM,UAAU,WAAW;AAC/C,MAAI,CAAC,YAAY,GAAI,OAAM,YAAY;AAEvC,SAAO,EAAE,OAAO,YAAY,OAAO,QAAQ,aAAa,MAAM;AAC/D;AAGA,eAAsB,YACrB,aACA,aACwB;AACxB,SAAO,eAAe,WAAW,EAAE,OAAO,WAAW;AACtD;AAGA,eAAsB,YACrB,aACA,OACA,aACA,SACwB;AACxB,SAAO,eAAe,WAAW,EAAE,OAAO,OAAO,aAAa,OAAO;AACtE;AAGO,SAAS,gBAAgB,SAAoC;AACnE,SAAO,cAAc,QAAQ,KAAK;AACnC;AAGO,SAAS,eACf,aACA,OACmB;AACnB,QAAM,UAAU,eAAe,WAAW;AAC1C,QAAM,SAAS,QAAQ,eAAe;AACtC,QAAM,OAAO,UAAU,MAAM,IAAI,CAAC,MAAM,EAAE,eAAe,CAAC;AAC1D,SAAO,mBAAmB,MAAM,OAAO,SAAS;AACjD;","names":[]}