@seojin08/skill-finder 0.0.0-stage → 0.3.2

package/server/src/db/index.js

@@ -0,0 +1,128 @@
+import { existsSync, readdirSync, renameSync, rmSync, statSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { MIGRATIONS } from "./schema.js";
+/** The data was written by a newer Skill Finder (UI debate D-6): an older one must not run on it. */
+export class DataTooNewError extends Error {
+    constructor(found, known) {
+        super(`이 데이터는 더 새 버전의 Skill Finder가 만들었습니다 (데이터 버전 ${found}, 이 앱은 ${known}까지). ` +
+            '새 버전의 Skill Finder를 실행하세요. 예전 버전으로 열면 데이터가 망가질 수 있어 시작하지 않습니다.');
+    }
+}
+/**
+ * Reading the database through a memory map halves the local search's SQL time (14 → 7ms, same results) at
+ * +0–5MB of private memory, where a 64MB page cache costs +35–40MB (perf debate 1-4). This SQLite build has no
+ * Windows structured exception handling, so a disk read error while mapped ends the process instead of failing
+ * one query: off for a network share, and SKILL_FINDER_MMAP=0 turns it off.
+ */
+export const MMAP_BYTES = 256 * 1024 * 1024;
+export function mmapBytesFor(path, env = process.env) {
+    if (env.SKILL_FINDER_MMAP === '0' || path === ':memory:' || /^(\\\\|\/\/)/.test(path))
+        return 0;
+    return MMAP_BYTES;
+}
+/**
+ * `backupLabel`: names the copy made before a migration (`<db>.before-<label>.bak`, the app version), which the
+ * launcher puts back when a new version fails to start (project review #4).
+ */
+export function openDb(path, opts = {}) {
+    const db = new DatabaseSync(path);
+    try {
+        db.exec('PRAGMA journal_mode = WAL; PRAGMA foreign_keys = OFF; PRAGMA busy_timeout = 5000;');
+        const mmap = mmapBytesFor(path);
+        if (mmap > 0) {
+            db.exec(`PRAGMA mmap_size = ${mmap}`);
+            const got = db.prepare('PRAGMA mmap_size').get()?.mmap_size ?? 0;
+            if (got === 0)
+                console.warn('[db] mmap을 쓸 수 없어 일반 읽기로 엽니다');
+        }
+        migrate(db, path === ':memory:' ? undefined : (from) => backupBeforeMigration(db, path, opts.backupLabel || `v${from}`));
+    }
+    catch (err) {
+        // let go of the file, so a damaged one can be moved aside (Windows refuses to rename an open file)
+        db.close();
+        throw err;
+    }
+    return db;
+}
+/** `beforeMigrating`: called once, with the stored version, when an existing database is about to change. */
+export function migrate(db, beforeMigrating) {
+    const row = db.prepare('PRAGMA user_version').get();
+    if (row.user_version > MIGRATIONS.length)
+        throw new DataTooNewError(row.user_version, MIGRATIONS.length);
+    if (row.user_version > 0 && row.user_version < MIGRATIONS.length)
+        beforeMigrating?.(row.user_version);
+    for (let v = row.user_version; v < MIGRATIONS.length; v++) {
+        db.exec('BEGIN');
+        try {
+            db.exec(MIGRATIONS[v]);
+            db.exec(`PRAGMA user_version = ${v + 1}`);
+            db.exec('COMMIT');
+        }
+        catch (err) {
+            db.exec('ROLLBACK');
+            throw err;
+        }
+    }
+}
+const BACKUPS_KEPT = 2;
+const backupsOf = (path) => {
+    const dir = dirname(path);
+    const prefix = `${basename(path)}.before-`;
+    return readdirSync(dir)
+        .filter((f) => f.startsWith(prefix) && f.endsWith('.bak'))
+        .map((f) => ({ path: join(dir, f), at: statSync(join(dir, f)).mtimeMs }))
+        .sort((a, b) => b.at - a.at);
+};
+/** A copy of the database as it was before a newer version changes its tables; the two newest are kept. */
+export function backupBeforeMigration(db, path, label) {
+    const target = `${path}.before-${label.replace(/[^0-9A-Za-z._-]/g, '_')}.bak`;
+    try {
+        rmSync(target, { force: true });
+        db.exec(`VACUUM INTO '${target.replace(/'/g, "''")}'`);
+        for (const old of backupsOf(path).slice(BACKUPS_KEPT))
+            rmSync(old.path, { force: true });
+        console.log(`[db] 데이터 형식을 바꾸기 전에 백업했습니다: ${target}`);
+        return target;
+    }
+    catch (err) {
+        // a full disk must not stop the app from starting; the migration itself still runs in a transaction
+        console.warn('[db] 데이터 형식을 바꾸기 전 백업을 만들지 못했습니다:', err);
+        return null;
+    }
+}
+/** The newest backup made before a migration, if any. */
+export function latestBackup(path) {
+    try {
+        return backupsOf(path)[0]?.path ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** SQLite cannot read the file as a database (damaged, or not one). */
+export function isCorruptDb(err) {
+    const e = err;
+    return e?.errcode === 11 || e?.errcode === 26 || /malformed|not a database|SQLITE_CORRUPT|SQLITE_NOTADB/i.test(`${e?.code ?? ''} ${e?.message ?? ''}`);
+}
+/** Moves a damaged database and its -wal/-shm aside as `<db>.corrupt-<time>`, kept for a look; returns that name. */
+export function setAsideCorrupt(path) {
+    const target = `${path}.corrupt-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+    renameSync(path, target);
+    for (const ext of ['-wal', '-shm'])
+        if (existsSync(path + ext))
+            renameSync(path + ext, target + ext);
+    return target;
+}
+export function tx(db, fn) {
+    db.exec('BEGIN');
+    try {
+        const out = fn();
+        db.exec('COMMIT');
+        return out;
+    }
+    catch (err) {
+        db.exec('ROLLBACK');
+        throw err;
+    }
+}

package/server/src/db/schema.js

@@ -0,0 +1,95 @@
+// Each entry upgrades PRAGMA user_version by one. Never edit a released migration; append a new one.
+export const MIGRATIONS = [
+    `
+  CREATE TABLE marketplaces (name TEXT PRIMARY KEY, repo TEXT NOT NULL, enabled INTEGER NOT NULL DEFAULT 1,
+    index_mode TEXT NOT NULL CHECK (index_mode IN ('eager','lazy')), etag TEXT, synced_at TEXT, plugin_count INTEGER,
+    commit_sha TEXT, error TEXT);
+  CREATE TABLE plugins (id TEXT PRIMARY KEY /* name@marketplace */, marketplace TEXT NOT NULL, name TEXT NOT NULL,
+    display_name TEXT, description TEXT, category TEXT, keywords TEXT, source_json TEXT NOT NULL, source_kind TEXT NOT NULL,
+    repo TEXT, path TEXT, ref TEXT, sha TEXT, strict INTEGER, signals_json TEXT, skills_indexed_at TEXT, error TEXT,
+    skills_indexed_sha TEXT, entry_json TEXT);
+  CREATE INDEX plugins_marketplace ON plugins(marketplace);
+  CREATE TABLE repos (full_name TEXT PRIMARY KEY, stars INTEGER, pushed_at TEXT, archived INTEGER, fork INTEGER,
+    license TEXT, default_branch TEXT, etag TEXT, fetched_at TEXT);
+  CREATE TABLE skills (id TEXT PRIMARY KEY /* gh:{owner}/{repo}:{dirPath} */, origin TEXT NOT NULL /* plugin|generic|wellknown */,
+    plugin_id TEXT REFERENCES plugins(id), repo TEXT, ref TEXT, dir_path TEXT, name TEXT NOT NULL, description TEXT,
+    when_to_use TEXT, frontmatter_json TEXT, body_lines INTEGER, skill_md_sha256 TEXT, name_desc_sha256 TEXT,
+    installs INTEGER, quality_json TEXT, risk_json TEXT, risk_level TEXT, last_commit_at TEXT, fetched_at TEXT,
+    files_json TEXT, install_json TEXT);
+  CREATE INDEX skills_plugin ON skills(plugin_id);
+  CREATE INDEX skills_repo_name ON skills(repo, name);
+  CREATE VIRTUAL TABLE skills_fts USING fts5(skill_id UNINDEXED, name, description, when_to_use, plugin_text, tokenize='porter unicode61');
+  CREATE VIRTUAL TABLE plugins_fts USING fts5(plugin_id UNINDEXED, name, description, category, tokenize='porter unicode61');
+  CREATE TABLE search_cache (key TEXT PRIMARY KEY, created_at TEXT NOT NULL, payload_json TEXT NOT NULL);
+  CREATE TABLE install_log (id INTEGER PRIMARY KEY, skill_id TEXT, plugin_id TEXT, method TEXT, scope TEXT,
+    project_path TEXT, argv_json TEXT, exit_code INTEGER, output TEXT, created_at TEXT NOT NULL);
+  CREATE TABLE events (id INTEGER PRIMARY KEY, kind TEXT /* view|install */, skill_id TEXT, query TEXT, created_at TEXT);
+  CREATE TABLE settings (key TEXT PRIMARY KEY, value_json TEXT NOT NULL);
+  `,
+    // Repo lookups ignore case (GitHub names do); without these they scan the whole table (~35ms each).
+    `
+  CREATE INDEX skills_repo_nocase ON skills(repo COLLATE NOCASE);
+  CREATE INDEX repos_full_name_nocase ON repos(full_name COLLATE NOCASE);
+  `,
+    // One-word queries look up skills by repo name ("rea" → morluto/rea); a LIKE '%/rea' scan took ~48ms.
+    `
+  CREATE INDEX skills_repo_tail ON skills(lower(substr(repo, instr(repo, '/') + 1)));
+  `,
+    // Downloads keep the latest count and when it was seen; counts older than 30 days are not ranked on (U4).
+    // Counts stored before this have no time of their own: the row's fetch time is the best guess.
+    `
+  ALTER TABLE skills ADD COLUMN installs_at TEXT;
+  UPDATE skills SET installs_at = fetched_at WHERE installs IS NOT NULL;
+  `,
+    // Local search log (U5-2): details per event, and the 90-day pruning by kind and time.
+    `
+  ALTER TABLE events ADD COLUMN meta_json TEXT;
+  CREATE INDEX events_kind_created ON events(kind, created_at);
+  `,
+    // The risk-rules version a row was checked under (risk.ts RISK_RULES_VERSION); NULL = before versions (1).
+    `
+  ALTER TABLE skills ADD COLUMN risk_rules INTEGER;
+  `,
+    // What was installed (UI debate 3-3): the commit, SKILL.md hash and risk level at install time; installed skills
+    // are matched to the index by their SKILL.md hash.
+    `
+  ALTER TABLE install_log ADD COLUMN ref TEXT;
+  ALTER TABLE install_log ADD COLUMN skill_md_sha256 TEXT;
+  ALTER TABLE install_log ADD COLUMN risk_level TEXT;
+  CREATE INDEX skills_md_sha ON skills(skill_md_sha256);
+  `,
+    // Accounts on this PC and their favorite skills (user decision 2026-11-02). The password is a scrypt hash; the
+    // signed-in state is a signed cookie (auth.ts), so there is no session table. The skill's name is kept so a
+    // favorite whose skill left the index can still be listed and removed.
+    `
+  CREATE TABLE users (
+    id INTEGER PRIMARY KEY,
+    username TEXT NOT NULL UNIQUE COLLATE NOCASE,
+    password_hash TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE TABLE favorites (
+    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    skill_id TEXT NOT NULL,
+    skill_name TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (user_id, skill_id)
+  );
+  `,
+    // Favorites without accounts (user decision 2026-11-02): accounts kept only on this PC protected nothing, so the
+    // favorites of every account made so far become this PC's favorites (the earliest star of each skill), and the
+    // users table and the session key go.
+    `
+  CREATE TABLE favorites_local (
+    skill_id TEXT PRIMARY KEY,
+    skill_name TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  INSERT INTO favorites_local (skill_id, skill_name, created_at)
+    SELECT skill_id, MIN(skill_name), MIN(created_at) FROM favorites GROUP BY skill_id;
+  DROP TABLE favorites;
+  DROP TABLE users;
+  ALTER TABLE favorites_local RENAME TO favorites;
+  DELETE FROM settings WHERE key = 'sessionKey';
+  `,
+];

package/server/src/db/store.js

@@ -0,0 +1,353 @@
+import { existsSync } from 'node:fs';
+import { tx } from "./index.js";
+const now = () => new Date().toISOString();
+/** A long install output keeps its start and its end, where the error usually is (review 2026-11-02). */
+export function clipOutput(text, max = 20_000) {
+    if (text.length <= max)
+        return text;
+    const head = Math.floor(max / 5);
+    return `${text.slice(0, head)}\n…(중간 ${text.length - max}자 생략)…\n${text.slice(text.length - (max - head))}`;
+}
+export class Store {
+    db;
+    cache = new Map();
+    constructor(db) {
+        this.db = db;
+    }
+    stmt(sql) {
+        let s = this.cache.get(sql);
+        if (!s) {
+            s = this.db.prepare(sql);
+            this.cache.set(sql, s);
+        }
+        return s;
+    }
+    all(sql, ...params) {
+        return this.stmt(sql).all(...params);
+    }
+    get(sql, ...params) {
+        return this.stmt(sql).get(...params);
+    }
+    run(sql, ...params) {
+        return this.stmt(sql).run(...params);
+    }
+    transaction(fn) {
+        return tx(this.db, fn);
+    }
+    // ---- settings
+    getSetting(key) {
+        const row = this.get('SELECT value_json FROM settings WHERE key = ?', key);
+        return row ? JSON.parse(row.value_json) : undefined;
+    }
+    setSetting(key, value) {
+        this.run('INSERT INTO settings (key, value_json) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json', key, JSON.stringify(value));
+    }
+    // ---- marketplaces
+    listMarketplaces() {
+        return this.all('SELECT * FROM marketplaces ORDER BY rowid');
+    }
+    getMarketplace(name) {
+        return this.get('SELECT * FROM marketplaces WHERE name = ?', name);
+    }
+    upsertMarketplace(m) {
+        this.run(`INSERT INTO marketplaces (name, repo, enabled, index_mode) VALUES (?, ?, ?, ?)
+       ON CONFLICT(name) DO UPDATE SET repo = excluded.repo, enabled = excluded.enabled, index_mode = excluded.index_mode`, m.name, m.repo, m.enabled ? 1 : 0, m.index_mode);
+    }
+    insertMarketplaceIfMissing(m) {
+        this.run('INSERT OR IGNORE INTO marketplaces (name, repo, enabled, index_mode) VALUES (?, ?, ?, ?)', m.name, m.repo, m.enabled ? 1 : 0, m.index_mode);
+    }
+    updateMarketplaceSync(name, patch) {
+        const cur = this.getMarketplace(name);
+        if (!cur)
+            return;
+        this.run('UPDATE marketplaces SET etag = ?, synced_at = ?, plugin_count = ?, commit_sha = ?, error = ? WHERE name = ?', patch.etag !== undefined ? patch.etag : cur.etag, now(), patch.plugin_count ?? cur.plugin_count, patch.commit_sha !== undefined ? patch.commit_sha : cur.commit_sha, patch.error ?? null, name);
+    }
+    deleteMarketplace(name) {
+        this.transaction(() => {
+            const ids = this.all('SELECT id FROM plugins WHERE marketplace = ?', name).map((r) => r.id);
+            for (const id of ids)
+                this.deletePlugin(id);
+            this.run('DELETE FROM marketplaces WHERE name = ?', name);
+        });
+    }
+    // ---- plugins
+    getPlugin(id) {
+        return this.get('SELECT * FROM plugins WHERE id = ?', id);
+    }
+    listPlugins(marketplace) {
+        return this.all('SELECT * FROM plugins WHERE marketplace = ? ORDER BY name', marketplace);
+    }
+    countPlugins() {
+        return this.get('SELECT COUNT(*) AS n FROM plugins').n;
+    }
+    /**
+     * Plugins whose skills were never indexed, whose last read failed (no indexed commit), or whose pinned commit
+     * changed since indexing. Unpinned entries (sha null) are read every sync; a failure on one used to leave
+     * `NULL IS NOT NULL` and drop it for good (project review 2026-11-02).
+     */
+    listPluginsNeedingIndex(marketplace) {
+        return this.all(`SELECT * FROM plugins WHERE marketplace = ? AND repo IS NOT NULL
+       AND (skills_indexed_at IS NULL OR skills_indexed_sha IS NULL OR skills_indexed_sha IS NOT sha) ORDER BY name`, marketplace);
+    }
+    upsertPlugin(p) {
+        this.run(`INSERT INTO plugins (id, marketplace, name, display_name, description, category, keywords, source_json, source_kind,
+         repo, path, ref, sha, strict, entry_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET display_name = excluded.display_name, description = excluded.description,
+         category = excluded.category, keywords = excluded.keywords, source_json = excluded.source_json,
+         source_kind = excluded.source_kind, repo = excluded.repo, path = excluded.path, ref = excluded.ref,
+         sha = excluded.sha, strict = excluded.strict, entry_json = excluded.entry_json`, p.id, p.marketplace, p.name, p.display_name, p.description, p.category, p.keywords, p.source_json, p.source_kind, p.repo, p.path, p.ref, p.sha, p.strict, p.entry_json);
+        const rowid = this.get('SELECT rowid FROM plugins WHERE id = ?', p.id).rowid;
+        this.run('DELETE FROM plugins_fts WHERE rowid = ?', rowid);
+        this.run('INSERT INTO plugins_fts (rowid, plugin_id, name, description, category) VALUES (?, ?, ?, ?, ?)', rowid, p.id, [p.name, p.display_name, p.keywords].filter(Boolean).join(' '), p.description ?? '', p.category ?? '');
+    }
+    markPluginIndexed(id, sha, signals, error) {
+        this.run('UPDATE plugins SET skills_indexed_at = ?, skills_indexed_sha = ?, signals_json = ?, error = ? WHERE id = ?', now(), sha, signals == null ? null : JSON.stringify(signals), error, id);
+    }
+    deletePlugin(id) {
+        for (const s of this.listSkillsByPlugin(id))
+            this.deleteSkill(s.id);
+        const row = this.get('SELECT rowid FROM plugins WHERE id = ?', id);
+        if (row)
+            this.run('DELETE FROM plugins_fts WHERE rowid = ?', row.rowid);
+        this.run('DELETE FROM plugins WHERE id = ?', id);
+    }
+    // ---- skills
+    getSkill(id) {
+        return this.get('SELECT * FROM skills WHERE id = ?', id);
+    }
+    /**
+     * Skills of a plugin that lives in a repo's own marketplace (not one the app indexes): the generic skills whose
+     * install plan names that marketplace and plugin (install_json), so an install from it is not "색인에 없음".
+     */
+    listSkillsByInstallPlugin(marketplace, plugin) {
+        return this.all(`SELECT * FROM skills WHERE install_json IS NOT NULL
+       AND json_extract(install_json, '$.marketplaceName') = ? AND json_extract(install_json, '$.pluginName') = ? ORDER BY name`, marketplace, plugin);
+    }
+    listSkillsByPlugin(pluginId) {
+        return this.all('SELECT * FROM skills WHERE plugin_id = ? ORDER BY name', pluginId);
+    }
+    /** Repos with at least `minStars` stars (stored count) that GitHub-indexed skills come from. */
+    listReposWithGithubSkills(minStars) {
+        return this.all(`SELECT r.full_name FROM repos r WHERE r.stars >= ?
+         AND EXISTS (SELECT 1 FROM skills s WHERE s.repo = r.full_name COLLATE NOCASE AND s.origin = 'generic')
+       ORDER BY r.stars DESC`, minStars).map((r) => r.full_name);
+    }
+    findSkillsByRepo(repo) {
+        return this.all('SELECT * FROM skills WHERE repo = ? COLLATE NOCASE', repo);
+    }
+    countSkills() {
+        return this.get('SELECT COUNT(*) AS n FROM skills').n;
+    }
+    upsertSkill(s, pluginText) {
+        this.run(`INSERT INTO skills (id, origin, plugin_id, repo, ref, dir_path, name, description, when_to_use, frontmatter_json,
+         body_lines, skill_md_sha256, name_desc_sha256, installs, quality_json, risk_json, risk_level, last_commit_at,
+         fetched_at, files_json, install_json, installs_at, risk_rules)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET origin = excluded.origin, plugin_id = COALESCE(excluded.plugin_id, skills.plugin_id),
+         repo = excluded.repo, ref = excluded.ref, dir_path = excluded.dir_path, name = excluded.name,
+         description = excluded.description, when_to_use = excluded.when_to_use, frontmatter_json = excluded.frontmatter_json,
+         body_lines = excluded.body_lines, skill_md_sha256 = excluded.skill_md_sha256,
+         name_desc_sha256 = excluded.name_desc_sha256, installs = COALESCE(excluded.installs, skills.installs),
+         quality_json = excluded.quality_json, risk_json = excluded.risk_json, risk_level = excluded.risk_level,
+         last_commit_at = excluded.last_commit_at, fetched_at = excluded.fetched_at, files_json = excluded.files_json,
+         install_json = COALESCE(excluded.install_json, skills.install_json),
+         installs_at = CASE WHEN excluded.installs IS NOT NULL THEN excluded.installs_at ELSE skills.installs_at END,
+         risk_rules = excluded.risk_rules`, s.id, s.origin, s.plugin_id, s.repo, s.ref, s.dir_path, s.name, s.description, s.when_to_use, s.frontmatter_json, s.body_lines, s.skill_md_sha256, s.name_desc_sha256, s.installs, s.quality_json, s.risk_json, s.risk_level, s.last_commit_at, s.fetched_at, s.files_json, s.install_json, s.installs != null ? new Date().toISOString() : null, s.risk_rules ?? null);
+        const rowid = this.get('SELECT rowid FROM skills WHERE id = ?', s.id).rowid;
+        this.run('DELETE FROM skills_fts WHERE rowid = ?', rowid);
+        this.run('INSERT INTO skills_fts (rowid, skill_id, name, description, when_to_use, plugin_text) VALUES (?, ?, ?, ?, ?, ?)', rowid, s.id, s.name.replace(/[-_]+/g, ' ') + ' ' + s.name, s.description ?? '', s.when_to_use ?? '', pluginText);
+    }
+    /** Rows from GitHub checked under risk rules older than `version`, after `afterId` in id order. */
+    listSkillsForRiskRecheck(version, afterId, limit) {
+        return this.all(`SELECT * FROM skills WHERE (risk_rules IS NULL OR risk_rules < ?) AND repo IS NOT NULL AND ref IS NOT NULL
+         AND dir_path IS NOT NULL AND id > ? ORDER BY id LIMIT ?`, version, afterId, limit);
+    }
+    /** Every skill's stored flags and level (the level follows from the flags; tasks.ts relevelRisk). */
+    listSkillRiskLevels() {
+        return this.all('SELECT id, risk_json, risk_level FROM skills');
+    }
+    setSkillRiskLevel(id, riskLevel) {
+        this.run('UPDATE skills SET risk_level = ? WHERE id = ?', riskLevel, id);
+    }
+    /** Updates the risk of a row still built from the SKILL.md with hash `sha`; false when it changed meanwhile. */
+    setSkillRisk(id, sha, riskJson, riskLevel, version) {
+        const r = this.run('UPDATE skills SET risk_json = ?, risk_level = ?, risk_rules = ? WHERE id = ? AND skill_md_sha256 = ?', riskJson, riskLevel, version, id, sha);
+        return Number(r.changes) > 0;
+    }
+    /** The latest count wins, even when lower (U4): skills.sh counts can drop, and the highest ever seen stuck forever. */
+    setSkillInstalls(id, installs, at = new Date().toISOString()) {
+        this.run('UPDATE skills SET installs = ?, installs_at = ? WHERE id = ?', installs, at, id);
+    }
+    /** Deletes these skill rows except those an install was logged for (the installed page still points at them). */
+    deleteSkillsUnlessInstalled(ids) {
+        return this.transaction(() => {
+            let n = 0;
+            for (const id of ids) {
+                if (this.get('SELECT 1 FROM install_log WHERE skill_id = ? LIMIT 1', id))
+                    continue;
+                this.deleteSkill(id);
+                n++;
+            }
+            return n;
+        });
+    }
+    deleteSkill(id) {
+        const row = this.get('SELECT rowid FROM skills WHERE id = ?', id);
+        if (row)
+            this.run('DELETE FROM skills_fts WHERE rowid = ?', row.rowid);
+        this.run('DELETE FROM skills WHERE id = ?', id);
+    }
+    searchSkillsFts(match, limit, marketplaces) {
+        // rank on the FTS index alone, then read only the kept rows (s.* holds files_json, up to tens of KB);
+        // rowid breaks bm25 ties so the order is stable
+        const rows = this.all(`WITH hit AS (SELECT rowid AS rid, bm25(skills_fts, 0, 5.0, 2.0, 1.0, 0.5) AS b FROM skills_fts
+         WHERE skills_fts MATCH ? ORDER BY b, rid LIMIT ?)
+       SELECT s.*, hit.b AS _bm25, p.marketplace AS _mp
+       FROM hit JOIN skills s ON s.rowid = hit.rid
+       LEFT JOIN plugins p ON p.id = s.plugin_id ORDER BY hit.b, hit.rid`, match, marketplaces ? limit * 4 : limit);
+        const filtered = marketplaces ? rows.filter((r) => r._mp == null || marketplaces.includes(r._mp)) : rows;
+        return filtered.slice(0, limit).map(({ _bm25, _mp, ...skill }) => ({ skill: skill, bm25: _bm25 }));
+    }
+    /** Skills of repos whose name (the part after the owner) equals `name`, e.g. "rea" → morluto/rea. */
+    findSkillsByRepoName(name, limit = 30) {
+        // same expression as the skills_repo_tail index (migration 3); a LIKE '%/name' scanned every row (~48ms)
+        return this.all(`SELECT * FROM skills WHERE lower(substr(repo, instr(repo, '/') + 1)) = ?
+       AND origin != 'wellknown' AND description IS NOT NULL LIMIT ?`, name.toLowerCase(), limit);
+    }
+    /** How many indexed skills match an FTS expression (document frequency for README recommendations). */
+    countSkillsFts(match) {
+        return this.get('SELECT COUNT(*) AS n FROM skills_fts WHERE skills_fts MATCH ?', match).n;
+    }
+    searchPluginsFts(match, limit, marketplaces) {
+        const rows = this.all(`SELECT p.*, bm25(plugins_fts, 0, 4.0, 2.0, 0.5) AS _bm25
+       FROM plugins_fts JOIN plugins p ON p.rowid = plugins_fts.rowid
+       WHERE plugins_fts MATCH ? ORDER BY _bm25 LIMIT ?`, match, marketplaces ? limit * 4 : limit);
+        const filtered = marketplaces ? rows.filter((r) => marketplaces.includes(r.marketplace)) : rows;
+        return filtered.slice(0, limit).map(({ _bm25, ...plugin }) => ({ plugin: plugin, bm25: _bm25 }));
+    }
+    /** FTS restricted to one plugin's skills; used to pick the matching skills of a lazily indexed plugin. */
+    searchSkillsInPlugin(match, pluginId, limit) {
+        return this.searchSkillsInPlugins(match, [pluginId], limit).get(pluginId) ?? [];
+    }
+    /**
+     * The best `limit` matches in each of several plugins with one full-text pass (one pass per plugin cost
+     * ~15–20ms each, 20 plugins per search). Ids go in as one JSON array; rowids never leave SQL (node:sqlite
+     * binds JS numbers as REAL, which an FTS rowid comparison silently ignores).
+     */
+    searchSkillsInPlugins(match, pluginIds, limit) {
+        const out = new Map();
+        if (pluginIds.length === 0)
+            return out;
+        const rows = this.all(`WITH hit AS (SELECT skills_fts.rowid AS rid, bm25(skills_fts, 0, 5.0, 2.0, 1.0, 0.5) AS b, s.plugin_id AS pid
+         FROM skills_fts JOIN skills s ON s.rowid = skills_fts.rowid
+         WHERE skills_fts MATCH ? AND s.plugin_id IN (SELECT value FROM json_each(?))),
+       top AS (SELECT rid, b, pid, ROW_NUMBER() OVER (PARTITION BY pid ORDER BY b, rid) AS rn FROM hit)
+       SELECT s.*, top.b AS _bm25 FROM top JOIN skills s ON s.rowid = top.rid WHERE top.rn <= ? ORDER BY top.pid, top.b, top.rid`, match, JSON.stringify(pluginIds), limit);
+        for (const { _bm25, ...skill } of rows) {
+            const list = out.get(skill.plugin_id) ?? [];
+            list.push({ skill: skill, bm25: _bm25 });
+            out.set(skill.plugin_id, list);
+        }
+        return out;
+    }
+    // ---- repos
+    getRepo(fullName) {
+        return this.get('SELECT * FROM repos WHERE full_name = ? COLLATE NOCASE', fullName);
+    }
+    /** Repos that indexed skills point at whose metadata is missing or was fetched before `beforeIso`. */
+    listReposToRefresh(beforeIso, limit) {
+        return this.all(`SELECT DISTINCT s.repo AS repo FROM skills s
+       LEFT JOIN repos r ON r.full_name = s.repo COLLATE NOCASE
+       WHERE s.repo IS NOT NULL AND (r.full_name IS NULL OR r.fetched_at IS NULL OR r.fetched_at < ?)
+       LIMIT ?`, beforeIso, limit).map((r) => r.repo);
+    }
+    upsertRepo(r) {
+        this.run(`INSERT INTO repos (full_name, stars, pushed_at, archived, fork, license, default_branch, etag, fetched_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(full_name) DO UPDATE SET stars = excluded.stars, pushed_at = excluded.pushed_at,
+         archived = excluded.archived, fork = excluded.fork, license = excluded.license,
+         default_branch = excluded.default_branch, etag = excluded.etag, fetched_at = excluded.fetched_at`, r.full_name, r.stars, r.pushed_at, r.archived, r.fork, r.license, r.default_branch, r.etag, r.fetched_at);
+    }
+    touchRepo(fullName) {
+        this.run('UPDATE repos SET fetched_at = ? WHERE full_name = ?', now(), fullName);
+    }
+    // ---- search cache
+    getCached(key, maxAgeMs) {
+        const row = this.get('SELECT created_at, payload_json FROM search_cache WHERE key = ?', key);
+        if (!row || Date.now() - Date.parse(row.created_at) > maxAgeMs)
+            return undefined;
+        return JSON.parse(row.payload_json);
+    }
+    /** When `key` was stored, if within `maxAgeMs` (for verdicts that a later change can make stale). */
+    getCachedAt(key, maxAgeMs) {
+        const row = this.get('SELECT created_at FROM search_cache WHERE key = ?', key);
+        return row && Date.now() - Date.parse(row.created_at) <= maxAgeMs ? row.created_at : undefined;
+    }
+    putCached(key, payload) {
+        this.run(`INSERT INTO search_cache (key, created_at, payload_json) VALUES (?, ?, ?)
+       ON CONFLICT(key) DO UPDATE SET created_at = excluded.created_at, payload_json = excluded.payload_json`, key, now(), JSON.stringify(payload));
+    }
+    /**
+     * Drops the cached search results (they depend on the index). External answers kept in the same table
+     * (`skillssh:`, `ghcode:`, `ghrepo:`) do not, so they stay.
+     */
+    clearSearchCache() {
+        this.run("DELETE FROM search_cache WHERE key LIKE 'search:%'");
+        // the external answers outlive this, but not forever: nothing reads them after a week
+        this.run("DELETE FROM search_cache WHERE key NOT LIKE 'search:%' AND created_at < ?", new Date(Date.now() - 7 * 86_400_000).toISOString());
+    }
+    // ---- logs
+    logInstall(e) {
+        this.run(`INSERT INTO install_log (skill_id, plugin_id, method, scope, project_path, argv_json, exit_code, output, created_at, ref, skill_md_sha256, risk_level)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, e.skill_id, e.plugin_id, e.method, e.scope, e.project_path, JSON.stringify(e.argv), e.exit_code, clipOutput(e.output), now(), e.ref ?? null, e.skill_md_sha256 ?? null, e.risk_level ?? null);
+    }
+    /** The latest installs and removals, newest first (the 설치됨 screen's history). */
+    listInstallLog(limit = 50) {
+        return this.all('SELECT id, created_at, method, scope, project_path, skill_id, plugin_id, exit_code, output FROM install_log ORDER BY id DESC LIMIT ?', limit);
+    }
+    /** Project folders the app installed into (newest first), for the 설치됨 screen's shortcuts; gone ones left out. */
+    listInstalledProjects(limit = 8) {
+        return this.all(`SELECT project_path, MAX(id) AS last FROM install_log
+        WHERE project_path IS NOT NULL AND exit_code = 0 AND method NOT LIKE 'uninstall-%'
+        GROUP BY lower(project_path) ORDER BY last DESC LIMIT ?`, limit * 3)
+            .map((r) => r.project_path)
+            .filter((p) => existsSync(p))
+            .slice(0, limit);
+    }
+    // ── favorites: this PC's, no accounts (user decision 2026-11-02) ──
+    addFavorite(skillId, skillName) {
+        this.run('INSERT INTO favorites (skill_id, skill_name, created_at) VALUES (?, ?, ?) ON CONFLICT DO NOTHING', skillId, skillName, now());
+    }
+    removeFavorite(skillId) {
+        this.run('DELETE FROM favorites WHERE skill_id = ?', skillId);
+    }
+    /** Newest first. */
+    listFavorites() {
+        return this.all('SELECT skill_id, skill_name, created_at FROM favorites ORDER BY created_at DESC, rowid DESC');
+    }
+    /** Skills the app installed into a skills folder (skills CLI), newest first, to match those folders to the index. */
+    listInstalledSkillLog() {
+        return this.all(`SELECT skill_id, scope, project_path, risk_level, created_at FROM install_log
+        WHERE skill_id IS NOT NULL AND exit_code = 0 AND method = 'skills-cli' ORDER BY id DESC`);
+    }
+    /** An indexed GitHub skill whose SKILL.md has this hash (newest commit first). */
+    findSkillIdByMdSha(sha) {
+        return this.get("SELECT id FROM skills WHERE skill_md_sha256 = ? AND id LIKE 'gh:%' ORDER BY last_commit_at DESC LIMIT 1", sha)?.id ?? null;
+    }
+    logEvent(kind, skillId, query, meta) {
+        this.run('INSERT INTO events (kind, skill_id, query, created_at, meta_json) VALUES (?, ?, ?, ?, ?)', kind, skillId, query, now(), meta ? JSON.stringify(meta) : null);
+    }
+    /** Search log entries (searches and the results opened from them) on this PC. */
+    countSearchLog() {
+        return this.get(`SELECT COUNT(*) AS n FROM events WHERE kind IN ${SEARCH_LOG_KINDS}`).n;
+    }
+    /** Deletes the search log; `olderThan` (ISO time) keeps what came after it. Returns how many were deleted. */
+    clearSearchLog(olderThan) {
+        const where = `kind IN ${SEARCH_LOG_KINDS}`;
+        const r = olderThan ? this.run(`DELETE FROM events WHERE ${where} AND created_at < ?`, olderThan) : this.run(`DELETE FROM events WHERE ${where}`);
+        return Number(r.changes);
+    }
+}
+/** The kinds that make up the search log (U5-2): what was searched and which result was opened. */
+const SEARCH_LOG_KINDS = "('search', 'view')";

package/server/src/discovery/classifyRepo.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { normalizeSource, resolveRelativeRoot } from "../sources/pluginSource.js";
+import { discoverGenericSkills } from "./genericRules.js";
+import { discoverPluginSkills } from "./pluginRules.js";
+import { joinPath } from "./tree.js";
+export const MARKETPLACE_JSON = '.claude-plugin/marketplace.json';
+export const PLUGIN_JSON = '.claude-plugin/plugin.json';
+export function classifyRepo(tree) {
+    if (tree.hasFile(MARKETPLACE_JSON))
+        return 'marketplace';
+    if (tree.hasFile(PLUGIN_JSON))
+        return 'plugin';
+    return 'generic';
+}
+export const MarketplaceSchema = z.looseObject({
+    name: z.string().min(1),
+    metadata: z.looseObject({ pluginRoot: z.string().optional() }).optional(),
+    plugins: z.array(z.looseObject({ name: z.string().min(1), source: z.unknown() })),
+});
+export function parseMarketplace(text) {
+    return MarketplaceSchema.parse(JSON.parse(text));
+}
+export function parseJsonObject(text) {
+    if (text == null)
+        return null;
+    try {
+        const v = JSON.parse(text);
+        return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * §5.1: marketplace.json → each relative entry with plugin rules; plugin.json → plugin rules at the root;
+ * otherwise the generic (skills CLI) rules. External entries of a marketplace live in other repos and are skipped.
+ */
+export async function discoverRepo(tree, read, validate, 
+/** `genericSkills: false` skips reading every SKILL.md of a generic repo (single-skill lookups decide per folder). */
+opts = {}) {
+    const generic = () => (opts.genericSkills === false ? Promise.resolve([]) : discoverGenericSkills(tree, read, validate));
+    const mode = classifyRepo(tree);
+    if (mode === 'generic') {
+        return { mode, marketplaceName: null, plugins: [], generic: await generic() };
+    }
+    if (mode === 'plugin') {
+        const manifest = parseJsonObject(await read(PLUGIN_JSON));
+        const d = discoverPluginSkills(tree, '', manifest, null);
+        const name = typeof manifest?.name === 'string' ? manifest.name : '';
+        return { mode, marketplaceName: null, plugins: [{ ...d, name, manifest }], generic: [] };
+    }
+    let market;
+    try {
+        market = parseMarketplace((await read(MARKETPLACE_JSON)) ?? '');
+    }
+    catch {
+        // An unreadable marketplace.json: fall back to plugin.json or the generic rules.
+        if (tree.hasFile(PLUGIN_JSON)) {
+            const manifest = parseJsonObject(await read(PLUGIN_JSON));
+            const d = discoverPluginSkills(tree, '', manifest, null);
+            return { mode: 'plugin', marketplaceName: null, plugins: [{ ...d, name: String(manifest?.name ?? ''), manifest }], generic: [] };
+        }
+        return { mode: 'generic', marketplaceName: null, plugins: [], generic: await generic() };
+    }
+    const pluginRoot = market.metadata?.pluginRoot ?? null;
+    const entries = market.plugins.flatMap((entry) => {
+        const src = normalizeSource(entry.source, pluginRoot);
+        if (src.kind !== 'relative')
+            return [];
+        const root = resolveRelativeRoot(src.raw, pluginRoot, tree);
+        return root != null && tree.hasDir(root) ? [{ entry, root }] : [];
+    });
+    // Manifests are independent files; reading them one after another made a 100-plugin marketplace take 100 round trips.
+    const plugins = await Promise.all(entries.map(async ({ entry, root }) => {
+        const manifestPath = joinPath(root, PLUGIN_JSON);
+        const manifest = tree.hasFile(manifestPath) ? parseJsonObject(await read(manifestPath)) : null;
+        const d = discoverPluginSkills(tree, root, manifest, entry, { entryAtMarketplaceRoot: root === '' });
+        return { ...d, name: entry.name, manifest };
+    }));
+    return { mode, marketplaceName: market.name, plugins, generic: [] };
+}