@seojin08/skill-finder 0.0.0-stage → 0.3.3

package/server/src/discovery/genericRules.js

@@ -0,0 +1,182 @@
+import { basename, joinPath, skillMdPath } from "./tree.js";
+// Mirrors skills CLI 1.7.6 src/skills.ts (discoverSkills) so that what we list is what `skills add --skill` can install.
+// Unchanged since 1.7.4 except two things not mirrored: extra search dirs a repo can list in skills.sh.json (`paths`),
+// and skipping a skill whose name or description is empty once control characters are removed.
+export const SKIP_DIRS = ['node_modules', '.git', 'dist', 'build', '__pycache__'];
+export const AGENT_PROJECT_SKILL_DIRS = [
+    '.agents/skills',
+    '.claude/skills',
+    '.cline/skills',
+    '.codebuddy/skills',
+    '.codex/skills',
+    '.commandcode/skills',
+    '.continue/skills',
+    '.factory/skills',
+    '.github/skills',
+    '.goose/skills',
+    '.grok/skills',
+    '.iflow/skills',
+    '.junie/skills',
+    '.kilo/skills',
+    '.kilocode/skills',
+    '.kimchi/skills',
+    '.kiro/skills',
+    '.minimax/skills',
+    '.mux/skills',
+    '.neovate/skills',
+    '.opencode/skills',
+    '.openhands/skills',
+    '.pi/skills',
+    '.posit/assistant/skills',
+    '.qoder/skills',
+    '.roo/skills',
+    '.trae/skills',
+    '.windsurf/skills',
+    '.zcode/skills',
+    '.zencoder/skills',
+];
+/**
+ * Candidate skill folders in priority order: root children (depth 1), then `skills/`, `skills/.curated`,
+ * `skills/.experimental`, `skills/.system` and agent project folders (depth 3). Does not descend below a
+ * folder that has SKILL.md. The root SKILL.md case is handled by the caller.
+ */
+export function priorityCandidateDirs(tree, base = '') {
+    const priority = [
+        base,
+        joinPath(base, 'skills'),
+        joinPath(base, 'skills/.curated'),
+        joinPath(base, 'skills/.experimental'),
+        joinPath(base, 'skills/.system'),
+        ...AGENT_PROJECT_SKILL_DIRS.map((d) => joinPath(base, d)),
+    ];
+    const deep = new Set(priority.slice(1));
+    const seen = new Set();
+    const out = [];
+    const walk = (dir, maxDepth, depth) => {
+        if (!tree.hasDir(dir))
+            return;
+        for (const child of tree.childDirs(dir)) {
+            if (tree.hasFile(skillMdPath(child))) {
+                if (!seen.has(child)) {
+                    seen.add(child);
+                    out.push(child);
+                }
+                continue;
+            }
+            if (depth >= maxDepth || SKIP_DIRS.includes(basename(child)))
+                continue;
+            walk(child, maxDepth, depth + 1);
+        }
+    };
+    for (const dir of priority)
+        walk(dir, deep.has(dir) ? 3 : 1, 1);
+    return out;
+}
+/** Fallback full recursion (max depth 5 from base) used when the priority scan found no valid skill. */
+export function recursiveCandidateDirs(tree, base = '', maxDepth = 5) {
+    const out = [];
+    const visit = (dir, depth) => {
+        if (depth > maxDepth)
+            return;
+        if (tree.hasFile(skillMdPath(dir)))
+            out.push(dir);
+        for (const child of tree.childDirs(dir)) {
+            if (SKIP_DIRS.includes(basename(child)))
+                continue;
+            visit(child, depth + 1);
+        }
+    };
+    visit(base, 0);
+    return out;
+}
+/**
+ * Generic repository mode. A SKILL.md needs a string name and description (as in the CLI);
+ * same-name skills keep only the first one.
+ */
+export async function discoverGenericSkills(tree, read, validate, opts = {}) {
+    const maxFetch = opts.maxFetch ?? 300;
+    if (tree.hasFile('SKILL.md')) {
+        const raw = await read('SKILL.md');
+        const v = raw != null ? validate(raw) : null;
+        if (raw != null && v)
+            return [{ dirPath: '', name: v.name, raw }];
+    }
+    const collect = async (dirs) => {
+        const limited = dirs.slice(0, maxFetch);
+        const raws = await Promise.all(limited.map((d) => read(skillMdPath(d))));
+        const seen = new Set();
+        const out = [];
+        limited.forEach((dirPath, i) => {
+            const raw = raws[i];
+            const v = raw != null ? validate(raw) : null;
+            if (raw == null || !v || seen.has(v.name))
+                return;
+            seen.add(v.name);
+            out.push({ dirPath, name: v.name, raw });
+        });
+        return out;
+    };
+    const found = await collect(priorityCandidateDirs(tree));
+    if (found.length > 0)
+        return found;
+    return collect(recursiveCandidateDirs(tree).filter((d) => d !== ''));
+}
+/**
+ * Same decision as {@link discoverGenericSkills} for one folder at a time, so looking up a single skill
+ * in a repo with hundreds of them reads a handful of SKILL.md files instead of all of them:
+ * a valid root SKILL.md hides everything else; a priority folder counts if its own SKILL.md is valid;
+ * a deeper folder counts only when no priority folder holds a valid skill.
+ */
+export function genericAcceptor(tree, read, validate) {
+    const priority = priorityCandidateDirs(tree);
+    const prioritySet = new Set(priority);
+    const recursive = recursiveCandidateDirs(tree).filter((d) => d !== '');
+    const recursiveSet = new Set(recursive);
+    const hasRoot = tree.hasFile('SKILL.md');
+    const validRaw = async (dir) => {
+        const raw = await read(skillMdPath(dir));
+        return raw != null && validate(raw) ? raw : null;
+    };
+    let rootValid = null;
+    let anyPriorityValid = null;
+    const priorityHasValid = async () => {
+        // Usually the first folder is valid, so check a few at a time and stop early.
+        for (let i = 0; i < priority.length; i += 4) {
+            const raws = await Promise.all(priority.slice(i, i + 4).map(validRaw));
+            if (raws.some(Boolean))
+                return true;
+        }
+        return false;
+    };
+    // Same-name skills keep only the first one in scan order. Checking every earlier folder would mean
+    // reading them all; copies almost always sit in a folder named after the skill, so check those.
+    const firstWithName = async (tier, dir, raw) => {
+        if (raw == null)
+            return null;
+        const name = validate(raw).name;
+        for (const other of tier.slice(0, tier.indexOf(dir))) {
+            if (basename(other) !== name)
+                continue;
+            const earlier = await validRaw(other);
+            if (earlier != null && validate(earlier).name === name)
+                return null;
+        }
+        return raw;
+    };
+    return {
+        candidates: [...(hasRoot ? [''] : []), ...priority, ...recursive.filter((d) => !prioritySet.has(d))],
+        async accepts(dir) {
+            if (hasRoot) {
+                rootValid ??= validRaw('').then(Boolean);
+                if (await rootValid)
+                    return dir === '' ? read('SKILL.md') : null;
+            }
+            if (prioritySet.has(dir))
+                return firstWithName(priority, dir, await validRaw(dir));
+            if (!recursiveSet.has(dir))
+                return null;
+            anyPriorityValid ??= priorityHasValid();
+            return (await anyPriorityValid) ? null : firstWithName(recursive, dir, await validRaw(dir));
+        },
+    };
+}

package/server/src/discovery/pluginRules.js

@@ -0,0 +1,59 @@
+import { joinPath, resolveRel, skillMdPath } from "./tree.js";
+const COMPONENT_FIELDS = ['commands', 'agents', 'skills', 'hooks', 'mcpServers', 'lspServers', 'outputStyles', 'monitors'];
+export function hasComponentFields(obj) {
+    return !!obj && COMPONENT_FIELDS.some((k) => obj[k] != null);
+}
+const toPathList = (v) => typeof v === 'string' ? [v] : Array.isArray(v) ? v.filter((x) => typeof x === 'string') : [];
+/**
+ * Skill folders of one plugin (Claude Code plugin manifest rules):
+ * - default `skills/<name>/SKILL.md`
+ * - plugin.json `skills` and marketplace entry `skills` add to the default scan; each path is either a folder
+ *   holding SKILL.md or a folder of `<name>/SKILL.md` bundles
+ * - a root SKILL.md is a single-skill plugin when there is no `skills/` folder and no `skills` key
+ * - an entry whose source is the marketplace root and lists `skills` loads only that list
+ */
+export function discoverPluginSkills(tree, root, manifest, entry, opts = {}) {
+    const dirs = new Set();
+    const addPath = (rel) => {
+        const abs = resolveRel(root, rel);
+        if (abs == null)
+            return;
+        if (tree.hasFile(skillMdPath(abs))) {
+            dirs.add(abs);
+            return;
+        }
+        for (const child of tree.childDirs(abs))
+            if (tree.hasFile(skillMdPath(child)))
+                dirs.add(child);
+    };
+    const entrySkills = toPathList(entry?.skills);
+    if (opts.entryAtMarketplaceRoot && entrySkills.length > 0) {
+        for (const p of entrySkills)
+            addPath(p);
+    }
+    else {
+        const defaultDir = joinPath(root, 'skills');
+        for (const child of tree.childDirs(defaultDir))
+            if (tree.hasFile(skillMdPath(child)))
+                dirs.add(child);
+        for (const p of toPathList(manifest?.skills))
+            addPath(p);
+        for (const p of entrySkills)
+            addPath(p);
+        const noSkillsKey = manifest?.skills == null && entry?.skills == null;
+        if (tree.hasFile(skillMdPath(root)) && !tree.hasDir(defaultDir) && noSkillsKey)
+            dirs.add(root);
+    }
+    const experimental = (manifest?.experimental ?? null);
+    const signals = {
+        hooks: tree.hasFile(joinPath(root, 'hooks/hooks.json')) || manifest?.hooks != null || entry?.hooks != null,
+        mcp: tree.hasFile(joinPath(root, '.mcp.json')) || manifest?.mcpServers != null || entry?.mcpServers != null,
+        bin: tree.hasDir(joinPath(root, 'bin')) && tree.dirHasAnyFile(joinPath(root, 'bin')),
+        monitors: tree.hasFile(joinPath(root, 'monitors/monitors.json')) ||
+            experimental?.monitors != null ||
+            manifest?.monitors != null ||
+            entry?.monitors != null,
+    };
+    const strictConflict = entry?.strict === false && hasComponentFields(manifest) && hasComponentFields(entry);
+    return { root, skillDirs: [...dirs].sort(), signals, strictConflict };
+}

package/server/src/discovery/tree.js

@@ -0,0 +1,79 @@
+/** Read-only view over a repository's blob paths with directory helpers. */
+export class TreeIndex {
+    files;
+    children = new Map();
+    constructor(entries) {
+        this.files = new Map();
+        this.children.set('', new Set());
+        for (const e of entries) {
+            const path = e.path.replace(/^\/+/, '');
+            this.files.set(path, { size: e.size ?? null, sha: e.sha ?? null });
+            const parts = path.split('/');
+            let dir = '';
+            for (let i = 0; i < parts.length - 1; i++) {
+                const child = dir ? `${dir}/${parts[i]}` : parts[i];
+                let set = this.children.get(dir);
+                if (!set)
+                    this.children.set(dir, (set = new Set()));
+                set.add(parts[i]);
+                if (!this.children.has(child))
+                    this.children.set(child, new Set());
+                dir = child;
+            }
+        }
+    }
+    hasFile(path) {
+        return this.files.has(path);
+    }
+    hasDir(path) {
+        return path === '' || this.children.has(path);
+    }
+    /** Immediate child directory paths, sorted. */
+    childDirs(dir) {
+        const names = [...(this.children.get(dir) ?? [])].sort();
+        return names.map((n) => (dir ? `${dir}/${n}` : n));
+    }
+    /** Files under a directory, as paths relative to it. */
+    filesUnder(dir) {
+        const prefix = dir ? `${dir}/` : '';
+        const out = [];
+        for (const [path, info] of this.files)
+            if (path.startsWith(prefix))
+                out.push({ path: path.slice(prefix.length), ...info });
+        return out.sort((a, b) => a.path.localeCompare(b.path));
+    }
+    dirHasAnyFile(dir) {
+        const prefix = dir ? `${dir}/` : '';
+        for (const path of this.files.keys())
+            if (path.startsWith(prefix))
+                return true;
+        return false;
+    }
+}
+export const joinPath = (...parts) => parts.filter((p) => p !== '' && p !== '.').join('/');
+export const skillMdPath = (dir) => joinPath(dir, 'SKILL.md');
+export const basename = (p) => p.split('/').pop() ?? p;
+/**
+ * Normalizes a manifest-relative path ("./skills/x", ".", "skills/x/") against a base directory.
+ * Returns null when the path escapes the base or is absolute.
+ */
+export function resolveRel(base, rel) {
+    if (typeof rel !== 'string')
+        return null;
+    if (/^([a-zA-Z]:|\/|\\)/.test(rel))
+        return null;
+    const out = base ? base.split('/') : [];
+    const depthFloor = out.length;
+    for (const seg of rel.replace(/\\/g, '/').split('/')) {
+        if (seg === '' || seg === '.')
+            continue;
+        if (seg === '..') {
+            if (out.length <= depthFloor)
+                return null;
+            out.pop();
+            continue;
+        }
+        out.push(seg);
+    }
+    return out.join('/');
+}

package/server/src/index.js

@@ -0,0 +1,55 @@
+import { config, ensureDataDirs } from "./config.js";
+import { createApp } from "./app.js";
+import { openContext } from "./bootstrap.js";
+import { DataTooNewError } from "./db/index.js";
+import { startUpdateChecks } from "./update.js";
+import { startLogFile } from "./util/log.js";
+import { pruneSearchLog, recheckRiskRules, refreshRepoMeta, relevelRisk, REPO_META_EVERY_MS, startSync } from "./tasks.js";
+const HOST = '127.0.0.1';
+const DAY_MS = 24 * 60 * 60 * 1000;
+ensureDataDirs();
+startLogFile(config.dataDir, [config.githubToken]);
+// A background task that fails (a sync, a refresh) is logged, not fatal: Node would otherwise end the server.
+process.on('unhandledRejection', (reason) => console.error('[백그라운드 오류]', reason));
+process.on('uncaughtException', (err) => {
+    console.error('[치명적 오류]', err);
+    process.exit(1);
+});
+const ctx = (() => {
+    try {
+        return openContext(config);
+    }
+    catch (err) {
+        if (!(err instanceof DataTooNewError))
+            throw err;
+        console.error(err.message);
+        process.exit(1);
+    }
+})();
+const app = createApp(ctx);
+// Express' listen(port) binds 0.0.0.0; always pass the loopback host explicitly.
+const server = app.listen(config.port, HOST, () => {
+    console.log(`Skill Finder: http://${HOST}:${config.port}${config.dev ? ' (dev)' : ''}`);
+    console.log(`GitHub 토큰: ${config.githubToken ? '있음' : '없음 (GitHub 코드 검색 생략, 트리는 git으로 조회)'}`);
+    startSync(ctx);
+    setInterval(() => startSync(ctx), DAY_MS).unref();
+    pruneSearchLog(ctx);
+    setInterval(() => pruneSearchLog(ctx), DAY_MS).unref();
+    relevelRisk(ctx);
+    startUpdateChecks();
+    void recheckRiskRules(ctx);
+    setInterval(() => void recheckRiskRules(ctx), DAY_MS).unref();
+    void refreshRepoMeta(ctx);
+    setInterval(() => void refreshRepoMeta(ctx), REPO_META_EVERY_MS).unref();
+});
+server.on('error', (err) => {
+    console.error(err);
+    process.exit(1);
+});
+for (const sig of ['SIGINT', 'SIGTERM']) {
+    process.on(sig, () => {
+        server.close();
+        ctx.store.db.close();
+        process.exit(0);
+    });
+}