skills-atlas-cli 0.9.1 → 0.10.0

package/bin/skills.js

@@ -17,6 +17,7 @@ const hook = require('../src/commands/hook');
 const gaps = require('../src/commands/gaps');
 const gapAnalyze = require('../src/commands/gap-analyze');
 const prune = require('../src/commands/prune');
+const feedback = require('../src/commands/feedback');
 const update = require('../src/commands/update');
 const mcp = require('../src/commands/mcp');
 const { categories, list } = require('../src/commands/categories');
@@ -24,7 +25,7 @@ const { categories, list } = require('../src/commands/categories');
 const VERSION = require('../package.json').version;
 // `use` = install + activate inline (emit the SKILL.md so an agent follows it now).
 const use = argv => install([...argv, '--inline']);
-const commands = { search, info, install, use, kit, sync, installed, upgrade, remove, outdated, doctor, suggest, hook, gaps, 'gap-analyze': gapAnalyze, prune, update, categories, list, registry, mcp };
+const commands = { search, info, install, use, kit, sync, installed, upgrade, remove, outdated, doctor, suggest, hook, gaps, 'gap-analyze': gapAnalyze, prune, feedback, update, categories, list, registry, mcp };
 
 const HELP = `skills-atlas — search, install & manage AI agent skills
 
@@ -49,6 +50,7 @@ autopilot (opt-in):
   hook on|off|status proactively suggest a skill in Claude when your prompt fits one
   gaps               kinds of work you keep doing without a skill (run: skills-atlas hook on)
   prune              installed skills you no longer use — Claude suggests removing them
+  feedback           what the autopilot learned from your installs/removes (sharpens it)
 
 catalog:
   update             refresh the catalog from the public data feed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skills-atlas-cli",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Search, install and learn AI agent skills from the terminal — powered by the Skills Atlas catalog.",
   "bin": {
     "skills-atlas": "bin/skills.js",

package/src/commands/feedback.js

@@ -0,0 +1,53 @@
+// `skills-atlas feedback` — the autopilot's local suppression list. Two scopes:
+// skills you've dismissed (never suggested, anywhere) and skills you've removed from
+// THIS project (not suggested here). Show / add to / reset it. Nothing is sent.
+'use strict';
+
+const { parse } = require('../args');
+const feedback = require('../feedback');
+const { green, dim } = require('../format');
+
+const HELP = `usage: skills-atlas feedback [dismiss <skill> | reset]
+
+Skills the autopilot won't suggest again. Two kinds, local only — nothing is sent:
+  • dismissed — you said "never suggest this"; applies in every project
+  • removed   — you removed it from THIS project; suppressed here only
+Installing a skill clears both. (Removing one from the global scope is just an
+uninstall — it does not suppress; use 'dismiss' for a blanket no.)
+
+  feedback                  show the suppression list (this project + global)
+  feedback dismiss <skill>  never suggest a skill again, in any project
+  feedback reset            forget everything (global + this project)
+  --json`;
+
+module.exports = async function feedbackCmd(argv) {
+  const { values, positionals } = parse(argv, ['json']);
+  if (values.help) { console.log(HELP); return; }
+  const sub = positionals[0];
+
+  if (sub === 'reset') {
+    feedback.clear();
+    console.log(values.json ? JSON.stringify({ reset: true }) : `${green('✓')} feedback reset.`);
+    return;
+  }
+  if (sub === 'dismiss') {
+    const x = positionals.slice(1).join(' ');
+    if (!x) { console.error('usage: skills-atlas feedback dismiss <skill>'); process.exitCode = 1; return; }
+    feedback.dismiss(x);
+    console.log(values.json ? JSON.stringify({ dismissed: x }) : `${green('✓')} won't suggest ${x} again (any project).`);
+    return;
+  }
+
+  const cur = feedback.current();
+  if (values.json) {
+    console.log(JSON.stringify({ dismissed: [...cur.global], removedHere: [...cur.project] }, null, 2));
+    return;
+  }
+  if (!cur.global.size && !cur.project.size) {
+    console.log(dim('nothing suppressed — run `skills-atlas feedback dismiss <skill>`, or remove a\nskill from this project, and the autopilot stops offering it.'));
+    return;
+  }
+  if (cur.global.size) console.log(`\n${green("won't suggest anywhere")} (${cur.global.size}): ${[...cur.global].join(', ')}`);
+  if (cur.project.size) console.log(`${green("won't suggest in this project")} (${cur.project.size}): ${[...cur.project].join(', ')}`);
+  console.log(dim('re-install one to clear it, or: skills-atlas feedback reset'));
+};

package/src/commands/install.js

@@ -253,6 +253,9 @@ module.exports = async function install(argv) {
     return;
   }
 
+  // installing clears any prior suppression (global dismiss + this project's removal).
+  try { require('../feedback').installed(skill); } catch { /* ignore */ }
+
   if (values.json) {
     const out = {
       skill, mode: 'folder', source: src.name,

package/src/commands/remove.js

@@ -40,6 +40,11 @@ module.exports = async function remove(argv) {
   if (fsu.dirExists(dest)) fsu.rmrf(dest);
   manifest.remove(root, name);
 
+  // Removing a PROJECT skill is a "not in this project" signal — suppress it here only,
+  // never across projects (it may be useful elsewhere). Removing a GLOBAL skill is just
+  // uninstalling; for a blanket "never suggest this", use `feedback dismiss`.
+  if (!global) { try { require('../feedback').removedInProject(name); } catch { /* ignore */ } }
+
   if (values.json) { console.log(JSON.stringify({ removed: name, dest })); return; }
   console.log(`${green('✓')} removed ${name}  ${dim(fsu.tildify(dest))}`);
   if (otherHas) console.log(dim(`note: '${name}' is still installed in the ${global ? 'project' : 'global'} scope — remove that too: skills-atlas remove ${name} ${otherFlag}`));

package/src/commands/suggest.js

@@ -131,7 +131,7 @@ module.exports = async function suggest() {
     for (const s of fsu.scopesFor({})) for (const e of manifest.list(s.root)) installed.add(e.skill);
     const suggested = new Set(state.suggested || []);
 
-    const { fire, candidates } = suggestCandidates(flatRows, prompt, { installed, suggested });
+    const { fire, candidates } = suggestCandidates(flatRows, prompt, { installed, suggested, feedback: require('../feedback').current() });
     if (!fire || !candidates.length) { writeState(file, state); return; }
 
     const lines = candidates.map(c => {
@@ -146,7 +146,8 @@ module.exports = async function suggest() {
       `fits THIS task (it's a curated skill from the Skills Atlas catalog, not something you made up), ` +
       `then let them choose — activate it now (\`skills-atlas use <skill> --yes --project\` installs + applies it ` +
       `immediately), see what it covers first (\`skills-atlas info <skill>\`), or skip and you'll just ` +
-      `do the task yourself. If none fit but the task plainly needs a specialized skill, you may run ` +
+      `do the task yourself; if they ask to never suggest it again, run \`skills-atlas feedback dismiss <skill>\`. ` +
+      `If none fit but the task plainly needs a specialized skill, you may run ` +
       `\`skills-atlas search "<short intent>"\` to look further. If nothing fits, say nothing about this ` +
       `at all — don't mention this hook, these skills, or that a suggestion was made.` + langHint(ap.replyLang));
     state.lastSuggestedCount = state.count;

package/src/feedback.js

@@ -0,0 +1,86 @@
+// Local suppression memory for the autopilot. Two scopes, because the two signals
+// mean different things:
+//
+//   • dismiss  — you explicitly said "never suggest this skill"        → GLOBAL table
+//   • removed  — you removed a project-scoped skill you'd installed     → PROJECT table
+//
+// A dismiss is a deliberate, blanket "no", so it applies everywhere. A removal is
+// contextual ("done with it here") — it must NOT leak to other projects, so it lives
+// in a per-project table keyed by the project root. The LATEST action per skill wins:
+// installing a skill clears both its global dismiss and this project's removal.
+//
+// All local; project tables live under the cache (keyed by path hash), never in the
+// repo, so personal suppression is never committed. Nothing is sent anywhere.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const MAX_EVENTS = 500;
+
+function baseDir() {
+  const base = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
+  return path.join(base, 'skills-atlas');
+}
+function globalFile() { return path.join(baseDir(), 'feedback.json'); }
+function projectFile(root) {
+  const key = crypto.createHash('sha1').update(path.resolve(root || process.cwd())).digest('hex').slice(0, 16);
+  return path.join(baseDir(), 'projects', `${key}.json`);
+}
+
+function readStore(file) {
+  try { const s = JSON.parse(fs.readFileSync(file, 'utf8')); if (!Array.isArray(s.events)) s.events = []; return s; }
+  catch { return { events: [] }; }
+}
+function writeStore(file, s) {
+  try { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, JSON.stringify(s)); } catch { /* best-effort */ }
+}
+function append(file, skill, signal) {
+  if (!skill || !signal) return;
+  const s = readStore(file);
+  s.events.push({ skill, signal, at: new Date().toISOString() });
+  if (s.events.length > MAX_EVENTS) s.events = s.events.slice(-MAX_EVENTS);
+  writeStore(file, s);
+}
+
+// Pure: skills whose MOST RECENT action in this store is the suppressing signal.
+// (An 'accepted' afterwards clears it — you installed it, so you changed your mind.)
+function suppressedFrom(events, suppressSignal) {
+  const latest = new Map();
+  for (const e of events || []) {
+    if (!e || !e.skill) continue;
+    const prev = latest.get(e.skill);
+    if (!prev || Date.parse(e.at) >= Date.parse(prev.at)) latest.set(e.skill, e);
+  }
+  const out = new Set();
+  for (const [skill, e] of latest) if (e.signal === suppressSignal) out.add(skill);
+  return out;
+}
+
+// --- writes ---
+function dismiss(skill) { append(globalFile(), skill, 'dismissed'); }              // explicit "never, anywhere"
+function removedInProject(skill, root) { append(projectFile(root), skill, 'removed'); } // "not in this project"
+function installed(skill, root) { append(globalFile(), skill, 'accepted'); append(projectFile(root), skill, 'accepted'); }
+
+// --- reads ---
+function globalDismissed() { return suppressedFrom(readStore(globalFile()).events, 'dismissed'); }
+function projectRemoved(root) { return suppressedFrom(readStore(projectFile(root)).events, 'removed'); }
+
+// Merged view for the autopilot hook, which runs in a project cwd: a skill is hidden
+// if it's globally dismissed OR removed in this project.
+function current(root) {
+  const global = globalDismissed();
+  const project = projectRemoved(root);
+  const suppressed = new Set([...global, ...project]);
+  return { suppressed, isSuppressed: s => suppressed.has(s), global, project };
+}
+
+function clear(root) { writeStore(globalFile(), { events: [] }); writeStore(projectFile(root), { events: [] }); }
+
+module.exports = {
+  globalFile, projectFile, readStore, writeStore,
+  dismiss, removedInProject, installed,
+  globalDismissed, projectRemoved, current, clear,
+};

package/src/search-core.js

@@ -270,10 +270,11 @@ function contentDf(rows) {
 // `fire` is true only when there's a distinctive anchor (a rare name word, or ≥2
 // matched name words) or an otherwise strong (non-weak) match — so the hook stays
 // quiet on greetings and generic dev actions ("fix the typo", "build the app").
-function suggestCandidates(rows, prompt, { installed = new Set(), suggested = new Set(), limit = 5 } = {}) {
+function suggestCandidates(rows, prompt, { installed = new Set(), suggested = new Set(), feedback = null, limit = 5 } = {}) {
   const tokens = tokenize(lc(prompt));
   if (tokens.length < 2) return { fire: false, candidates: [], weak: false };
-  const taken = new Set([...installed, ...suggested]);
+  // `taken` also drops what you've dismissed or installed-then-removed — never re-suggest those.
+  const taken = new Set([...installed, ...suggested, ...(feedback ? feedback.suppressed : [])]);
   const info = segmentDf(rows);
 
   // 1. name anchors — ONLY contentful (non-generic) name words count, weighted by
@@ -365,6 +366,9 @@ function suggestCandidates(rows, prompt, { installed = new Set(), suggested = ne
     anchors.some(a => a.strong >= 2 || a.specific >= 1) ||
     contentAnchors.some(contentQualifies)
   );
+  // NB: feedback only SUPPRESSES (via `taken` above) — that changes which skills make
+  // the shortlist. We deliberately don't reorder the final ≤5: Claude reads all of them
+  // and picks by fit, so reordering them would do nothing.
   return { fire, candidates: out.slice(0, limit), weak };
 }