@klhapp/skillmux 0.2.0 → 0.4.2

package/src/types.ts

@@ -83,16 +83,23 @@ export interface RateLimitConfig {
   trust_proxy?: boolean;
 }
 
+export interface AdminConfig {
+  enabled: boolean;
+  token_env: string;
+}
+
 export interface ServerConfig {
   auth_enabled: boolean;
   auth_token_env: string;
   allowed_origins: string[];
   hostname?: string;
   rate_limit?: RateLimitConfig;
+  admin?: AdminConfig;
 }
 
 export interface Config {
   vault_path: string;
+  local_vault_paths: string[];
   state_dir: string;
   recall: RecallConfig;
   thresholds: Thresholds;

package/src/vault.ts

@@ -1,4 +1,4 @@
-import { readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
 
 export const SKILL_ID_PATTERN = /^[a-z0-9][a-z0-9-]{1,127}$/;
@@ -66,6 +66,64 @@ export async function scanVault(
   return skills;
 }
 
+/** Local overlays checked first (in order), canonical vault_path is the fallback. */
+export function vaultResolutionOrder(vaultPath: string, localVaultPaths: string[]): string[] {
+  return [...localVaultPaths, vaultPath];
+}
+
+/** Which configured root actually backs skillId, per local-overrides-first precedence. */
+export function resolveSkillRoot(skillId: string, vaultPath: string, localVaultPaths: string[]): string | null {
+  for (const root of vaultResolutionOrder(vaultPath, localVaultPaths)) {
+    if (existsSync(join(root, skillId, "SKILL.md"))) return root;
+  }
+  return null;
+}
+
+/** Scans every configured root and merges by skill_id — first-seen (per resolution order) wins. */
+export async function scanVaults(
+  vaultPath: string,
+  localVaultPaths: string[],
+  onInvalid?: (skillId: string, error: unknown) => void,
+): Promise<VaultSkill[]> {
+  const seen = new Set<string>();
+  const merged: VaultSkill[] = [];
+  for (const root of vaultResolutionOrder(vaultPath, localVaultPaths)) {
+    if (!existsSync(root)) continue;
+    for (const skill of await scanVault(root, onInvalid)) {
+      if (seen.has(skill.skill_id)) continue;
+      seen.add(skill.skill_id);
+      merged.push(skill);
+    }
+  }
+  return merged;
+}
+
+export interface ShadowedSkill {
+  skill_id: string;
+  winner: string;
+  shadowed: string[];
+}
+
+/** skill_ids present in more than one configured root — every root after the winner is silently shadowed. */
+export function findShadowedSkills(vaultPath: string, localVaultPaths: string[]): ShadowedSkill[] {
+  const rootsBySkillId = new Map<string, string[]>();
+  for (const root of vaultResolutionOrder(vaultPath, localVaultPaths)) {
+    if (!existsSync(root)) continue;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory() || !SKILL_ID_PATTERN.test(entry.name)) continue;
+      if (!existsSync(join(root, entry.name, "SKILL.md"))) continue;
+      const roots = rootsBySkillId.get(entry.name) ?? [];
+      roots.push(root);
+      rootsBySkillId.set(entry.name, roots);
+    }
+  }
+  const shadowed: ShadowedSkill[] = [];
+  for (const [skillId, roots] of rootsBySkillId) {
+    if (roots.length > 1) shadowed.push({ skill_id: skillId, winner: roots[0]!, shadowed: roots.slice(1) });
+  }
+  return shadowed.sort((a, b) => a.skill_id.localeCompare(b.skill_id));
+}
+
 /** Relative paths of everything under the skill dir except SKILL.md itself, sorted. */
 export function listSupportingFiles(vaultPath: string, skillId: string): string[] {
   const root = join(vaultPath, skillId);