nuxt-skill-hub 0.0.6 → 0.0.7

package/dist/module.d.mts

@@ -11,6 +11,11 @@ interface ModuleOptions {
     targets?: SkillHubTarget[];
     moduleAuthoring?: boolean;
     generationMode?: SkillHubGenerationMode;
+    /**
+     * Auto-register ESLint rule to remove redundant imports when @nuxt/eslint is installed.
+     * @default true
+     */
+    eslint?: boolean;
 }
 interface SkillHubContribution {
     packageName: string;

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-skill-hub",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "configKey": "skillHub",
   "compatibility": {
     "nuxt": ">=4.3.0"

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { useLogger, defineNuxtModule } from '@nuxt/kit';
-import { isCI, isTest } from 'std-env';
+import { isAgent, agent, isCI, isTest } from 'std-env';
 import { promises, existsSync, lstatSync, writeFileSync, readFileSync } from 'node:fs';
 import { join, basename, resolve, dirname, relative, isAbsolute } from 'pathe';
 import { fileURLToPath } from 'mlly';
@@ -16,7 +16,7 @@ import { glob } from 'tinyglobby';
 import { createConsola } from 'consola';
 import { colorize } from 'consola/utils';
 
-const version = "0.0.6";
+const version = "0.0.7";
 const packageJson = {
 	version: version};
 
@@ -1062,6 +1062,9 @@ function findGitHubOverride(packageName) {
 
 const GITHUB_API_BASE = "https://api.github.com";
 const UNGH_API_BASE = "https://ungh.cc";
+const githubDirectoryCache = /* @__PURE__ */ new Map();
+const githubDefaultBranchCache = /* @__PURE__ */ new Map();
+const githubFileTextCache = /* @__PURE__ */ new Map();
 function githubFetchOptions(timeoutMs) {
   return {
     timeout: timeoutMs,
@@ -1096,6 +1099,15 @@ function toRepoPath(value) {
   }
   return null;
 }
+function memoize(cache, key, factory) {
+  const cached = cache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const pending = factory();
+  cache.set(key, pending);
+  return pending;
+}
 function parseGitHubRepo(input) {
   if (!input) {
     return null;
@@ -1109,25 +1121,27 @@ async function listGitHubDirectory(repo, ref, dirPath, timeoutMs) {
   }
   const normalizedDirPath = dirPath.replace(/^\/+|\/+$/g, "");
   const prefix = normalizedDirPath ? `${normalizedDirPath}/` : "";
-  try {
-    const data = await ofetch(
-      `${GITHUB_API_BASE}/repos/${repoPath}/git/trees/${encodeURIComponent(ref)}?recursive=1`,
-      githubFetchOptions(timeoutMs)
-    );
-    const entries = /* @__PURE__ */ new Set();
-    for (const entry of data.tree || []) {
-      if (entry.type !== "tree" || !entry.path.startsWith(prefix)) {
-        continue;
-      }
-      const remainder = entry.path.slice(prefix.length);
-      if (remainder && !remainder.includes("/")) {
-        entries.add(remainder);
+  return await memoize(githubDirectoryCache, `${repoPath}::${ref}::${normalizedDirPath}`, async () => {
+    try {
+      const data = await ofetch(
+        `${GITHUB_API_BASE}/repos/${repoPath}/git/trees/${encodeURIComponent(ref)}?recursive=1`,
+        githubFetchOptions(timeoutMs)
+      );
+      const entries = /* @__PURE__ */ new Set();
+      for (const entry of data.tree || []) {
+        if (entry.type !== "tree" || !entry.path.startsWith(prefix)) {
+          continue;
+        }
+        const remainder = entry.path.slice(prefix.length);
+        if (remainder && !remainder.includes("/")) {
+          entries.add(remainder);
+        }
       }
+      return Array.from(entries).sort((a, b) => a.localeCompare(b));
+    } catch {
+      return [];
     }
-    return Array.from(entries).sort((a, b) => a.localeCompare(b));
-  } catch {
-    return [];
-  }
+  });
 }
 async function fetchGitHubDefaultBranch(repo, timeoutMs) {
   const repoPath = toRepoPath(repo);
@@ -1138,38 +1152,42 @@ async function fetchGitHubDefaultBranch(repo, timeoutMs) {
   if (!owner || !name) {
     return null;
   }
-  try {
-    const data = await ofetch(
-      `${UNGH_API_BASE}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`,
-      githubFetchOptions(timeoutMs)
-    );
-    return data.repo?.defaultBranch || null;
-  } catch {
-    return null;
-  }
+  return await memoize(githubDefaultBranchCache, repoPath, async () => {
+    try {
+      const data = await ofetch(
+        `${UNGH_API_BASE}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`,
+        githubFetchOptions(timeoutMs)
+      );
+      return data.repo?.defaultBranch || null;
+    } catch {
+      return null;
+    }
+  });
 }
 async function fetchGitHubFileText(repo, ref, filePath, timeoutMs) {
   const repoPath = toRepoPath(repo);
   if (!repoPath) {
     return { ok: false, error: "Invalid GitHub repository format" };
   }
-  try {
-    const data = await ofetch(
-      `https://raw.githubusercontent.com/${repoPath}/${encodeURIComponent(ref)}/${encodeGitHubPath(filePath)}`,
-      {
-        ...githubFetchOptions(timeoutMs),
-        responseType: "text"
-      }
-    );
-    return { ok: true, data };
-  } catch (error) {
-    const status = typeof error === "object" && error && "status" in error ? Number(error.status) : void 0;
-    return {
-      ok: false,
-      status,
-      error: error.message
-    };
-  }
+  return await memoize(githubFileTextCache, `${repoPath}::${ref}::${filePath}`, async () => {
+    try {
+      const data = await ofetch(
+        `https://raw.githubusercontent.com/${repoPath}/${encodeURIComponent(ref)}/${encodeGitHubPath(filePath)}`,
+        {
+          ...githubFetchOptions(timeoutMs),
+          responseType: "text"
+        }
+      );
+      return { ok: true, data };
+    } catch (error) {
+      const status = typeof error === "object" && error && "status" in error ? Number(error.status) : void 0;
+      return {
+        ok: false,
+        status,
+        error: error.message
+      };
+    }
+  });
 }
 
 function makeSkip(packageName, skillName, reason, sourceKind) {
@@ -1225,6 +1243,15 @@ function resolveRepositoryUrl(packageInfo) {
     repoUrl: normalizeHttpUrl(packageInfo.repository)
   };
 }
+function isImmutableRef(ref, version) {
+  if (!ref) {
+    return false;
+  }
+  if (version && (ref === version || ref === `v${version}`)) {
+    return true;
+  }
+  return /^[a-f0-9]{7,40}$/i.test(ref);
+}
 async function materializeCandidate(packageInfo, candidate, cacheRoot) {
   const targetDir = join(
     cacheRoot,
@@ -1232,8 +1259,24 @@ async function materializeCandidate(packageInfo, candidate, cacheRoot) {
     sanitizeSegment(candidate.sourceRepo),
     sanitizeSegment(candidate.sourceRef),
     sanitizeSegment(packageInfo.packageName),
+    sanitizeSegment(packageInfo.version || "unknown"),
     sanitizeSegment(candidate.skillName)
   );
+  const skillFilePath = join(targetDir, "SKILL.md");
+  if (isImmutableRef(candidate.sourceRef, packageInfo.version) && await pathExists(skillFilePath)) {
+    return normalizeContribution({
+      packageName: packageInfo.packageName,
+      version: packageInfo.version,
+      skillName: candidate.skillName,
+      sourceKind: candidate.sourceKind,
+      sourceRepo: candidate.sourceRepo,
+      sourceRef: candidate.sourceRef,
+      sourcePath: candidate.sourcePath,
+      official: candidate.official,
+      resolver: candidate.resolver,
+      forceIncludeScripts: true
+    }, targetDir, join(targetDir, ".."));
+  }
   try {
     await downloadTemplate(`gh:${candidate.sourceRepo}/${candidate.sourcePath}#${candidate.sourceRef}`, {
       dir: targetDir,
@@ -1245,7 +1288,7 @@ async function materializeCandidate(packageInfo, candidate, cacheRoot) {
   } catch {
     return null;
   }
-  if (!await pathExists(join(targetDir, "SKILL.md"))) {
+  if (!await pathExists(skillFilePath)) {
     return null;
   }
   return normalizeContribution({
@@ -1276,10 +1319,7 @@ async function resolveViaGitHub(packageInfo, cacheRoot, timeoutMs) {
   const refs = dedupe([
     override?.ref || "",
     packageInfo.version ? `v${packageInfo.version}` : "",
-    packageInfo.version || "",
-    await fetchGitHubDefaultBranch(repo, timeoutMs) || "",
-    "main",
-    "master"
+    packageInfo.version || ""
   ]);
   const candidates = dedupe([
     override?.skillName || "",
@@ -1295,7 +1335,7 @@ async function resolveViaGitHub(packageInfo, cacheRoot, timeoutMs) {
       ];
     })
   ]);
-  for (const ref of refs) {
+  const tryResolveForRef = async (ref, allowTreeLookup) => {
     const packageJson = await fetchGitHubFileText(repo, ref, "package.json", timeoutMs);
     if (packageJson.ok && packageJson.data) {
       try {
@@ -1313,13 +1353,16 @@ async function resolveViaGitHub(packageInfo, cacheRoot, timeoutMs) {
             resolver: "agentsField"
           }, cacheRoot);
           if (resolved) {
-            return { contributions: [resolved], issues, skipped };
+            return [resolved];
           }
         }
       } catch {
         issues.push(createValidationIssue(packageInfo.packageName, packageInfo.packageName, "Failed to parse remote package.json", "github"));
       }
     }
+    if (!allowTreeLookup) {
+      return null;
+    }
     const skillsDirs = await listGitHubDirectory(repo, ref, "skills", timeoutMs);
     if (skillsDirs.length) {
       const contributions = [];
@@ -1338,7 +1381,7 @@ async function resolveViaGitHub(packageInfo, cacheRoot, timeoutMs) {
         }
       }
       if (contributions.length) {
-        return { contributions, issues, skipped };
+        return contributions;
       }
     }
     for (const path of pathCandidates) {
@@ -1353,9 +1396,33 @@ async function resolveViaGitHub(packageInfo, cacheRoot, timeoutMs) {
         resolver: "githubHeuristic"
       }, cacheRoot);
       if (resolved) {
-        return { contributions: [resolved], issues, skipped };
+        return [resolved];
       }
     }
+    return null;
+  };
+  for (const ref of refs) {
+    const resolved = await tryResolveForRef(ref, false);
+    if (resolved?.length) {
+      return { contributions: resolved, issues, skipped };
+    }
+  }
+  const fallbackRefs = dedupe([
+    await fetchGitHubDefaultBranch(repo, timeoutMs) || "",
+    "main",
+    "master"
+  ]);
+  for (const ref of fallbackRefs) {
+    const resolved = await tryResolveForRef(ref, true);
+    if (resolved?.length) {
+      return { contributions: resolved, issues, skipped };
+    }
+  }
+  for (const ref of refs) {
+    const resolved = await tryResolveForRef(ref, true);
+    if (resolved?.length) {
+      return { contributions: resolved, issues, skipped };
+    }
   }
   skipped.push(makeSkip(packageInfo.packageName, override?.skillName || packageInfo.packageName, "No GitHub skill found using configured refs and path heuristics", "github"));
   return {
@@ -1380,8 +1447,31 @@ async function resolveViaMetadataRouter(packageInfo, cacheRoot) {
     "generated",
     "metadata-router",
     sanitizeSegment(packageInfo.packageName),
+    sanitizeSegment(packageInfo.version || "unknown"),
     sanitizeSegment(skillName)
   );
+  const skillFilePath = join(targetDir, "SKILL.md");
+  if (await pathExists(skillFilePath)) {
+    return {
+      contributions: [
+        normalizeContribution({
+          packageName: packageInfo.packageName,
+          version: packageInfo.version,
+          skillName,
+          description: packageInfo.description,
+          sourceKind: "generated",
+          sourceRepo,
+          repoUrl,
+          docsUrl,
+          official: true,
+          resolver: "metadataRouter",
+          forceIncludeScripts: false
+        }, targetDir, join(targetDir, ".."))
+      ],
+      issues: [],
+      skipped: []
+    };
+  }
   const files = createMetadataRouterSkillFiles({
     packageName: packageInfo.packageName,
     skillName,
@@ -1613,6 +1703,7 @@ async function isGeneratedSkillFresh(generatedSkillRoot, fingerprint) {
 }
 
 const GITHUB_LOOKUP_TIMEOUT_MS = 1500;
+const REMOTE_RESOLUTION_CONCURRENCY = 4;
 function resolveStableSkillBuildDir(rootDir, buildDir) {
   const rel = relative(resolve(rootDir), resolve(buildDir)).replaceAll("\\", "/");
   if (rel === ".nuxt" || rel.startsWith(".nuxt/")) {
@@ -1630,6 +1721,30 @@ function normalizeRelativePath(from, to) {
 function getGeneratedSkillRoot(buildDir, skillName) {
   return join(buildDir, "skill-hub", skillName);
 }
+function getPersistentCacheRoot(exportRoot) {
+  return join(exportRoot, "node_modules", ".cache", "nuxt-skill-hub");
+}
+function getCachedGeneratedSkillRoot(cacheRoot, skillName) {
+  return join(cacheRoot, "generated", skillName);
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+  if (!items.length) {
+    return [];
+  }
+  const results = [];
+  let nextIndex = 0;
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (true) {
+      const index = nextIndex++;
+      if (index >= items.length) {
+        return;
+      }
+      results[index] = await mapper(items[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
 function mergeSkipped(entries, keyFn) {
   const byKey = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -1706,6 +1821,8 @@ async function ensureStableSkillWrappers(input) {
 async function generateSkillTree(input) {
   const { nuxt, logger, options, skillName, exportRoot, generationMode } = input;
   const stableBuildDir = resolveStableSkillBuildDir(nuxt.options.rootDir, nuxt.options.buildDir);
+  const persistentCacheRoot = getPersistentCacheRoot(exportRoot);
+  const cachedGeneratedSkillRoot = getCachedGeneratedSkillRoot(persistentCacheRoot, skillName);
   const generatedSkillRoot = getGeneratedSkillRoot(stableBuildDir, skillName);
   const referencesRoot = join(generatedSkillRoot, "references");
   const nuxtRoot = join(referencesRoot, "nuxt");
@@ -1739,26 +1856,32 @@ async function generateSkillTree(input) {
       ...sortAndDedupeContributions(resolvedManual)
     ])
   });
-  if (generationMode === "prepare" && await isGeneratedSkillFresh(generatedSkillRoot, fingerprint)) {
-    logger.info(`Generated ${skillName} skill is already up to date at ${generatedSkillRoot}`);
+  if (generationMode === "prepare" && await isGeneratedSkillFresh(cachedGeneratedSkillRoot, fingerprint)) {
+    await copySkillTree(cachedGeneratedSkillRoot, generatedSkillRoot, true);
+    logger.info(`Restored cached ${skillName} skill from ${cachedGeneratedSkillRoot}`);
     return;
   }
   const distResolvedPackages = new Set(discoveredContributions.contributions.map((item) => item.packageName));
   const remoteIssues = [];
   const remoteSkipped = [];
   const remoteContributions = [];
-  const remoteCacheRoot = join(stableBuildDir, "skill-hub-cache");
-  await emptyDir(remoteCacheRoot);
+  const remoteCacheRoot = join(persistentCacheRoot, "remote");
+  await ensureDir(remoteCacheRoot);
   const packagesToResolve = installedPackages.filter((pkg) => pkg.packageName !== "nuxt-skill-hub" && !distResolvedPackages.has(pkg.packageName));
   const totalToResolve = packagesToResolve.length;
-  for (let i = 0; i < packagesToResolve.length; i++) {
-    const pkg = packagesToResolve[i];
-    logger.start(`[${i + 1}/${totalToResolve}] Resolving skills for ${pkg.packageName}...`);
-    const remote = await resolveRemoteContributionsForPackage(pkg, {
-      cacheRoot: remoteCacheRoot,
-      githubLookupTimeoutMs: GITHUB_LOOKUP_TIMEOUT_MS,
-      enableGithubLookup: true
-    });
+  const remoteResults = await mapWithConcurrency(
+    packagesToResolve,
+    REMOTE_RESOLUTION_CONCURRENCY,
+    async (pkg, index) => {
+      logger.start(`Resolving skills for ${pkg.packageName} (${index + 1}/${totalToResolve})...`);
+      return await resolveRemoteContributionsForPackage(pkg, {
+        cacheRoot: remoteCacheRoot,
+        githubLookupTimeoutMs: GITHUB_LOOKUP_TIMEOUT_MS,
+        enableGithubLookup: true
+      });
+    }
+  );
+  for (const remote of remoteResults) {
     remoteIssues.push(...remote.issues);
     remoteSkipped.push(...remote.skipped);
     remoteContributions.push(...remote.contributions);
@@ -1841,14 +1964,56 @@ async function generateSkillTree(input) {
     skipped
   ));
   await writeGenerationState(generatedSkillRoot, fingerprint);
+  await copySkillTree(generatedSkillRoot, cachedGeneratedSkillRoot, true);
   logger.success(`Generated ${skillName} skill at ${generatedSkillRoot}`);
 }
 
 function isCancelled(value) {
   return value === null || typeof value === "symbol";
 }
+const AI_AGENT_TARGET_MAP = {
+  codex: "codex",
+  claude: "claude-code",
+  gemini: "gemini-code-assist",
+  replit: "replit-agent"
+};
+function resolveAIGuidanceTarget(currentTarget, detectedAgent) {
+  if (currentTarget) {
+    return currentTarget;
+  }
+  if (!detectedAgent) {
+    return void 0;
+  }
+  return AI_AGENT_TARGET_MAP[detectedAgent];
+}
+function buildAIGuidance(currentTarget, detectedAgent) {
+  const target = resolveAIGuidanceTarget(currentTarget, detectedAgent);
+  const sourceLabel = detectedAgent ? ` (${detectedAgent})` : "";
+  const snippetLines = [
+    "export default defineNuxtConfig({",
+    "  skillHub: {",
+    ...target ? [`    targets: ['${target}'],`] : [],
+    `    generationMode: 'prepare',`,
+    "  },",
+    "})"
+  ];
+  return {
+    intro: `Install wizard skipped because nuxt-skill-hub was installed by an AI agent${sourceLabel}. Add this to your nuxt.config.ts:`,
+    snippet: snippetLines.join("\n"),
+    optionalFlags: target ? "Optional flags: set `skillHub.skillName`, enable `skillHub.moduleAuthoring`, or switch to `skillHub.generationMode: 'manual'` if needed." : "Optional flags: add `skillHub.targets` to pin an agent target, set `skillHub.skillName`, enable `skillHub.moduleAuthoring`, or switch to `skillHub.generationMode: 'manual'` if needed."
+  };
+}
 async function runInstallWizard(nuxt) {
   const logger = useLogger("nuxt-skill-hub");
+  if (isAgent) {
+    const guidance = buildAIGuidance(detectCurrentTarget(), agent);
+    logger.info(guidance.intro);
+    logger.info(`\`\`\`ts
+${guidance.snippet}
+\`\`\``);
+    logger.info(guidance.optionalFlags);
+    return;
+  }
   if (process.env.CI || !process.stdout.isTTY) {
     logger.info("Non-interactive environment detected, skipping install wizard.");
     return;
@@ -2005,6 +2170,49 @@ Configure \`skillHub.skillName\`, \`skillHub.targets\`, or set \`skillHub.genera
   );
 }
 
+function createAutoImportAddon(nuxt) {
+  let unimport;
+  let nitroUnimport;
+  const hook = nuxt.hook;
+  hook("imports:context", (context) => {
+    unimport = context;
+  });
+  hook("nitro:init", (nitro) => {
+    nitroUnimport = nitro.unimport;
+  });
+  hook("eslint:config:addons", (addons) => {
+    addons.push({
+      name: "skill-hub:no-redundant-import",
+      async getConfigs() {
+        const imports = [
+          ...await unimport?.getImports() || [],
+          ...await nitroUnimport?.getImports() || []
+        ];
+        const seen = /* @__PURE__ */ new Set();
+        const entries = imports.filter((i) => {
+          const key = `${i.as || i.name}:${i.from}:${i.type ? "type" : "value"}`;
+          if (seen.has(key)) return false;
+          seen.add(key);
+          return true;
+        }).map((i) => ({ name: i.name, ...i.as && i.as !== i.name ? { as: i.as } : {}, from: i.from, ...i.type ? { type: true } : {} })).sort((a, b) => a.from.localeCompare(b.from) || a.name.localeCompare(b.name));
+        return {
+          imports: [{ from: "nuxt-skill-hub/eslint-plugin", name: "default", as: "skillHubPlugin" }],
+          configs: [
+            [
+              "{",
+              `  name: 'skill-hub/no-redundant-import',`,
+              `  plugins: { 'skill-hub': skillHubPlugin },`,
+              `  settings: { 'skill-hub/autoImports': ${JSON.stringify(entries)} },`,
+              `  rules: { 'skill-hub/no-redundant-import': 'warn' },`,
+              "}"
+            ].join("\n")
+          ]
+        };
+      }
+    });
+  });
+}
+
 const module$1 = defineNuxtModule({
   meta: {
     name: "nuxt-skill-hub",
@@ -2025,6 +2233,8 @@ const module$1 = defineNuxtModule({
   },
   async setup(options, nuxt) {
     const logger = useLogger("nuxt-skill-hub");
+    if (options.eslint !== false)
+      createAutoImportAddon(nuxt);
     if (isCI && !isTest) {
       logger.info("Skipping skill generation in CI");
       return;

package/dist/runtime/eslint/no-redundant-import.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const noRedundantImport: Rule.RuleModule;

package/dist/runtime/eslint/no-redundant-import.js

@@ -0,0 +1,114 @@
+const SETTINGS_KEY = "skill-hub/autoImports";
+export const noRedundantImport = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow explicit imports of auto-imported identifiers in Nuxt"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      redundant: "'{{ name }}' is auto-imported by Nuxt. Remove this explicit import."
+    }
+  },
+  create(context) {
+    const entries = context.settings[SETTINGS_KEY];
+    if (!entries?.length)
+      return {};
+    const lookup = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const localName = entry.as || entry.name;
+      const existing = lookup.get(entry.from) || { type: /* @__PURE__ */ new Map(), value: /* @__PURE__ */ new Map() };
+      addAutoImportName(existing[entry.type ? "type" : "value"], localName, entry.name);
+      lookup.set(entry.from, existing);
+    }
+    return {
+      ImportDeclaration(node) {
+        const importNode = node;
+        if (!importNode.specifiers.length) return;
+        const source = typeof importNode.source.value === "string" ? importNode.source.value : void 0;
+        if (!source) return;
+        const autoImported = lookup.get(source);
+        if (!autoImported) return;
+        if (isDeclarationFile(context.filename)) return;
+        const specInfos = [];
+        for (const spec of importNode.specifiers) {
+          if (spec.type !== "ImportSpecifier") {
+            specInfos.push({ spec, localName: "", isRedundant: false });
+            continue;
+          }
+          const localName = spec.local.name;
+          const names = isTypeOnlyImport(importNode, spec) ? autoImported.type : autoImported.value;
+          const importedName = getImportedName(spec);
+          specInfos.push({ spec, localName, isRedundant: importedName ? names.get(localName)?.has(importedName) === true : false });
+        }
+        const redundant = specInfos.filter((s) => s.isRedundant);
+        if (!redundant.length) return;
+        const kept = specInfos.filter((s) => !s.isRedundant);
+        const sourceText = context.sourceCode.getText();
+        if (!kept.length) {
+          context.report({
+            node: importNode,
+            messageId: "redundant",
+            data: { name: redundant.map((s) => s.localName).join(", ") },
+            fix: (fixer) => fixer.removeRange(importRemovalRange(sourceText, importNode.range))
+          });
+          return;
+        }
+        context.report({
+          node: importNode,
+          messageId: "redundant",
+          data: { name: redundant.map((s) => s.localName).join(", ") },
+          fix: (fixer) => fixer.replaceText(importNode, rebuildImportDeclaration(context, importNode, kept))
+        });
+      }
+    };
+  }
+};
+function isDeclarationFile(filename) {
+  return /\.d\.(?:cts|mts|ts)$/.test(filename);
+}
+function importRemovalRange(text, range) {
+  let end = range[1];
+  while (text[end] === " " || text[end] === "	") {
+    end++;
+  }
+  if (text.startsWith("\r\n", end)) {
+    return [range[0], end + 2];
+  }
+  if (text[end] === "\n") {
+    return [range[0], end + 1];
+  }
+  return [range[0], end];
+}
+function isTypeOnlyImport(node, spec) {
+  return node.importKind === "type" || spec.importKind === "type";
+}
+function addAutoImportName(lookup, localName, importedName) {
+  const importedNames = lookup.get(localName) || /* @__PURE__ */ new Set();
+  importedNames.add(importedName);
+  lookup.set(localName, importedNames);
+}
+function getImportedName(spec) {
+  return typeof spec.imported.name === "string" ? spec.imported.name : typeof spec.imported.value === "string" ? spec.imported.value : void 0;
+}
+function rebuildImportDeclaration(context, node, kept) {
+  const defaultSpecifiers = kept.filter(({ spec }) => spec.type === "ImportDefaultSpecifier");
+  const namespaceSpecifiers = kept.filter(({ spec }) => spec.type === "ImportNamespaceSpecifier");
+  const namedSpecifiers = kept.filter(({ spec }) => spec.type === "ImportSpecifier").map(({ spec }) => spec);
+  const useTypeKeyword = node.importKind !== "type" && !defaultSpecifiers.length && !namespaceSpecifiers.length && namedSpecifiers.length > 0 && namedSpecifiers.every((spec) => spec.importKind === "type");
+  const specifierTexts = [
+    ...defaultSpecifiers.map(({ spec }) => context.sourceCode.getText(spec)),
+    ...namespaceSpecifiers.map(({ spec }) => context.sourceCode.getText(spec))
+  ];
+  if (namedSpecifiers.length) {
+    const namedTexts = namedSpecifiers.map((spec) => {
+      const text = context.sourceCode.getText(spec);
+      return useTypeKeyword ? text.replace(/^type\s+/, "") : text;
+    });
+    specifierTexts.push(`{ ${namedTexts.join(", ")} }`);
+  }
+  const sourceRange = node.source.range;
+  const suffix = context.sourceCode.text.slice(sourceRange[1], node.range[1]);
+  return `import${node.importKind === "type" || useTypeKeyword ? " type" : ""} ${specifierTexts.join(", ")} from ${context.sourceCode.getText(node.source)}${suffix}`;
+}

package/dist/runtime/eslint/plugin.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-redundant-import': import("eslint").Rule.RuleModule;
+    };
+};
+export default _default;

package/dist/runtime/eslint/plugin.js

@@ -0,0 +1,5 @@
+import { noRedundantImport } from "./no-redundant-import.js";
+export default {
+  meta: { name: "skill-hub" },
+  rules: { "no-redundant-import": noRedundantImport }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-skill-hub",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Teach your AI agent the Nuxt way with best practices and module guidance.",
   "repository": {
     "type": "git",
@@ -13,6 +13,9 @@
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs",
       "default": "./dist/module.mjs"
+    },
+    "./eslint-plugin": {
+      "import": "./dist/runtime/eslint/plugin.js"
     }
   },
   "main": "./dist/module.mjs",