@ftarganski/omni-ai 0.1.0

package/dist/chunk-JTXDF5KG.js

@@ -0,0 +1,156 @@
+// ../skills/src/ux/audit-accessibility.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { z } from "zod";
+var InputSchema = z.object({
+  path: z.string().describe("File path (.tsx/.ts) or directory to audit recursively"),
+  recursive: z.boolean().default(false).describe("Scan all .tsx files in the directory recursively")
+});
+var RULES = [
+  {
+    id: "img-missing-alt",
+    severity: "critical",
+    description: "<img> without alt attribute \u2014 screen readers will read the file name",
+    suggestion: 'Add alt="" for decorative images or alt="descriptive text" for informative ones',
+    pattern: /<img(?![^>]*\balt=)[^>]*/
+  },
+  {
+    id: "onclick-non-interactive",
+    severity: "critical",
+    description: "onClick on a non-interactive element (div/span/p) without role or tabIndex",
+    suggestion: 'Use <button> instead, or add role="button" tabIndex={0} onKeyDown handler',
+    pattern: /<(div|span|p|section|article)\s[^>]*onClick/,
+    isIssue: (_match, line) => !/role=["']button["']/.test(line) && !/tabIndex/.test(line)
+  },
+  {
+    id: "link-blank-no-rel",
+    severity: "moderate",
+    description: 'target="_blank" without rel="noopener noreferrer" \u2014 security risk and unexpected UX',
+    suggestion: 'Add rel="noopener noreferrer" to all target="_blank" links',
+    pattern: /target=["']_blank["']/,
+    isIssue: (_match, line) => !/rel=/.test(line)
+  },
+  {
+    id: "hardcoded-color",
+    severity: "moderate",
+    description: "Hardcoded Tailwind color scale class \u2014 will break dark mode and theme consistency",
+    suggestion: "Replace with shadcn/ui semantic tokens: bg-background, text-foreground, bg-muted, text-muted-foreground, border-border",
+    pattern: /className=[^>]*["'][^"']*\b(bg|text|border|ring|outline|fill|stroke)-(white|black|gray|zinc|slate|stone|neutral|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d+[^"']*["']/
+  },
+  {
+    id: "icon-button-no-label",
+    severity: "critical",
+    description: "Button containing only an icon without aria-label \u2014 invisible to screen readers",
+    suggestion: 'Add aria-label="Descriptive action name" to the button',
+    pattern: /<button(?![^>]*aria-label)[^>]*>\s*<[A-Z][a-zA-Z]+\s*(?:size|className|strokeWidth)[^/]*\/>\s*<\/button>/
+  },
+  {
+    id: "input-missing-label",
+    severity: "critical",
+    description: "<input> or <Input> without aria-label, aria-labelledby, or associated <label>",
+    suggestion: "Wrap with Form.Item + Form.Label, or add aria-label directly to the input",
+    pattern: /<(?:input|Input)\s(?![^>]*(?:aria-label|aria-labelledby|id=))[^>]*/,
+    isIssue: (_match, _line, allLines, lineIndex) => {
+      const context = allLines.slice(Math.max(0, lineIndex - 5), lineIndex + 5).join("\n");
+      return !/<label|Form\.Label|htmlFor/.test(context);
+    }
+  },
+  {
+    id: "autofocus",
+    severity: "low",
+    description: "autoFocus used \u2014 can disorient screen reader users and break keyboard flow",
+    suggestion: "Manage focus programmatically with useEffect + ref.focus() only when truly needed (e.g. after modal opens)",
+    pattern: /\bautoFocus\b/
+  },
+  {
+    id: "inline-style",
+    severity: "low",
+    description: "Inline style attribute \u2014 bypasses theme system and cannot adapt to dark mode",
+    suggestion: "Replace with Tailwind utility classes or shadcn/ui semantic tokens",
+    pattern: /\bstyle=\{/
+  },
+  {
+    id: "no-focus-visible",
+    severity: "moderate",
+    description: "Interactive element may be missing focus-visible styles",
+    suggestion: "Ensure focus-visible:ring-2 focus-visible:ring-ring is present on all focusable elements",
+    pattern: /<(button|a|input|select|textarea|Input|Button|Link)[^>]*(?:className|class)=["'][^"']*["'][^>]*>/,
+    isIssue: (_match, line) => !/focus-visible/.test(line) && !/focus:ring/.test(line)
+  }
+];
+async function auditFile(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  const lines = content.split("\n");
+  const issues = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const rule of RULES) {
+      rule.pattern.lastIndex = 0;
+      const match = rule.pattern.exec(line);
+      if (!match) continue;
+      const isIssue = rule.isIssue ? rule.isIssue(match, line, lines, i) : true;
+      if (!isIssue) continue;
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: rule.severity,
+        rule: rule.id,
+        description: rule.description,
+        suggestion: rule.suggestion,
+        snippet: line.trim().slice(0, 120)
+      });
+    }
+  }
+  return issues;
+}
+var MAX_DEPTH = 10;
+var MAX_FILES = 500;
+async function collectFiles(dir, recursive, depth = 0, results = []) {
+  if (depth > MAX_DEPTH || results.length >= MAX_FILES) return results;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (results.length >= MAX_FILES) break;
+    if (entry.name === "node_modules" || entry.name === "dist") continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory() && recursive) {
+      await collectFiles(full, recursive, depth + 1, results);
+    } else if (entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+var auditAccessibilitySkill = {
+  name: "audit-accessibility",
+  description: "Heuristic static scan of React TSX files for accessibility and dark-mode issues. Detects: missing alt, onClick on non-interactive elements, icon-only buttons without aria-label, inputs without labels, target=_blank without rel, hardcoded colors, missing focus-visible styles, autoFocus misuse, inline styles.",
+  async execute(input) {
+    const { path, recursive } = InputSchema.parse(input);
+    let files;
+    try {
+      const entries = await readdir(path);
+      files = await collectFiles(path, recursive ?? false);
+      void entries;
+    } catch {
+      files = [path];
+    }
+    const allIssues = [];
+    for (const file of files) {
+      allIssues.push(...await auditFile(file));
+    }
+    const critical = allIssues.filter((i) => i.severity === "critical").length;
+    const moderate = allIssues.filter((i) => i.severity === "moderate").length;
+    const low = allIssues.filter((i) => i.severity === "low").length;
+    return {
+      totalFiles: files.length,
+      totalIssues: allIssues.length,
+      critical,
+      moderate,
+      low,
+      issues: allIssues
+    };
+  }
+};
+
+export {
+  auditAccessibilitySkill
+};

package/dist/chunk-M4QJF7CV.js

@@ -0,0 +1,57 @@
+// ../skills/src/code/search-code.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { z } from "zod";
+var InputSchema = z.object({
+  directory: z.string().describe("Root directory to search in"),
+  pattern: z.string().describe("Text substring or regex pattern to search for"),
+  extensions: z.array(z.string()).default([".ts", ".tsx"]).describe("File extensions to include in the search"),
+  maxResults: z.number().int().positive().default(30).describe("Maximum number of matching lines to return"),
+  useRegex: z.boolean().default(false).describe("Treat pattern as a regular expression")
+});
+async function searchInFile(filePath, matcher, results, maxResults) {
+  if (results.length >= maxResults) return;
+  const text = await readFile(filePath, "utf-8");
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (results.length >= maxResults) break;
+    if (matcher(lines[i])) {
+      results.push({ file: filePath, line: i + 1, content: lines[i].trim() });
+    }
+  }
+}
+async function walkAndSearch(dir, extensions, matcher, results, maxResults) {
+  if (results.length >= maxResults) return;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (results.length >= maxResults) break;
+    if (entry.name === "node_modules" || entry.name === "dist") continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkAndSearch(fullPath, extensions, matcher, results, maxResults);
+    } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
+      await searchInFile(fullPath, matcher, results, maxResults);
+    }
+  }
+}
+var searchCodeSkill = {
+  name: "search-code",
+  description: "Search for a text pattern across TypeScript/TSX source files. Use this to find existing components, hooks, types or patterns before generating new code \u2014 avoiding duplicates and understanding existing conventions.",
+  async execute(input) {
+    const { directory, pattern, extensions, maxResults, useRegex } = InputSchema.parse(input);
+    let matcher;
+    if (useRegex) {
+      const re = new RegExp(pattern);
+      matcher = (line) => re.test(line);
+    } else {
+      matcher = (line) => line.includes(pattern);
+    }
+    const results = [];
+    await walkAndSearch(directory, extensions, matcher, results, maxResults);
+    return results;
+  }
+};
+
+export {
+  searchCodeSkill
+};

package/dist/chunk-PPTEJ2FH.js

@@ -0,0 +1,102 @@
+// ../skills/src/qa/analyze-test-coverage.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { z } from "zod";
+var InputSchema = z.object({
+  directory: z.string().describe("Root directory to scan for source files and their tests"),
+  extensions: z.array(z.string()).default([".ts", ".tsx"]).describe("Source file extensions to check"),
+  ignorePatterns: z.array(z.string()).default(["index.ts", "index.tsx", ".spec.", ".test.", ".d.ts", ".module.ts"]).describe("Substrings that mark files to skip (index, spec, declaration, module files)")
+});
+async function collectFiles(dir, exts, ignore) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return [];
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(fullPath, exts, ignore));
+    } else if (entry.isFile() && exts.some((e) => entry.name.endsWith(e)) && !ignore.some((p) => entry.name.includes(p) || fullPath.includes(p))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function collectAllFiles(dir) {
+  const files = await collectFiles(dir, [".ts", ".tsx"], []);
+  return new Set(files);
+}
+function specPathCandidates(filePath) {
+  const base = filePath.replace(/\.(tsx?)$/, "");
+  return [`${base}.spec.ts`, `${base}.spec.tsx`, `${base}.test.ts`, `${base}.test.tsx`];
+}
+var analyzeTestCoverageSkill = {
+  name: "analyze-test-coverage",
+  description: "Scan a directory and identify which source files have a corresponding .spec.ts test file and which do not. Use this before a QA pass to prioritize which files need tests written.",
+  async execute(input) {
+    const { directory, extensions, ignorePatterns } = InputSchema.parse(input);
+    const sourceFiles = await collectFiles(directory, extensions, ignorePatterns);
+    const allFiles = await collectAllFiles(directory);
+    const covered = [];
+    const uncovered = [];
+    for (const file of sourceFiles) {
+      const hasSpec = specPathCandidates(file).some((s) => allFiles.has(s));
+      if (hasSpec) covered.push(file);
+      else uncovered.push(file);
+    }
+    const total = covered.length + uncovered.length;
+    return {
+      covered,
+      uncovered,
+      coverageRate: total === 0 ? 1 : covered.length / total
+    };
+  }
+};
+
+// ../skills/src/qa/find-test-pattern.ts
+import { readdir as readdir2, readFile } from "fs/promises";
+import { join as join2 } from "path";
+import { z as z2 } from "zod";
+var patternFilters = {
+  service: (name) => name.endsWith(".service.spec.ts"),
+  component: (name) => /^[A-Z]/.test(name) && (name.endsWith(".spec.ts") || name.endsWith(".spec.tsx")),
+  hook: (name) => name.startsWith("use") && (name.endsWith(".spec.ts") || name.endsWith(".spec.tsx")),
+  resolver: (name) => name.endsWith(".resolver.spec.ts")
+};
+var InputSchema2 = z2.object({
+  patternType: z2.enum(["service", "component", "hook", "resolver"]).describe("Type of test pattern to find examples of"),
+  directory: z2.string().describe("Root directory to search in"),
+  maxExamples: z2.number().int().positive().default(2).describe("Maximum number of test examples to return")
+});
+async function walkForTests(dir, filter, results, max) {
+  if (results.length >= max) return;
+  const entries = await readdir2(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return;
+  for (const entry of entries) {
+    if (results.length >= max) break;
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkForTests(fullPath, filter, results, max);
+    } else if (entry.isFile() && filter(entry.name)) {
+      const content = await readFile(fullPath, "utf-8");
+      results.push({ file: fullPath, content });
+    }
+  }
+}
+var findTestPatternSkill = {
+  name: "find-test-pattern",
+  description: "Find real test file examples (service, component, hook, resolver) from the codebase. Use this before writing tests to understand the exact test structure, setup() pattern, mocking conventions and assertion style already in use.",
+  async execute(input) {
+    const { patternType, directory, maxExamples } = InputSchema2.parse(input);
+    const filter = patternFilters[patternType];
+    const results = [];
+    await walkForTests(directory, filter, results, maxExamples);
+    return results;
+  }
+};
+
+export {
+  analyzeTestCoverageSkill,
+  findTestPatternSkill
+};

package/dist/chunk-S5MK6LBH.js

@@ -0,0 +1,136 @@
+// ../skills/src/frontend/analyze-component.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { z } from "zod";
+var InputSchema = z.object({
+  path: z.string().describe("Path to the React component file (.tsx or .ts)")
+});
+function extractComponentName(source, filePath) {
+  const fnMatch = /(?:export\s+(?:default\s+)?function\s+|const\s+)([A-Z]\w*)/.exec(source);
+  if (fnMatch) return fnMatch[1];
+  const parts = filePath.split(/[/\\]/);
+  return (parts[parts.length - 1] ?? "").replace(/\.(tsx?|jsx?)$/, "");
+}
+function extractPropsInterface(source) {
+  const ifaceMatch = /interface\s+(\w*Props\w*)\s*\{([^}]*)\}/.exec(source);
+  if (ifaceMatch) return `interface ${ifaceMatch[1]} {${ifaceMatch[2]}}`;
+  const typeMatch = /type\s+(\w*Props\w*)\s*=\s*\{([^}]*)\}/.exec(source);
+  if (typeMatch) return `type ${typeMatch[1]} = {${typeMatch[2]}}`;
+  return null;
+}
+function extractHooksUsed(source) {
+  const matches = source.match(/\buse[A-Z]\w*/g) ?? [];
+  return [...new Set(matches)];
+}
+function extractNamedExports(source) {
+  return [...source.matchAll(/export\s+(?:const|function|class|type|interface|enum)\s+(\w+)/g)].map((m) => m[1]);
+}
+var analyzeComponentSkill = {
+  name: "analyze-component",
+  description: "Parse a React component file and extract its name, props interface, hooks used, named exports, and whether it has a default export. Use this to understand an existing component's contract before creating a related component or hook.",
+  async execute(input) {
+    const { path } = InputSchema.parse(input);
+    const source = await readFile(resolve(path), "utf-8");
+    return {
+      componentName: extractComponentName(source, path),
+      propsInterface: extractPropsInterface(source),
+      hooksUsed: extractHooksUsed(source),
+      namedExports: extractNamedExports(source),
+      hasDefaultExport: /export\s+default\s+/.test(source)
+    };
+  }
+};
+
+// ../skills/src/frontend/analyze-module-structure.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { z as z2 } from "zod";
+var InputSchema2 = z2.object({
+  directory: z2.string().describe("Root directory of the React module or feature folder")
+});
+async function collectFiles(dir) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return [];
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === "dist") continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(fullPath));
+    } else if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function categorize(files) {
+  const result = { components: [], hooks: [], pages: [], stores: [], indexFiles: [] };
+  for (const f of files) {
+    const name = f.split(/[/\\]/).pop() ?? "";
+    if (name.includes(".spec.") || name.includes(".test.")) continue;
+    if (name === "index.ts" || name === "index.tsx") result.indexFiles.push(f);
+    else if (name.startsWith("use")) result.hooks.push(f);
+    else if (/page|route/i.test(name)) result.pages.push(f);
+    else if (/store|context|provider/i.test(name)) result.stores.push(f);
+    else if (/^[A-Z]/.test(name)) result.components.push(f);
+  }
+  return result;
+}
+var analyzeModuleStructureSkill = {
+  name: "analyze-module-structure",
+  description: "Map the file structure of a React module directory: lists components, hooks, pages, stores and index files. Use this before creating a new feature module to understand the existing layout and avoid duplicating files.",
+  async execute(input) {
+    const { directory } = InputSchema2.parse(input);
+    const files = await collectFiles(directory);
+    return categorize(files);
+  }
+};
+
+// ../skills/src/frontend/find-component-pattern.ts
+import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { z as z3 } from "zod";
+var patternFilters = {
+  component: (name) => /^[A-Z]/.test(name) && (name.endsWith(".tsx") || name.endsWith(".ts")) && !name.includes(".spec."),
+  hook: (name) => name.startsWith("use") && (name.endsWith(".ts") || name.endsWith(".tsx")) && !name.includes(".spec."),
+  page: (name) => /page|route/i.test(name) && (name.endsWith(".tsx") || name.endsWith(".ts")) && !name.includes(".spec."),
+  module: (name) => (name === "index.ts" || name === "index.tsx" || /module/i.test(name)) && !name.includes(".spec.")
+};
+var InputSchema3 = z3.object({
+  patternType: z3.enum(["component", "hook", "page", "module"]).describe("Type of React pattern to find examples of"),
+  directory: z3.string().describe("Root directory to search in"),
+  maxExamples: z3.number().int().positive().default(3).describe("Maximum number of examples to return")
+});
+async function walkForComponent(dir, filter, results, max) {
+  if (results.length >= max) return;
+  const entries = await readdir2(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return;
+  for (const entry of entries) {
+    if (results.length >= max) break;
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkForComponent(fullPath, filter, results, max);
+    } else if (entry.isFile() && filter(entry.name)) {
+      const content = await readFile2(fullPath, "utf-8");
+      results.push({ file: fullPath, content });
+    }
+  }
+}
+var findComponentPatternSkill = {
+  name: "find-component-pattern",
+  description: "Find real examples of React patterns (component, hook, page, module) from the codebase. Use this before generating new UI code to understand the exact naming conventions, file structure and import patterns already in use.",
+  async execute(input) {
+    const { patternType, directory, maxExamples } = InputSchema3.parse(input);
+    const filter = patternFilters[patternType];
+    const results = [];
+    await walkForComponent(directory, filter, results, maxExamples);
+    return results;
+  }
+};
+
+export {
+  analyzeComponentSkill,
+  analyzeModuleStructureSkill,
+  findComponentPatternSkill
+};

package/dist/chunk-TFU437SW.js

@@ -0,0 +1,107 @@
+// ../skills/src/fs/list-directory.ts
+import { readdir } from "fs/promises";
+import { join, resolve, sep } from "path";
+import { z } from "zod";
+var InputSchema = z.object({
+  path: z.string().describe("Directory path to list"),
+  recursive: z.boolean().default(false).describe("Whether to list files in subdirectories recursively"),
+  extensions: z.array(z.string()).optional().describe('Filter results by file extension, e.g. [".ts", ".tsx"]')
+});
+function assertSafePath(inputPath) {
+  const cwd = process.cwd();
+  const resolved = resolve(cwd, inputPath);
+  const cwdWithSep = cwd.endsWith(sep) ? cwd : cwd + sep;
+  if (resolved !== cwd && !resolved.startsWith(cwdWithSep)) {
+    throw new Error(`Access denied: "${inputPath}" resolves outside the working directory`);
+  }
+  return resolved;
+}
+async function walk(dir, recursive, extensions) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (recursive) {
+        results.push(...await walk(fullPath, recursive, extensions));
+      }
+    } else if (entry.isFile()) {
+      const include = !extensions || extensions.some((ext) => entry.name.endsWith(ext));
+      if (include) results.push(fullPath);
+    }
+  }
+  return results;
+}
+var listDirectorySkill = {
+  name: "list-directory",
+  description: "List files in a directory. Use this to discover existing components, pages or hooks before creating new ones, avoiding duplicates.",
+  async execute(input) {
+    const { path, recursive, extensions } = InputSchema.parse(input);
+    const safePath = assertSafePath(path);
+    return await walk(safePath, recursive, extensions);
+  }
+};
+
+// ../skills/src/fs/read-file.ts
+import { readFile } from "fs/promises";
+import { resolve as resolve2, sep as sep2 } from "path";
+import { z as z2 } from "zod";
+var InputSchema2 = z2.object({
+  path: z2.string().describe("Absolute or relative path to the file to read")
+});
+function assertSafePath2(inputPath) {
+  const cwd = process.cwd();
+  const resolved = resolve2(cwd, inputPath);
+  const cwdWithSep = cwd.endsWith(sep2) ? cwd : cwd + sep2;
+  if (resolved !== cwd && !resolved.startsWith(cwdWithSep)) {
+    throw new Error(`Access denied: "${inputPath}" resolves outside the working directory`);
+  }
+  return resolved;
+}
+var readFileSkill = {
+  name: "read-file",
+  description: "Read the full text content of a file. Use this to inspect existing components, hooks, pages, config files or any source file before generating new code.",
+  async execute(input) {
+    const { path } = InputSchema2.parse(input);
+    const safePath = assertSafePath2(path);
+    return await readFile(safePath, "utf-8");
+  }
+};
+
+// ../skills/src/fs/write-file.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, resolve as resolve3, sep as sep3 } from "path";
+import { z as z3 } from "zod";
+var InputSchema3 = z3.object({
+  path: z3.string().describe("Absolute or relative path where the file will be written"),
+  content: z3.string().describe("Full text content to write"),
+  createDirs: z3.boolean().default(true).describe("Create intermediate directories if they do not exist")
+});
+function assertSafePath3(inputPath) {
+  const cwd = process.cwd();
+  const resolved = resolve3(cwd, inputPath);
+  const cwdWithSep = cwd.endsWith(sep3) ? cwd : cwd + sep3;
+  if (resolved !== cwd && !resolved.startsWith(cwdWithSep)) {
+    throw new Error(`Access denied: "${inputPath}" resolves outside the working directory`);
+  }
+  return resolved;
+}
+var writeFileSkill = {
+  name: "write-file",
+  description: "Write or overwrite a file with the given content. Use this to create new components, hooks, pages or any source file after generating the code.",
+  async execute(input) {
+    const { path, content, createDirs } = InputSchema3.parse(input);
+    const safePath = assertSafePath3(path);
+    if (createDirs) {
+      await mkdir(dirname(safePath), { recursive: true });
+    }
+    await writeFile(safePath, content, "utf-8");
+    return `Written: ${safePath}`;
+  }
+};
+
+export {
+  listDirectorySkill,
+  readFileSkill,
+  writeFileSkill
+};