@heihei0299/matt-skills 3.0.0 → 3.0.1

package/bin/cli.js

@@ -6,12 +6,12 @@ import { fileURLToPath } from 'node:url';
 import prompts from 'prompts';
 import {
   PROPRIETARY_SKILLS,
-  isDefaultProgrammingSkill,
-  isDistributableProprietarySkill,
   isDistributableSkill,
   isRepoLocalSkill,
   REPO_LOCAL_SKILLS,
 } from './skill-boundaries.js';
+import { resolveSkillNames } from './skill-selection.js';
+import { loadSkillSet } from './skill-config.js';
 
 const SKILLS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '.agents', 'skills');
 const TEMPLATE_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'template');
@@ -19,32 +19,15 @@ const ENGINEERING_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)),
 const REQUIRED_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'config', 'required.json');
 let ENGINEERING_SKILLS = null;
 async function loadEngineeringSkills() {
-  if (ENGINEERING_SKILLS) return ENGINEERING_SKILLS;
-  try {
-    const raw = await readFile(ENGINEERING_PATH, 'utf8');
-    ENGINEERING_SKILLS = new Set(JSON.parse(raw));
-  } catch {
-    ENGINEERING_SKILLS = new Set(['ask-matt','code-review','codebase-design','diagnosing-bugs','domain-modeling','grill-with-docs','implement','improve-codebase-architecture','prototype','research','resolving-merge-conflicts','setup-matt-pocock-skills','tdd','to-spec','to-tickets','triage','wayfinder','wizard']);
-  }
+  if (!ENGINEERING_SKILLS) ENGINEERING_SKILLS = await loadSkillSet(ENGINEERING_PATH, 'engineering');
   return ENGINEERING_SKILLS;
 }
+
 let REQUIRED_SKILLS = null;
 async function loadRequiredSkills() {
-  if (REQUIRED_SKILLS) return REQUIRED_SKILLS;
-  try {
-    const raw = await readFile(REQUIRED_PATH, 'utf8');
-    REQUIRED_SKILLS = new Set(JSON.parse(raw));
-  } catch {
-    REQUIRED_SKILLS = new Set(['grilling', 'grill-me', 'handoff']);
-  }
+  if (!REQUIRED_SKILLS) REQUIRED_SKILLS = await loadSkillSet(REQUIRED_PATH, 'required');
   return REQUIRED_SKILLS;
 }
-function isProgrammingSkill(name, engineering, required) {
-  return isDefaultProgrammingSkill(name, engineering, required);
-}
-function isProgrammingAll(name, engineering) {
-  return isDistributableProprietarySkill(name) || engineering.has(name);
-}
 process.stdout.on('error', (err) => {
   if (err.code === 'EPIPE') process.exit(0);
   throw err;
@@ -156,20 +139,22 @@ function parseFrontmatter(text) {
   return fields;
 }
 
-async function listSkillNames({ onlyProgramming = false } = {}) {
+async function listAvailableSkillNames() {
   const entries = await readdir(SKILLS_DIR, { withFileTypes: true });
-  let names = entries
+  return entries
     .filter((entry) => entry.isDirectory())
     .filter((entry) => !entry.name.endsWith('.bak'))
     .filter((entry) => entry.name !== 'skill-creator' && entry.name !== '.git')
-    .filter((entry) => !isRepoLocalSkill(entry.name))
     .map((entry) => entry.name);
-  if (onlyProgramming) {
-    const engineering = await loadEngineeringSkills();
-    const required = await loadRequiredSkills();
-    names = names.filter((name) => isProgrammingSkill(name, engineering, required));
-  }
-  return names.sort();
+}
+
+async function listSkillNames({ onlyProgramming = false } = {}) {
+  return resolveSkillNames({
+    availableNames: await listAvailableSkillNames(),
+    mode: onlyProgramming ? 'default' : 'all',
+    engineering: onlyProgramming ? await loadEngineeringSkills() : [],
+    required: onlyProgramming ? await loadRequiredSkills() : [],
+  });
 }
 
 async function listSkills({ onlyProgramming = false } = {}) {
@@ -249,11 +234,8 @@ async function promptSkills(skills) {
 
 async function installCommand({ dest, all, force, tools, global }) {
   const onlyProgramming = !all;
-  const engineering = onlyProgramming ? await loadEngineeringSkills() : null;
-  const required = onlyProgramming ? await loadRequiredSkills() : null;
   const skillNames = await listSkillNames({ onlyProgramming });
-  const skillsAll = await listSkills({ onlyProgramming: false });
-  const skills = onlyProgramming ? skillsAll.filter(s => isProgrammingSkill(s.name, engineering, required)) : skillsAll;
+  const skills = await listSkills({ onlyProgramming });
   let targets;
   if (dest) {
     targets = [{ tool: null, dir: path.resolve(process.cwd(), dest) }];
@@ -338,11 +320,10 @@ async function initCommand({ dest, all }) {
     installed = entries.filter((e) => e.isDirectory() && !e.name.endsWith('.bak') && e.name !== '.git' && e.name !== 'skill-creator' && !isRepoLocalSkill(e.name)).length;
   } catch {}
   const allSkillsFull = await listSkills({ onlyProgramming: false });
-  const engineeringForStats = await loadEngineeringSkills();
-  const requiredForStats = await loadRequiredSkills();
-  const programmingCount = allSkillsFull.filter(s => isProgrammingSkill(s.name, engineeringForStats, requiredForStats)).length;
+  const programmingSkills = await listSkills({ onlyProgramming: true });
+  const programmingCount = programmingSkills.length;
   const upstreamFull = allSkillsFull.filter((s) => !PROPRIETARY_SKILLS.has(s.name)).length;
-  const upstreamProg = allSkillsFull.filter((s) => !PROPRIETARY_SKILLS.has(s.name) && (engineeringForStats.has(s.name) || requiredForStats.has(s.name))).length;
+  const upstreamProg = programmingSkills.filter((s) => !PROPRIETARY_SKILLS.has(s.name)).length;
   const displayTotal = onlyProgramming ? programmingCount : allSkillsFull.length;
   const displayUpstream = onlyProgramming ? upstreamProg : upstreamFull;
   if (path.resolve(skillsDir) === path.resolve(SKILLS_DIR)) {

package/bin/skill-boundaries.js

@@ -46,14 +46,6 @@ export function isDefaultProprietarySkill(name) {
   return DEFAULT_PROPRIETARY_SKILLS.has(name);
 }
 
-export function isDefaultProgrammingSkill(name, engineering, required) {
-  return (
-    DEFAULT_PROPRIETARY_SKILLS.has(name) ||
-    engineering.has(name) ||
-    (required && required.has(name))
-  );
-}
-
 export function isDistributableSkill(name, knownNames) {
   if (!knownNames) return isDistributableProprietarySkill(name);
   const known = knownNames instanceof Set ? knownNames : new Set(knownNames);

package/bin/skill-config.js

@@ -0,0 +1,21 @@
+import { readFile } from 'node:fs/promises';
+
+export async function loadSkillSet(file, label) {
+  let raw;
+  try {
+    raw = await readFile(file, 'utf8');
+  } catch (error) {
+    throw new Error(`unable to read ${label} skill config: ${error.message}`);
+  }
+
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`invalid ${label} skill config: ${error.message}`);
+  }
+  if (!Array.isArray(value) || value.some((name) => typeof name !== 'string')) {
+    throw new Error(`invalid ${label} skill config: expected an array of strings`);
+  }
+  return new Set(value);
+}

package/bin/skill-selection.js

@@ -0,0 +1,27 @@
+import {
+  DEFAULT_PROPRIETARY_SKILLS,
+  isDistributableSkill,
+} from './skill-boundaries.js';
+
+function asSet(value) {
+  return value instanceof Set ? new Set(value) : new Set(value ?? []);
+}
+
+export function resolveSkillNames({ availableNames, mode = 'default', engineering, required }) {
+  if (mode !== 'default' && mode !== 'all') {
+    throw new Error(`unknown skill selection mode: ${mode}`);
+  }
+
+  const available = asSet(availableNames);
+  const candidates = mode === 'all'
+    ? available
+    : new Set([
+      ...asSet(engineering),
+      ...asSet(required),
+      ...DEFAULT_PROPRIETARY_SKILLS,
+    ]);
+
+  return [...candidates]
+    .filter((name) => available.has(name) && isDistributableSkill(name, available))
+    .sort();
+}

package/config/required.json

@@ -0,0 +1,5 @@
+[
+  "grilling",
+  "grill-me",
+  "handoff"
+]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heihei0299/matt-skills",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Agent skills + 项目配置模板：一条命令初始化 opencode / pi-agent 项目（含 mattpocock/skills 上游技能）",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
     "scripts/codex-smoke.js",
     "config/proprietary.json",
     "config/engineering.json",
+    "config/required.json",
     "README.md"
   ],
   "scripts": {

package/scripts/sync-upstream.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { PROPRIETARY_SKILLS } from '../bin/skill-boundaries.js';
+import { loadSkillSet } from '../bin/skill-config.js';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const LOCAL_SKILLS_DIR = path.join(ROOT, '.agents', 'skills');
@@ -23,20 +24,10 @@ async function loadProprietary() {
 }
 
 async function loadEngineering() {
-  try {
-    const raw = await readFile(ENGINEERING_PATH, 'utf8');
-    return new Set(JSON.parse(raw));
-  } catch {
-    return new Set(['ask-matt','code-review','codebase-design','diagnosing-bugs','domain-modeling','grill-with-docs','implement','improve-codebase-architecture','prototype','research','resolving-merge-conflicts','setup-matt-pocock-skills','tdd','to-spec','to-tickets','triage','wayfinder','wizard']);
-  }
+  return loadSkillSet(ENGINEERING_PATH, 'engineering');
 }
 async function loadRequired() {
-  try {
-    const raw = await readFile(REQUIRED_PATH, 'utf8');
-    return new Set(JSON.parse(raw));
-  } catch {
-    return new Set(['grilling', 'grill-me', 'handoff']);
-  }
+  return loadSkillSet(REQUIRED_PATH, 'required');
 }
 
 async function hashFile(filePath) {