@titan-design/style-profile 0.0.0

package/dist/index.js

@@ -0,0 +1,974 @@
+// src/schema/style-rule.ts
+import { z } from "zod";
+var ExampleSchema = z.object({
+  good: z.string().optional(),
+  bad: z.string().optional(),
+  source: z.string().optional()
+});
+var StabilitySchema = z.enum(["high", "medium", "low"]);
+var FixabilitySchema = z.enum([
+  "safe",
+  "maybe-incorrect",
+  "requires-input",
+  "not-fixable"
+]);
+var StyleRuleSchema = z.object({
+  convention: z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.string())
+  ]),
+  confidence: z.number().min(0).max(1),
+  stability: StabilitySchema.optional(),
+  fixability: FixabilitySchema.optional(),
+  description: z.string().optional(),
+  examples: z.array(ExampleSchema).optional(),
+  extensions: z.record(z.string(), z.unknown()).optional()
+});
+
+// src/schema/profile.ts
+import { z as z2 } from "zod";
+var SCHEMA_VERSION = "1.0.0";
+var CategorySchema = z2.record(z2.string(), StyleRuleSchema);
+var IdiomSchema = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  frequency: z2.number(),
+  confidence: z2.number().min(0).max(1),
+  example: z2.string().optional()
+});
+var AntiPatternSchema = z2.object({
+  pattern: z2.string(),
+  reason: z2.string(),
+  deprecated: z2.boolean().optional()
+});
+var OverrideSchema = z2.object({
+  files: z2.array(z2.string()),
+  naming: CategorySchema.optional(),
+  structure: CategorySchema.optional(),
+  documentation: CategorySchema.optional(),
+  errorHandling: CategorySchema.optional(),
+  formatting: CategorySchema.optional(),
+  patterns: CategorySchema.optional()
+});
+var SeverityThresholdsSchema = z2.object({
+  error: z2.number().min(0).max(1),
+  warn: z2.number().min(0).max(1),
+  info: z2.number().min(0).max(1)
+});
+var DEFAULT_SEVERITY_THRESHOLDS = {
+  error: 0.85,
+  warn: 0.6,
+  info: 0.4
+};
+var ProfileSchema = z2.object({
+  $schema: z2.string().optional(),
+  schemaVersion: z2.string(),
+  author: z2.string(),
+  generated: z2.string(),
+  sources: z2.array(z2.string()),
+  naming: CategorySchema,
+  structure: CategorySchema,
+  documentation: CategorySchema,
+  errorHandling: CategorySchema,
+  formatting: CategorySchema,
+  patterns: CategorySchema,
+  idioms: z2.object({
+    detected: z2.array(IdiomSchema)
+  }),
+  antiPatterns: z2.object({
+    acknowledged: z2.array(AntiPatternSchema)
+  }),
+  overrides: z2.array(OverrideSchema),
+  severityThresholds: SeverityThresholdsSchema.default(DEFAULT_SEVERITY_THRESHOLDS)
+});
+var PROFILE_CATEGORIES = [
+  "naming",
+  "structure",
+  "documentation",
+  "errorHandling",
+  "formatting",
+  "patterns"
+];
+
+// src/io.ts
+import * as fs from "fs/promises";
+async function readProfile(filePath) {
+  const raw = await fs.readFile(filePath, "utf-8");
+  const json = JSON.parse(raw);
+  return ProfileSchema.parse(json);
+}
+async function writeProfile(filePath, profile) {
+  const validated = ProfileSchema.parse(profile);
+  await fs.writeFile(filePath, JSON.stringify(validated, null, 2) + "\n");
+}
+function validateProfile(data) {
+  return ProfileSchema.safeParse(data);
+}
+
+// src/migrations/registry.ts
+var migrations = [];
+function registerMigration(migration) {
+  migrations.push(migration);
+  migrations.sort((a, b) => a.from.localeCompare(b.from));
+}
+function getMigrations() {
+  return migrations;
+}
+
+// src/migrations/migrate-profile.ts
+function migrateProfile(profile) {
+  let current = { ...profile };
+  const version = current.schemaVersion;
+  if (version === SCHEMA_VERSION) {
+    return current;
+  }
+  const migrations2 = getMigrations();
+  let currentVersion = version;
+  for (const migration of migrations2) {
+    if (migration.from === currentVersion) {
+      current = migration.migrate(current);
+      currentVersion = migration.to;
+    }
+  }
+  if (currentVersion !== SCHEMA_VERSION) {
+    throw new Error(
+      `No migration path from version ${version} to ${SCHEMA_VERSION}`
+    );
+  }
+  return current;
+}
+
+// src/exporters/template-helpers.ts
+function extractAllRules(profile) {
+  const rules = [];
+  for (const category of PROFILE_CATEGORIES) {
+    const section = profile[category];
+    if (!section || typeof section !== "object") continue;
+    for (const [name, rule] of Object.entries(section)) {
+      if (!rule || typeof rule !== "object") continue;
+      rules.push({
+        category,
+        name,
+        convention: rule.convention,
+        confidence: rule.confidence,
+        stability: rule.stability,
+        description: rule.description,
+        examples: rule.examples,
+        extensions: rule.extensions
+      });
+    }
+  }
+  return rules;
+}
+function getTopRules(profile, count = 8) {
+  const errorThreshold = profile.severityThresholds?.error ?? 0.85;
+  return extractAllRules(profile).filter((r) => r.confidence >= errorThreshold).sort((a, b) => b.confidence - a.confidence).slice(0, count);
+}
+function getRulesForCategory(profile, category) {
+  return extractAllRules(profile).filter((r) => r.category === category);
+}
+function getRulesByCategory(profile) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const rule of extractAllRules(profile)) {
+    const existing = grouped.get(rule.category) ?? [];
+    existing.push(rule);
+    grouped.set(rule.category, existing);
+  }
+  return grouped;
+}
+var byConfidence = (a, b) => b.confidence - a.confidence;
+function getRulesByTier(profile) {
+  const allRules = extractAllRules(profile);
+  const errorThreshold = profile.severityThresholds?.error ?? 0.85;
+  const warnThreshold = profile.severityThresholds?.warn ?? 0.6;
+  const infoThreshold = profile.severityThresholds?.info ?? 0.4;
+  const critical = [];
+  const strong = [];
+  const preferred = [];
+  for (const rule of allRules) {
+    if (rule.confidence >= errorThreshold) {
+      critical.push(rule);
+    } else if (rule.confidence >= warnThreshold) {
+      strong.push(rule);
+    } else if (rule.confidence >= infoThreshold) {
+      preferred.push(rule);
+    }
+  }
+  critical.sort(byConfidence);
+  strong.sort(byConfidence);
+  preferred.sort(byConfidence);
+  return { critical, strong, preferred };
+}
+function readableConvention(rule) {
+  if (typeof rule.convention === "boolean" || typeof rule.convention === "number") {
+    return rule.description ?? JSON.stringify(rule.convention);
+  }
+  if (Array.isArray(rule.convention)) {
+    return rule.convention.join(" \u2192 ");
+  }
+  return String(rule.convention);
+}
+function detectLanguages(profile) {
+  const langs = [];
+  const hasTypescriptSignals = Object.keys(profile.naming).length > 0 || Object.keys(profile.structure).length > 0;
+  if (hasTypescriptSignals) langs.push("typescript");
+  return langs.length > 0 ? langs : ["typescript"];
+}
+
+// src/exporters/templates.ts
+import Handlebars from "handlebars";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function findPackageRoot(start) {
+  let dir = start;
+  while (!existsSync(join(dir, "package.json"))) {
+    const parent = dirname(dir);
+    if (parent === dir) throw new Error(`style-profile package root not found above ${start}`);
+    dir = parent;
+  }
+  return dir;
+}
+function loadTemplate(name) {
+  const root = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+  const source = readFileSync(join(root, "templates", name), "utf-8");
+  return Handlebars.compile(source);
+}
+
+// src/exporters/skill.ts
+function buildTieredRulesContext(profile) {
+  const tiers = getRulesByTier(profile);
+  const mapRule = (r) => ({
+    name: `${r.category}.${r.name}`,
+    readableConvention: readableConvention(r),
+    confidencePercent: (r.confidence * 100).toFixed(0)
+  });
+  return {
+    criticalRules: tiers.critical.map(mapRule),
+    strongRules: tiers.strong.map(mapRule),
+    preferredRules: tiers.preferred.map(mapRule)
+  };
+}
+function buildNamingContext(profile) {
+  const section = profile.naming;
+  return Object.entries(section).map(([name, rule]) => ({
+    label: name.charAt(0).toUpperCase() + name.slice(1),
+    convention: typeof rule.convention === "string" ? rule.convention : JSON.stringify(rule.convention),
+    confidencePercent: (rule.confidence * 100).toFixed(0),
+    stability: rule.stability,
+    fixability: rule.fixability,
+    description: rule.description,
+    examples: rule.examples
+  }));
+}
+function buildPatternsContext(profile) {
+  const section = profile.patterns;
+  const patternRules = Object.entries(section).map(([name, rule]) => ({
+    name,
+    strength: typeof rule.convention === "string" ? rule.convention : "detected",
+    confidencePercent: (rule.confidence * 100).toFixed(0),
+    description: rule.description,
+    fixability: rule.fixability,
+    examples: rule.examples
+  }));
+  const preferredPatterns = profile.structure?.preferredPatterns;
+  let preferredList;
+  if (preferredPatterns && Array.isArray(preferredPatterns.convention)) {
+    preferredList = preferredPatterns.convention;
+  }
+  return { patterns: patternRules, preferredPatterns: preferredList };
+}
+function buildIdiomsContext(profile) {
+  return profile.idioms.detected.map((idiom) => ({
+    name: idiom.name,
+    description: idiom.description,
+    example: idiom.example
+  }));
+}
+function buildAntiPatternsContext(profile) {
+  return profile.antiPatterns.acknowledged.map((ap) => ({
+    pattern: ap.pattern,
+    reason: ap.reason
+  }));
+}
+function buildLanguageContext(profile, lang) {
+  const tiers = getRulesByTier(profile);
+  const mapRule = (r) => ({
+    category: r.category,
+    name: r.name,
+    convention: typeof r.convention === "string" ? r.convention : JSON.stringify(r.convention),
+    confidencePercent: (r.confidence * 100).toFixed(0),
+    readableConvention: readableConvention(r),
+    description: r.description
+  });
+  return {
+    language: lang.charAt(0).toUpperCase() + lang.slice(1),
+    criticalRules: tiers.critical.map(mapRule),
+    strongRules: tiers.strong.map(mapRule),
+    preferredRules: tiers.preferred.map(mapRule)
+  };
+}
+function renderSkillFile(profile, languages) {
+  const skillTemplate = loadTemplate("skill.md.hbs");
+  const idioms = buildIdiomsContext(profile);
+  const antiPatterns = buildAntiPatternsContext(profile);
+  return {
+    path: "skill.md",
+    content: skillTemplate({
+      author: profile.author,
+      ...buildTieredRulesContext(profile),
+      languages,
+      idioms: idioms.length > 0 ? idioms : void 0,
+      antiPatterns: antiPatterns.length > 0 ? antiPatterns : void 0
+    })
+  };
+}
+function generateSkillFiles(profile) {
+  const files = [];
+  const languages = detectLanguages(profile);
+  files.push(renderSkillFile(profile, languages));
+  const namingTemplate = loadTemplate("naming.md.hbs");
+  files.push({
+    path: "references/naming.md",
+    content: namingTemplate({ rules: buildNamingContext(profile) })
+  });
+  const patternsTemplate = loadTemplate("patterns.md.hbs");
+  files.push({
+    path: "references/patterns.md",
+    content: patternsTemplate(buildPatternsContext(profile))
+  });
+  const langTemplate = loadTemplate("per-language.md.hbs");
+  for (const lang of languages) {
+    files.push({
+      path: `references/per-language/${lang}.md`,
+      content: langTemplate(buildLanguageContext(profile, lang))
+    });
+  }
+  return files;
+}
+
+// src/exporters/claude-rules.ts
+function formatFrontmatter(globs, description) {
+  return [
+    "---",
+    `description: "${description}"`,
+    `globs: "${globs.join(", ")}"`,
+    "alwaysApply: false",
+    "---",
+    ""
+  ].join("\n");
+}
+function formatRuleLine(category, name, convention, description) {
+  const value = typeof convention === "string" ? convention : JSON.stringify(convention);
+  const desc = description ? ` -- ${description}` : "";
+  return `- **${category}.${name}**: \`${value}\`${desc}`;
+}
+function formatBody(author, rules) {
+  return [
+    `# ${author}'s TypeScript Style`,
+    "",
+    ...rules.sort((a, b) => b.confidence - a.confidence).map(
+      (r) => formatRuleLine(r.category, r.name, r.convention, r.description)
+    )
+  ].join("\n");
+}
+function generateClaudeRules(profile) {
+  const files = [];
+  const allRules = extractAllRules(profile);
+  const infoThreshold = profile.severityThresholds?.info ?? 0.4;
+  const eligibleRules = allRules.filter(
+    (r) => r.confidence >= infoThreshold
+  );
+  if (eligibleRules.length > 0) {
+    const frontmatter = formatFrontmatter(
+      ["**/*.ts", "**/*.tsx"],
+      `${profile.author}'s TypeScript coding style preferences`
+    );
+    files.push({
+      path: ".claude/rules/typescript.md",
+      content: frontmatter + formatBody(profile.author, eligibleRules) + "\n"
+    });
+  }
+  return files;
+}
+
+// src/exporters/hooks.ts
+function generateHooksConfig(_profile) {
+  return {
+    hooks: [
+      {
+        event: "PostToolUse",
+        matcher: "Write",
+        command: "codewatch diff --fix $TOOL_INPUT_FILE_PATH"
+      },
+      {
+        event: "PostToolUse",
+        matcher: "Edit",
+        command: "codewatch diff --fix $TOOL_INPUT_FILE_PATH"
+      }
+    ]
+  };
+}
+
+// src/exporters/eslint-rules.ts
+function toEslintSeverity(confidence, thresholds) {
+  if (confidence >= thresholds.error) return "error";
+  if (confidence >= thresholds.warn) return "warn";
+  if (confidence >= thresholds.info) return "info";
+  return null;
+}
+function severityRank(s) {
+  return s === "error" ? 3 : s === "warn" ? 2 : 1;
+}
+var NAMING_SELECTORS = {
+  variables: "variable",
+  functions: "function",
+  types: "typeLike",
+  constants: "variable"
+};
+function eslintExtensionOptions(rule) {
+  const eslintExt = rule.extensions?.eslint;
+  return eslintExt && typeof eslintExt === "object" && "options" in eslintExt && Array.isArray(eslintExt.options) ? eslintExt.options : void 0;
+}
+function namingSelectors(rule, selectorName) {
+  const eslintOptions = eslintExtensionOptions(rule);
+  if (eslintOptions) return eslintOptions;
+  if (typeof rule.convention === "string") {
+    return [{ selector: selectorName, format: [rule.convention] }];
+  }
+  return [];
+}
+function buildNamingConventionRule(profile) {
+  const thresholds = profile.severityThresholds;
+  const naming = profile.naming;
+  if (!naming) return null;
+  const selectors = [];
+  let maxSeverity = null;
+  for (const [key, rule] of Object.entries(naming)) {
+    if (key === "files") continue;
+    const selectorName = NAMING_SELECTORS[key];
+    if (!selectorName) continue;
+    const severity = toEslintSeverity(rule.confidence, thresholds);
+    if (!severity) continue;
+    if (!maxSeverity || severityRank(severity) > severityRank(maxSeverity)) {
+      maxSeverity = severity;
+    }
+    selectors.push(...namingSelectors(rule, selectorName));
+  }
+  if (selectors.length === 0 || !maxSeverity) return null;
+  return ["@typescript-eslint/naming-convention", [maxSeverity, ...selectors]];
+}
+function buildImportOrderRule(profile) {
+  const importOrder = profile.structure?.importOrder;
+  if (!importOrder) return null;
+  const severity = toEslintSeverity(importOrder.confidence, profile.severityThresholds);
+  if (!severity) return null;
+  const convention = Array.isArray(importOrder.convention) ? importOrder.convention : ["builtin", "external", "internal", "relative"];
+  return [
+    "perfectionist/sort-imports",
+    [
+      severity,
+      {
+        type: "natural",
+        groups: convention
+      }
+    ]
+  ];
+}
+function buildFunctionLengthRule(profile) {
+  const maxLines = profile.structure?.functionMaxLines;
+  if (!maxLines) return null;
+  const severity = toEslintSeverity(maxLines.confidence, profile.severityThresholds);
+  if (!severity) return null;
+  if (typeof maxLines.convention !== "number") return null;
+  return ["max-lines-per-function", [severity, { max: maxLines.convention }]];
+}
+function buildFileNamingRule(profile) {
+  const files = profile.naming?.files;
+  if (!files) return null;
+  const severity = toEslintSeverity(files.confidence, profile.severityThresholds);
+  if (!severity) return null;
+  if (typeof files.convention !== "string") return null;
+  const caseMap = {
+    "kebab-case": "kebabCase",
+    camelCase: "camelCase",
+    PascalCase: "pascalCase",
+    snake_case: "snakeCase"
+  };
+  return [
+    "unicorn/filename-case",
+    [severity, { case: { [caseMap[files.convention] ?? "kebabCase"]: true } }]
+  ];
+}
+function buildJsdocRules(profile) {
+  const rules = [];
+  const docs = profile.documentation;
+  if (!docs) return rules;
+  const functionDocs = docs.functionDocs;
+  if (!functionDocs) return rules;
+  const severity = toEslintSeverity(functionDocs.confidence, profile.severityThresholds);
+  if (!severity) return rules;
+  if (functionDocs.convention === "jsdoc-selective") {
+    rules.push(["jsdoc/require-jsdoc", [severity, { publicOnly: true }]]);
+  } else if (functionDocs.convention === "jsdoc-all") {
+    rules.push(["jsdoc/require-jsdoc", [severity]]);
+  }
+  return rules;
+}
+
+// src/exporters/eslint.ts
+function extensionEntry(rule, thresholds) {
+  const ext = rule.extensions?.eslint;
+  if (!ext) return null;
+  const sev = toEslintSeverity(rule.confidence, thresholds);
+  if (sev === null) return null;
+  const plugin = ext.rule.includes("/") ? ext.rule.split("/").slice(0, -1).join("/") : "";
+  return {
+    plugin,
+    rule: ext.rule,
+    severity: sev === "info" ? "warn" : sev,
+    options: ext.options
+  };
+}
+function collectEslintExtensions(profile) {
+  const entries = [];
+  for (const category of PROFILE_CATEGORIES) {
+    const section = profile[category];
+    if (!section) continue;
+    for (const [, rule] of Object.entries(section)) {
+      const entry = extensionEntry(rule, profile.severityThresholds);
+      if (entry) entries.push(entry);
+    }
+  }
+  return entries;
+}
+function addImportOrderRule(profile, entries) {
+  const result = buildImportOrderRule(profile);
+  if (!result) return;
+  const [ruleName, ruleConfig] = result;
+  const configArray = ruleConfig;
+  const severity = configArray[0];
+  if (severity === "info") return;
+  entries.push({
+    plugin: "perfectionist",
+    rule: ruleName,
+    severity,
+    options: [configArray[1]]
+  });
+}
+function detectRequiredPlugins(entries) {
+  const plugins = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.plugin.includes("@typescript-eslint")) {
+      plugins.add("@typescript-eslint");
+    }
+    if (entry.plugin === "perfectionist") {
+      plugins.add("perfectionist");
+    }
+    if (entry.plugin.includes("unicorn")) {
+      plugins.add("unicorn");
+    }
+    if (entry.plugin.includes("jsdoc")) {
+      plugins.add("jsdoc");
+    }
+  }
+  return plugins;
+}
+function generateImportStatements(plugins) {
+  const imports = [];
+  if (plugins.has("@typescript-eslint")) {
+    imports.push(`import tseslint from "@typescript-eslint/eslint-plugin";`);
+    imports.push(`import tsparser from "@typescript-eslint/parser";`);
+  }
+  if (plugins.has("perfectionist")) {
+    imports.push(`import perfectionist from "eslint-plugin-perfectionist";`);
+  }
+  if (plugins.has("unicorn")) {
+    imports.push(`import unicorn from "eslint-plugin-unicorn";`);
+  }
+  if (plugins.has("jsdoc")) {
+    imports.push(`import jsdoc from "eslint-plugin-jsdoc";`);
+  }
+  return imports;
+}
+function buildRulesObject(entries) {
+  const rules = {};
+  for (const entry of entries) {
+    if (entry.options && entry.options.length > 0) {
+      rules[entry.rule] = [entry.severity, ...entry.options];
+    } else {
+      rules[entry.rule] = entry.severity;
+    }
+  }
+  return rules;
+}
+function generateEslintExport(profile) {
+  const entries = collectEslintExtensions(profile);
+  addImportOrderRule(profile, entries);
+  const plugins = detectRequiredPlugins(entries);
+  const imports = generateImportStatements(plugins);
+  const rules = buildRulesObject(entries);
+  const header = [
+    `// Generated by codewatch for ${profile.author}`,
+    `// Date: ${profile.generated}`,
+    `// Do not edit manually - regenerate with: codewatch export --format eslint`,
+    ""
+  ].join("\n");
+  const content = [
+    header,
+    ...imports,
+    "",
+    `export default ${JSON.stringify({ rules }, null, 2)};`,
+    ""
+  ].join("\n");
+  return { path: "eslint.config.js", content };
+}
+
+// src/exporters/ruff.ts
+var CATEGORY_KEYS = [
+  "naming",
+  "structure",
+  "documentation",
+  "errorHandling",
+  "formatting",
+  "patterns"
+];
+function addExtensionCodes(rule, select) {
+  if (!rule.extensions?.ruff) return;
+  const ext = rule.extensions.ruff;
+  if (!ext.codes) return;
+  for (const code of ext.codes) {
+    select.add(code.replace(/\d+$/, ""));
+  }
+}
+function applyFunctionMaxLines(category, name, rule, acc) {
+  if (category !== "structure" || name !== "functionMaxLines") return;
+  acc.select.add("C90");
+  if (typeof rule.convention === "number") {
+    acc.mccabe = { maxComplexity: rule.convention };
+  }
+}
+function applyRule(category, name, rule, acc) {
+  addExtensionCodes(rule, acc.select);
+  if (category === "naming") {
+    acc.select.add("N");
+  }
+  if (category === "structure" && name === "importOrder") {
+    acc.select.add("I");
+    if (Array.isArray(rule.convention)) {
+      acc.isort = { sectionOrder: rule.convention };
+    }
+  }
+  if (category === "documentation" && name === "functionDocs") {
+    acc.select.add("D");
+    if (typeof rule.convention === "string") {
+      acc.pydocstyle = { convention: rule.convention };
+    }
+  }
+  applyFunctionMaxLines(category, name, rule, acc);
+}
+function lineLengthOf(profile) {
+  const lineLengthRule = profile.formatting?.lineLength;
+  if (lineLengthRule && typeof lineLengthRule.convention === "number") {
+    return lineLengthRule.convention;
+  }
+  return void 0;
+}
+function buildRuffConfig(profile) {
+  const thresholds = profile.severityThresholds;
+  const acc = { select: /* @__PURE__ */ new Set() };
+  const fixable = /* @__PURE__ */ new Set(["ALL"]);
+  for (const category of CATEGORY_KEYS) {
+    const section = profile[category];
+    if (!section) continue;
+    for (const [name, rule] of Object.entries(
+      section
+    )) {
+      if (rule.confidence < thresholds.info) continue;
+      applyRule(category, name, rule, acc);
+    }
+  }
+  return {
+    lineLength: lineLengthOf(profile),
+    lint: {
+      select: [...acc.select].sort(),
+      ignore: [],
+      fixable: [...fixable],
+      mccabe: acc.mccabe,
+      pydocstyle: acc.pydocstyle,
+      isort: acc.isort
+    }
+  };
+}
+function toTomlArray(items) {
+  return `[${items.map((s) => `"${s}"`).join(", ")}]`;
+}
+function serializeLintTable(lint) {
+  const lines = ["[lint]"];
+  if (lint.select.length > 0) {
+    lines.push(`select = ${toTomlArray(lint.select)}`);
+  }
+  if (lint.ignore.length > 0) {
+    lines.push(`ignore = ${toTomlArray(lint.ignore)}`);
+  }
+  if (lint.fixable.length > 0) {
+    lines.push(`fixable = ${toTomlArray(lint.fixable)}`);
+  }
+  lines.push("");
+  return lines;
+}
+function serializeLintSubtables(lint) {
+  const lines = [];
+  if (lint.mccabe) {
+    lines.push("[lint.mccabe]");
+    lines.push(`max-complexity = ${lint.mccabe.maxComplexity}`);
+    lines.push("");
+  }
+  if (lint.pydocstyle) {
+    lines.push("[lint.pydocstyle]");
+    lines.push(`convention = "${lint.pydocstyle.convention}"`);
+    lines.push("");
+  }
+  if (lint.isort) {
+    lines.push("[lint.isort]");
+    lines.push(`section-order = ${toTomlArray(lint.isort.sectionOrder)}`);
+    lines.push("");
+  }
+  return lines;
+}
+function serializeToToml(config) {
+  const lines = [];
+  if (config.lineLength !== void 0) {
+    lines.push(`line-length = ${config.lineLength}`);
+    lines.push("");
+  }
+  lines.push(...serializeLintTable(config.lint));
+  lines.push(...serializeLintSubtables(config.lint));
+  return lines.join("\n");
+}
+function generateRuffExport(profile) {
+  const config = buildRuffConfig(profile);
+  const header = [
+    `# Generated by codewatch for ${profile.author}`,
+    `# Date: ${profile.generated}`,
+    `# Do not edit manually - regenerate with: codewatch export --format ruff`,
+    ""
+  ].join("\n");
+  return {
+    path: "ruff.toml",
+    content: header + serializeToToml(config)
+  };
+}
+
+// src/exporters/markdown.ts
+function capitalize(str) {
+  const spaced = str.replace(/([A-Z])/g, " $1");
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+function formatConvention(convention) {
+  if (typeof convention === "string") return convention;
+  if (typeof convention === "number") return String(convention);
+  if (typeof convention === "boolean") return String(convention);
+  return JSON.stringify(convention);
+}
+function groupByCategory(rules) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const existing = byCategory.get(rule.category) ?? [];
+    existing.push(rule);
+    byCategory.set(rule.category, existing);
+  }
+  return byCategory;
+}
+function exampleLines(examples) {
+  const lines = [];
+  for (const example of examples) {
+    if (example.good) {
+      lines.push("```typescript");
+      lines.push("// Preferred");
+      lines.push(example.good);
+      lines.push("```");
+      lines.push("");
+    }
+    if (example.bad) {
+      lines.push("```typescript");
+      lines.push("// Avoid");
+      lines.push(example.bad);
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  return lines;
+}
+function ruleLines(rule) {
+  const lines = [];
+  const confPct = (rule.confidence * 100).toFixed(0);
+  const value = formatConvention(rule.convention);
+  lines.push(`### ${capitalize(rule.name)}`);
+  lines.push("");
+  lines.push(
+    `**Convention**: \`${value}\` | **Confidence**: ${confPct}%${rule.stability ? ` | **Stability**: ${rule.stability}` : ""}`
+  );
+  lines.push("");
+  if (rule.description) {
+    lines.push(rule.description);
+    lines.push("");
+  }
+  if (rule.examples && rule.examples.length > 0) {
+    lines.push(...exampleLines(rule.examples));
+  }
+  return lines;
+}
+function generateMarkdownExport(profile) {
+  const allRules = extractAllRules(profile);
+  const byCategory = groupByCategory(allRules);
+  const lines = [];
+  lines.push(`# ${profile.author}'s Code Style Guide`);
+  lines.push("");
+  lines.push(`> Generated by codewatch on ${profile.generated}`);
+  lines.push(
+    `> Sources: ${profile.sources.length > 0 ? profile.sources.join(", ") : "N/A"}`
+  );
+  lines.push("");
+  for (const [category, rules] of byCategory) {
+    lines.push(`## ${capitalize(category)}`);
+    lines.push("");
+    const sorted = [...rules].sort((a, b) => b.confidence - a.confidence);
+    for (const rule of sorted) {
+      lines.push(...ruleLines(rule));
+    }
+  }
+  return {
+    path: "style-guide.md",
+    content: lines.join("\n")
+  };
+}
+
+// src/exporters/editorconfig.ts
+function getConvention(section, key) {
+  const rule = section[key];
+  if (!rule) return void 0;
+  return rule.convention;
+}
+function indentAndNewlineLines(formatting) {
+  const lines = [];
+  const indentStyle = getConvention(formatting, "indentStyle");
+  if (indentStyle) {
+    const value = indentStyle === "spaces" ? "space" : indentStyle === "tabs" ? "tab" : indentStyle;
+    lines.push(`indent_style = ${value}`);
+  }
+  const indentSize = getConvention(formatting, "indentSize");
+  if (indentSize !== void 0) {
+    lines.push(`indent_size = ${indentSize}`);
+  }
+  const trailingNewline = getConvention(
+    formatting,
+    "trailingNewline"
+  );
+  if (trailingNewline !== void 0) {
+    lines.push(`insert_final_newline = ${trailingNewline}`);
+  }
+  return lines;
+}
+function generateEditorConfigExport(profile) {
+  const formatting = profile.formatting;
+  const lines = [];
+  lines.push("# Generated by codewatch");
+  lines.push("root = true");
+  lines.push("");
+  lines.push("[*]");
+  lines.push(...indentAndNewlineLines(formatting));
+  lines.push("end_of_line = lf");
+  lines.push("charset = utf-8");
+  lines.push("trim_trailing_whitespace = true");
+  const lineLength = getConvention(formatting, "lineLength");
+  if (lineLength !== void 0) {
+    lines.push(`max_line_length = ${lineLength}`);
+  }
+  lines.push("");
+  return {
+    path: ".editorconfig",
+    content: lines.join("\n")
+  };
+}
+
+// src/exporters/export-index.ts
+var SUPPORTED_FORMATS = [
+  "skill",
+  "claude-rules",
+  "hooks",
+  "eslint",
+  "ruff",
+  "markdown",
+  "editorconfig"
+];
+function hooksFiles(profile) {
+  const config = generateHooksConfig(profile);
+  return [
+    {
+      path: ".claude/settings.json",
+      content: JSON.stringify(config, null, 2)
+    }
+  ];
+}
+function exportProfile(profile, format) {
+  switch (format) {
+    case "skill":
+      return generateSkillFiles(profile);
+    case "claude-rules":
+      return generateClaudeRules(profile);
+    case "hooks":
+      return hooksFiles(profile);
+    case "eslint":
+      return [generateEslintExport(profile)];
+    case "ruff":
+      return [generateRuffExport(profile)];
+    case "markdown":
+      return [generateMarkdownExport(profile)];
+    case "editorconfig":
+      return [generateEditorConfigExport(profile)];
+    default:
+      throw new Error(
+        `Unsupported export format: "${format}". Supported formats: ${SUPPORTED_FORMATS.join(", ")}`
+      );
+  }
+}
+export {
+  DEFAULT_SEVERITY_THRESHOLDS,
+  ExampleSchema,
+  FixabilitySchema,
+  PROFILE_CATEGORIES,
+  ProfileSchema,
+  SCHEMA_VERSION,
+  SUPPORTED_FORMATS,
+  StabilitySchema,
+  StyleRuleSchema,
+  buildFileNamingRule,
+  buildFunctionLengthRule,
+  buildImportOrderRule,
+  buildJsdocRules,
+  buildNamingConventionRule,
+  detectLanguages,
+  exportProfile,
+  extractAllRules,
+  generateClaudeRules,
+  generateEditorConfigExport,
+  generateEslintExport,
+  generateHooksConfig,
+  generateMarkdownExport,
+  generateRuffExport,
+  generateSkillFiles,
+  getRulesByCategory,
+  getRulesForCategory,
+  getTopRules,
+  migrateProfile,
+  readProfile,
+  registerMigration,
+  severityRank,
+  toEslintSeverity,
+  validateProfile,
+  writeProfile
+};
+//# sourceMappingURL=index.js.map