@shinaps/skills 0.42.0 → 0.44.0

package/README.md

@@ -8,7 +8,7 @@ Claude Code と Codex で使う、開発ワークフローのスキル集です
 ## 必要なもの
 
 - Claude Code または Codex CLI
-- Node.js 22 以上（Codex への導入と、設定の検証・Managed Agents の操作に使う[配布 CLI](docs/install.md#配布-cli)に必要）
+- Node.js 22.13 以上の 22 系、または 24 以上（Codex への導入と、設定の検証・Managed Agents の操作・規約の機械検査に使う[配布 CLI](docs/install.md#配布-cli)に必要。機械検査の ESLint の要件に合わせている）。配布 CLI は機械検査のために ESLint・typescript-eslint・TypeScript などを依存に持ち、導入に約 50MB を使います。
 - 機能によって追加で必要なもの（Linear・Claude Managed Agents など）は、下の「機能別の資料」の各資料に書いています。
 
 ## インストール

package/dist/bin/skills.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { packageRoot } from '../lib/layout.js';
-import { validateLinearConfig } from '../lib/linear-config.js';
-import { validateManagedConfig } from '../lib/managed-config.js';
-import { managed } from '../lib/managed.js';
-import { run } from '../lib/install.js';
-import { autoUpdate } from '../lib/auto-update.js';
-import { errorMessage } from '../lib/fs.js';
+import { packageRoot } from "../lib/layout.js";
+import { validateLinearConfig } from "../lib/linear-config.js";
+import { validateManagedConfig } from "../lib/managed-config.js";
+import { managed } from "../lib/managed.js";
+import { run } from "../lib/install.js";
+import { autoUpdate } from "../lib/auto-update.js";
+import { lint } from "../lib/lint.js";
+import { errorMessage } from "../lib/fs.js";
 const [command, ...rest] = process.argv.slice(2);
 try {
     if (command === '--version') {
@@ -29,6 +30,8 @@ try {
         await managed(rest);
     else if (command === 'auto-update')
         await autoUpdate(rest);
+    else if (command === 'lint')
+        await lint(rest);
     else
         await run(process.argv.slice(2));
 }

package/dist/lib/auto-update.js

@@ -2,10 +2,10 @@ import { mkdir, writeFile, rm } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { execFileSync, spawnSync } from 'node:child_process';
-import { withLock } from './lock.js';
-import { install, openInstallation, recover } from './install.js';
-import { errorMessage, readJson, readJsonIfExists } from './fs.js';
-import { codexHomeMismatch, codexHomeOf, isRecordedCodexHome, managedRoot, manifestPath, payloadDir, statePath, } from './layout.js';
+import { withLock } from "./lock.js";
+import { install, openInstallation, recover } from "./install.js";
+import { errorMessage, readJson, readJsonIfExists } from "./fs.js";
+import { codexHomeMismatch, codexHomeOf, isRecordedCodexHome, managedRoot, manifestPath, payloadDir, statePath, } from "./layout.js";
 const actions = ['enable', 'disable', 'status', 'check'];
 const isAction = (value) => actions.includes(value);
 const label = 'io.shinaps.skills.update';

package/dist/lib/config-validation.js

@@ -1,7 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Ajv } from 'ajv';
-import { packageRoot } from './layout.js';
+import { packageRoot } from "./layout.js";
 /** 明示されたファイルを同梱の契約で検証し、検証した内容を返す。設定の探索・変更や外部取得は行わない。 */
 export async function validateConfig(path, contract) {
     const input = JSON.parse(await readFile(path, 'utf8'));

package/dist/lib/install.js

@@ -2,10 +2,10 @@ import { readFile, readdir, cp, rm, mkdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { digest, registerPlugin, replaceInstallation, restore, } from './transaction.js';
-import { withLock } from './lock.js';
-import { readTextIfExists, writeFileAtomic } from './fs.js';
-import { codexHomeMismatch, codexHomeOf, isRecordedCodexHome, managedAgent, managedRoot, marketplaceName, packageRoot, payloadDir, payloadPaths, pluginDir, pluginId, statePath, } from './layout.js';
+import { digest, registerPlugin, replaceInstallation, restore, } from "./transaction.js";
+import { withLock } from "./lock.js";
+import { readTextIfExists, writeFileAtomic } from "./fs.js";
+import { codexHomeMismatch, codexHomeOf, isRecordedCodexHome, managedAgent, managedRoot, marketplaceName, packageRoot, payloadDir, payloadPaths, pluginDir, pluginId, statePath, } from "./layout.js";
 const actions = ['install', 'update', 'uninstall', 'recover'];
 const isAction = (value) => actions.includes(value);
 const usage = [
@@ -14,6 +14,7 @@ const usage = [
     '       shinaps-skills validate-managed-config <file>',
     '       shinaps-skills managed <setup|run|status|reply|collect> (see managed --help)',
     '       shinaps-skills auto-update <enable|disable|status|check> codex',
+    '       shinaps-skills lint --checks <checks.json> --root <project> --out <result.json> -- <files...>',
     'Claude Code: /plugin marketplace add sh1n4ps/shinaps-skills',
     '             /plugin install shinaps@shinaps-skills',
 ].join('\n');
@@ -124,7 +125,7 @@ async function uninstall(installation, options) {
             return;
         }
         // auto-update.ts は check でこのモジュールを使う。相互 import を避けるため実行時に読み込む。
-        const { autoUpdate } = await import('./auto-update.js');
+        const { autoUpdate } = await import("./auto-update.js");
         await autoUpdate(['disable', 'codex'], options);
         await command(['plugin', 'remove', pluginId]);
         await command(['plugin', 'marketplace', 'remove', marketplaceName]);

package/dist/lib/linear-config.js

@@ -1,4 +1,4 @@
-import { validateConfig } from './config-validation.js';
+import { validateConfig } from "./config-validation.js";
 /** `.shinaps/linear.json` を同梱の契約で検証する。 */
 export async function validateLinearConfig(path) {
     await validateConfig(path, {

package/dist/lib/lint-plan.js

@@ -0,0 +1,173 @@
+/**
+ * `shinaps-skills lint` の入力・実行単位・結果の分類。ESLint を呼ばない純関数だけを置き、実行は lint.ts が行う。
+ *
+ * 規約 R × ファイル F の組を AI 照合から外してよいのは、次がすべて成り立つときだけ（docs/lint.md）。
+ * - R の検査の coverage が full（登録時の意味のレビューの結果。ここでは値を読むだけ）
+ * - その検査が F に適用されると ESLint が判定し、検査が属する実行単位が完了し、F に致命的な報告も
+ *   ruleId の無い報告も無い
+ * どれかが欠けた組は not-run にして AI へ回す。
+ */
+/** 検査を引く key。規約 id と、その規約の checks の中の位置で決まる。 */
+export const checkKey = (ruleId, index) => `${ruleId}#${index}`;
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * 入力 JSON を検査の一覧にする。形が違えば throw し、呼び出し側は結果を書かずに失敗する（全組を AI へ）。
+ * 形だけを見る。ルール ID・options・glob の中身は検査せず、ESLint が拒否すればその検査だけが not-run になる。
+ */
+export function parseLintInput(raw) {
+    if (!isObject(raw) || !Array.isArray(raw.rules))
+        throw new Error('checks: expected { "rules": [...] }');
+    return {
+        rules: raw.rules.map((rule, ruleIndex) => {
+            const where = `checks: rules[${ruleIndex}]`;
+            if (!isObject(rule) || typeof rule.id !== 'string' || rule.id === '')
+                throw new Error(`${where}: expected a non-empty "id"`);
+            if (!Array.isArray(rule.checks))
+                throw new Error(`${where}: expected "checks" to be an array`);
+            return {
+                id: rule.id,
+                checks: rule.checks.map((check, checkIndex) => parseCheck(check, `${where}.checks[${checkIndex}]`)),
+            };
+        }),
+    };
+}
+function parseCheck(raw, where) {
+    if (!isObject(raw))
+        throw new Error(`${where}: expected an object`);
+    const { rule, options, files, coverage } = raw;
+    if (typeof rule !== 'string' || rule === '')
+        throw new Error(`${where}: expected a non-empty "rule"`);
+    if (options !== undefined && !Array.isArray(options))
+        throw new Error(`${where}: expected "options" to be an array`);
+    if (!Array.isArray(files) ||
+        files.length === 0 ||
+        !files.every((file) => typeof file === 'string' && file !== ''))
+        throw new Error(`${where}: expected "files" to be a non-empty array of globs`);
+    if (coverage !== 'full' && coverage !== 'partial')
+        throw new Error(`${where}: expected "coverage" to be "full" or "partial"`);
+    return { rule, options: options ?? [], files, coverage };
+}
+/** キーの順を揃えた JSON。同じ options を同じ文字列にして、実行単位でまとめるために使う。 */
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (isObject(value))
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+            .join(',')}}`;
+    return JSON.stringify(value);
+}
+/**
+ * 検査を実行単位に分ける。同じルール・同じ options の検査は 1 つの設定にまとめ、同じルールで options が
+ * 違うものだけを別の単位にする（flat config では同じルールの設定は後勝ちで 1 つしか残らないため）。
+ * 型が要るルールは projectService を付けた単位に分ける。型の得られないファイルはその単位だけが fatal になり、
+ * 型なしの検査を巻き込まない。
+ * @param needsTypes ルール ID が型情報を要するか。解決できたルールについてだけ呼ぶ
+ */
+export function planUnits(bindings, needsTypes) {
+    const groups = new Map();
+    for (const binding of bindings) {
+        const key = `${binding.check.rule}\0${canonicalJson(binding.check.options)}`;
+        const group = groups.get(key);
+        if (group)
+            group.bindings.push(binding);
+        else
+            groups.set(key, {
+                rule: binding.check.rule,
+                options: binding.check.options,
+                bindings: [binding],
+            });
+    }
+    const units = new Map();
+    const variants = new Map();
+    for (const group of groups.values()) {
+        const typed = needsTypes(group.rule);
+        const variant = variants.get(group.rule) ?? 0;
+        variants.set(group.rule, variant + 1);
+        const id = `${typed ? 'typed' : 'syntax'}-${variant}`;
+        const unit = units.get(id) ?? { id, typed, rules: [] };
+        unit.rules.push(group);
+        units.set(id, unit);
+    }
+    return [...units.values()];
+}
+/**
+ * 組を分類する。検査は checkKey で引く。
+ * @param applied 検査ごとに、ESLint が適用すると判定したファイル（root からの相対パス）
+ * @param outcomeOf 検査ごとの、その検査が属する実行単位の結果。unusable の検査は含まない
+ * @param unusable 実行しなかった検査とその理由（この版に無いルール、ESLint が拒否した設定）
+ */
+export function classify(input) {
+    const pairs = [];
+    for (const rule of input.rules) {
+        if (rule.checks.length === 0)
+            continue;
+        for (const file of input.files) {
+            const findings = [];
+            const reasons = [];
+            let fullRan = false;
+            let anyRan = false;
+            for (const [index, check] of rule.checks.entries()) {
+                const key = checkKey(rule.id, index);
+                const unusable = input.unusable.get(key);
+                if (unusable !== undefined) {
+                    reasons.push(`${check.rule}: ${unusable}`);
+                    continue;
+                }
+                if (!input.applied.get(key)?.has(file))
+                    continue;
+                const outcome = input.outcomeOf.get(key);
+                if (outcome?.error !== undefined) {
+                    reasons.push(`${check.rule}: ${outcome.error}`);
+                    continue;
+                }
+                const report = outcome?.reports.get(file);
+                if (!report) {
+                    reasons.push(`${check.rule}: no result for the file`);
+                    continue;
+                }
+                const ruleless = report.messages.find((message) => message.ruleId === null);
+                if (report.fatal || ruleless) {
+                    reasons.push(`${check.rule}: ${ruleless?.message ?? 'fatal error'}`);
+                    continue;
+                }
+                anyRan = true;
+                if (check.coverage === 'full')
+                    fullRan = true;
+                for (const message of report.messages) {
+                    if (message.ruleId === check.rule)
+                        findings.push({
+                            rule: check.rule,
+                            line: message.line,
+                            column: message.column,
+                            message: message.message,
+                        });
+                }
+            }
+            const state = fullRan
+                ? findings.length > 0
+                    ? 'violation'
+                    : 'covered'
+                : anyRan
+                    ? 'partial'
+                    : 'not-run';
+            const pair = { ruleId: rule.id, file, state, findings: dedupe(findings) };
+            if (state === 'not-run')
+                pair.reason = reasons.length > 0 ? reasons.join('; ') : 'no check applies to the file';
+            pairs.push(pair);
+        }
+    }
+    return pairs;
+}
+// 同じルール・同じ options の検査を 1 規約が 2 つ持つと、同じ報告が 2 回集まるため 1 つにする。
+function dedupe(findings) {
+    const seen = new Set();
+    return findings.filter((finding) => {
+        const key = `${finding.rule}:${finding.line}:${finding.column}:${finding.message}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/lib/lint-rules.js

@@ -0,0 +1,52 @@
+/**
+ * Promise の executor が受け取る resolve / reject を、executor の外から使うために executor 内で別の場所へ
+ * 代入する書き方（deferred promise）を報告する。`Promise.withResolvers()` で書ける。
+ * 代入先は変数・プロパティを問わない。resolve / reject を値として渡す呼び出し（`setResolve(resolve)`）や、
+ * 包んだ関数の代入（`done = () => resolve()`）は報告しない（意図の判定に構文以上の情報が要るため）。
+ */
+const preferPromiseWithResolvers = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Create deferred promises with Promise.withResolvers instead of leaking the executor callbacks',
+        },
+        messages: {
+            leaked: "Promise executor's {{name}} is assigned to be used outside the executor. Use Promise.withResolvers().",
+        },
+        schema: [],
+    },
+    create(context) {
+        // 名前だけで判定すると、executor の内側の関数が同じ名前の引数を持つ場合を取り違える。
+        // 右辺を scope で解決し、それを定義した関数が、祖先の `new Promise(...)` の第 1 引数そのものかを確かめる。
+        return {
+            AssignmentExpression(node) {
+                if (node.right.type !== 'Identifier')
+                    return;
+                const definition = findVariable(context.sourceCode.getScope(node), node.right.name)
+                    ?.defs[0];
+                if (definition?.type !== 'Parameter')
+                    return;
+                const leaksExecutorParameter = context.sourceCode
+                    .getAncestors(node)
+                    .some((ancestor) => ancestor.type === 'NewExpression' &&
+                    ancestor.callee.type === 'Identifier' &&
+                    ancestor.callee.name === 'Promise' &&
+                    ancestor.arguments[0] === definition.node);
+                if (leaksExecutorParameter)
+                    context.report({ node, messageId: 'leaked', data: { name: node.right.name } });
+            },
+        };
+    },
+};
+function findVariable(scope, name) {
+    for (let current = scope; current; current = current.upper) {
+        const variable = current.set.get(name);
+        if (variable)
+            return variable;
+    }
+    return undefined;
+}
+export const shinapsPlugin = {
+    meta: { name: 'shinaps' },
+    rules: { 'prefer-promise-with-resolvers': preferPromiseWithResolvers },
+};

package/dist/lib/lint.js

@@ -0,0 +1,233 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { checkKey, classify, parseLintInput, planUnits, } from "./lint-plan.js";
+import { shinapsPlugin } from "./lint-rules.js";
+import { errorMessage } from "./fs.js";
+const USAGE = 'Usage: shinaps-skills lint --checks <checks.json> --root <project> --out <result.json> -- <files...>';
+/**
+ * `shinaps-skills lint`: 規約の検査を、プロジェクトの設定を使わずに ESLint の Node API で実行し、
+ * 規約 × ファイルの組を分類して result.json に書く。プロジェクトの lint 設定・script・node_modules の
+ * パッケージは読み込まない（overrideConfigFile: true、プラグインはこのパッケージの依存から渡す）。
+ * 対象ファイルへは書き込まない。
+ */
+export async function lint(args) {
+    const options = parseArgs(args);
+    const input = parseLintInput(JSON.parse(await readFile(options.checks, 'utf8')));
+    const result = await runLint(input, options.root, options.files);
+    await writeFile(options.out, `${JSON.stringify(result, null, 2)}\n`);
+    const counts = Object.fromEntries(['covered', 'violation', 'partial', 'not-run'].map((state) => [
+        state,
+        result.pairs.filter((pair) => pair.state === state).length,
+    ]));
+    console.log(`Shinaps lint: ${JSON.stringify(counts)} → ${options.out}`);
+}
+function parseArgs(args) {
+    const separator = args.indexOf('--');
+    const flags = separator === -1 ? args : args.slice(0, separator);
+    const files = separator === -1 ? [] : args.slice(separator + 1);
+    const value = (name) => {
+        const index = flags.indexOf(name);
+        const found = index === -1 ? undefined : flags[index + 1];
+        if (!found)
+            throw new Error(`${name} is required. ${USAGE}`);
+        return found;
+    };
+    return { checks: value('--checks'), root: resolve(value('--root')), out: value('--out'), files };
+}
+/**
+ * @param root 対象プロジェクトのルート（絶対パス）
+ * @param files 対象ファイル。root からの相対パスか絶対パス。結果では root からの相対パス（区切りは `/`）で表す
+ */
+export async function runLint(input, root, files) {
+    const { ESLint } = await import('eslint');
+    const registry = await loadRegistry();
+    const relativeFiles = [...new Set(files.map((file) => toRelative(root, file)))];
+    const newESLint = (overrideConfig) => new ESLint({
+        cwd: root,
+        overrideConfigFile: true,
+        overrideConfig,
+        allowInlineConfig: false,
+        // 削除済みなどで存在しないファイルを渡しても単位全体を失敗にせず、そのファイルを「結果なし」
+        // (not-run) にするため。
+        errorOnUnmatchedPattern: false,
+        // 渡すのはファイルだけ。`src/*.ts` のような名前のファイルを glob として展開し、渡していない
+        // ファイルまで検査しないため。
+        globInputPaths: false,
+    });
+    const needsTypes = (rule) => 
+    // ESLint の型の docs には requiresTypeChecking が無い (typescript-eslint が付ける独自の項目)。
+    registry.rules.get(rule)?.meta?.docs
+        ?.requiresTypeChecking === true;
+    // 検査が F に適用されるかは ESLint だけが判定する。その検査の設定だけを入れたインスタンスで
+    // calculateConfigForFile を呼び、ルールが有効なら適用される。glob の解釈を CLI 側で再現しない。
+    // ESLint が設定（不正な options など）を拒否した検査は、ここで not-run にして実行単位に入れない。
+    // 単位に入れると、同じ単位の他の検査まで実行できなくなるため。
+    const unusable = new Map();
+    const applied = new Map();
+    const bindings = [];
+    for (const rule of input.rules) {
+        for (const [index, check] of rule.checks.entries()) {
+            const key = checkKey(rule.id, index);
+            if (!registry.rules.has(check.rule)) {
+                unusable.set(key, 'unsupported rule in this version of @shinaps/skills');
+                continue;
+            }
+            const binding = { ruleId: rule.id, index, check };
+            const single = newESLint(unitConfig(registry, root, needsTypes(check.rule), [
+                { rule: check.rule, options: check.options, bindings: [binding] },
+            ]));
+            try {
+                const hits = new Set();
+                for (const file of relativeFiles) {
+                    if (isActive(await single.calculateConfigForFile(resolve(root, file)), check.rule))
+                        hits.add(file);
+                }
+                applied.set(key, hits);
+                bindings.push(binding);
+            }
+            catch (error) {
+                unusable.set(key, oneLine(error));
+            }
+        }
+    }
+    const outcomeOf = new Map();
+    const units = [];
+    for (const unit of planUnits(bindings, needsTypes)) {
+        const unitBindings = unit.rules.flatMap((planned) => planned.bindings);
+        const targets = [
+            ...new Set(unitBindings.flatMap((binding) => [
+                ...(applied.get(checkKey(binding.ruleId, binding.index)) ?? []),
+            ])),
+        ];
+        const outcome = await runUnit(unit, targets);
+        for (const binding of unitBindings)
+            outcomeOf.set(checkKey(binding.ruleId, binding.index), outcome);
+        units.push({
+            id: unit.id,
+            typed: unit.typed,
+            rules: unit.rules.map((planned) => planned.rule),
+            // ESLint が結果を返したファイルの数。単位のエラーや存在しないファイルでは、渡した数より少なくなる。
+            fileCount: outcome.reports.size,
+            ...(outcome.error === undefined ? {} : { error: outcome.error }),
+        });
+    }
+    async function runUnit(unit, targets) {
+        // 渡すファイルが無ければ実行しない。ファイルを省くと ESLint は cwd 配下を全部検査するため。
+        if (targets.length === 0)
+            return { reports: new Map() };
+        try {
+            const results = await newESLint(unitConfig(registry, root, unit.typed, unit.rules)).lintFiles(targets.map((file) => resolve(root, file)));
+            const reports = new Map();
+            for (const result of results) {
+                reports.set(toRelative(root, result.filePath), {
+                    fatal: result.fatalErrorCount > 0,
+                    messages: result.messages.map((message) => ({
+                        ruleId: message.ruleId,
+                        line: message.line,
+                        column: message.column,
+                        message: message.message,
+                    })),
+                });
+            }
+            return { reports };
+        }
+        catch (error) {
+            return { error: oneLine(error), reports: new Map() };
+        }
+    }
+    return {
+        root,
+        units,
+        pairs: classify({ rules: input.rules, files: relativeFiles, applied, outcomeOf, unusable }),
+    };
+}
+// ESLint の設定エラーは複数行で、理由が 2 行目以降にあるため、1 行にまとめて結果に残す。
+const oneLine = (error) => errorMessage(error)
+    .replace(/\s*\n\s*/g, ' ')
+    .trim();
+function toRelative(root, file) {
+    const absolute = isAbsolute(file) ? file : resolve(root, file);
+    return relative(root, absolute).split(sep).join('/');
+}
+function isActive(config, rule) {
+    const entry = config?.rules?.[rule];
+    const severity = Array.isArray(entry) ? entry[0] : entry;
+    return severity !== undefined && severity !== 0 && severity !== 'off';
+}
+async function loadRegistry() {
+    const [{ builtinRules }, tseslint, vue, vueParser] = await Promise.all([
+        import('eslint/use-at-your-own-risk'),
+        import('typescript-eslint'),
+        import('eslint-plugin-vue'),
+        import('vue-eslint-parser'),
+    ]);
+    // typescript-eslint と eslint-plugin-vue が公開する型は ESLint の Plugin・Parser・RuleModule の型と
+    // 細部が一致しない (どちらも実行時は ESLint の API に従う)。flat config に渡すために ESLint の型にする。
+    const plugins = {
+        '@typescript-eslint': tseslint.default.plugin,
+        vue: vue.default,
+        shinaps: shinapsPlugin,
+    };
+    const rules = new Map(builtinRules);
+    for (const [prefix, plugin] of Object.entries(plugins)) {
+        for (const [name, rule] of Object.entries(plugin.rules ?? {}))
+            rules.set(`${prefix}/${name}`, rule);
+    }
+    return {
+        plugins,
+        rules,
+        parsers: {
+            typescript: tseslint.default.parser,
+            vue: vueParser.default,
+        },
+    };
+}
+const TS_FILES = ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'];
+// 検査の対象にする拡張子。ESLint は `src/**` のように全てのファイルに一致する glob だけではファイルを検査の
+// 対象にしないので、拡張子を指定したパターンを両方の単位に置く。単位の種類で適用範囲が変わらないよう、
+// 型付き・型なしで同じ一覧を使う。
+const LINTED_FILES = [...TS_FILES, '**/*.js', '**/*.jsx', '**/*.mjs', '**/*.cjs', '**/*.vue'];
+/**
+ * 実行単位の設定。parser は拡張子ごとの設定オブジェクトで指定し、ルールは検査の glob の和に付ける。
+ * 型付きの単位は、対象の全てのファイルを projectService 付きの typescript-eslint で読む。型の得られない
+ * ファイル (tsconfig に含まれない JS、Vue など) はそのファイルだけが fatal (not-run) になる。JS を ESLint
+ * の既定の parser で読むと、型を要求するルールが単位全体を例外で止め、他の検査を巻き込むため。
+ * 型付きの単位では Vue を扱わない (vue-eslint-parser と projectService の組み合わせは使っていない)。
+ */
+function unitConfig(registry, root, typed, rules) {
+    const parsers = typed
+        ? [
+            {
+                files: LINTED_FILES,
+                languageOptions: {
+                    parser: registry.parsers.typescript,
+                    parserOptions: { projectService: true, tsconfigRootDir: root },
+                },
+            },
+        ]
+        : [
+            { files: LINTED_FILES },
+            // 既定の parser は JSX を読まないので、.jsx では JSX を有効にする (無いと常に parse error で not-run)。
+            {
+                files: ['**/*.jsx'],
+                languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+            },
+            { files: TS_FILES, languageOptions: { parser: registry.parsers.typescript } },
+            {
+                files: ['**/*.vue'],
+                languageOptions: {
+                    parser: registry.parsers.vue,
+                    parserOptions: { parser: registry.parsers.typescript, sourceType: 'module' },
+                },
+            },
+        ];
+    return [
+        ...parsers,
+        ...rules.map((planned) => ({
+            files: [...new Set(planned.bindings.flatMap((binding) => binding.check.files))],
+            plugins: registry.plugins,
+            // options は JSON の配列 (unknown[]) で、ESLint の RuleEntry は要素の型を持たないので型だけを合わせる。
+            rules: { [planned.rule]: ['error', ...planned.options] },
+        })),
+    ];
+}

package/dist/lib/lock.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, writeFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { errorCode } from './fs.js';
+import { errorCode } from "./fs.js";
 /**
  * `<directory>/update.lock` を保持したまま `work` を実行する。ロックはディレクトリで、保持者の pid を
  * `pid` ファイルに記録する。保持者が存在しないロックは置き換える。保持者が生きているか pid をまだ読め

package/dist/lib/managed-config.js

@@ -1,4 +1,4 @@
-import { validateConfig } from './config-validation.js';
+import { validateConfig } from "./config-validation.js";
 /** `.shinaps/managed.json` を同梱の契約で検証し、内容を返す。 */
 export async function validateManagedConfig(path) {
     return (await validateConfig(path, {

package/dist/lib/managed-session.js

@@ -1,9 +1,9 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, readdir, rename, rm, stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { readJson, readJsonIfExists, writeFileAtomic } from './fs.js';
-import { withLock } from './lock.js';
-import { filesBeta, managedBeta } from './managed-ant.js';
+import { readJson, readJsonIfExists, writeFileAtomic } from "./fs.js";
+import { withLock } from "./lock.js";
+import { filesBeta, managedBeta } from "./managed-ant.js";
 export const staffings = ['LITE', 'BASIC', 'ULTRA'];
 export const permissions = ['commit', 'push', 'draft_pr'];
 const leadKey = './agents/shinaps-dev-managed-cc.md';

package/dist/lib/managed-setup.js

@@ -1,10 +1,10 @@
 import { createHash } from 'node:crypto';
 import { lstat, mkdir, readdir, readFile, rm } from 'node:fs/promises';
 import { dirname, join, relative, sep } from 'node:path';
-import { errorCode, readJsonIfExists, readTextIfExists, writeFileAtomic } from './fs.js';
-import { withLock } from './lock.js';
-import { managedTemplatePath } from './layout.js';
-import { managedBeta } from './managed-ant.js';
+import { errorCode, readJsonIfExists, readTextIfExists, writeFileAtomic } from "./fs.js";
+import { withLock } from "./lock.js";
+import { managedTemplatePath } from "./layout.js";
+import { managedBeta } from "./managed-ant.js";
 /** 共通定義の 3 ディレクトリ。`definitions/` には、これと `claude-lock.json` 以外を置かない。 */
 const definitionDirs = ['agents', 'environments', 'skills'];
 const lockName = 'claude-lock.json';

package/dist/lib/managed.js

@@ -1,11 +1,11 @@
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { errorMessage } from './fs.js';
-import { managedAccountDir, managedRoot, packageRoot } from './layout.js';
-import { antCommand } from './managed-ant.js';
-import { validateManagedConfig } from './managed-config.js';
-import { collectOutputs, permissions, replySession, runSession, sessionStatus, staffings, } from './managed-session.js';
-import { setupAccount } from './managed-setup.js';
+import { errorMessage } from "./fs.js";
+import { managedAccountDir, managedRoot, packageRoot } from "./layout.js";
+import { antCommand } from "./managed-ant.js";
+import { validateManagedConfig } from "./managed-config.js";
+import { collectOutputs, permissions, replySession, runSession, sessionStatus, staffings, } from "./managed-session.js";
+import { setupAccount } from "./managed-setup.js";
 const managedUsage = [
     'Usage: shinaps-skills managed setup --account <name> [--account <name> ...] [--apply]',
     '       shinaps-skills managed run <managed.json> --account <name> --base <branch> --base-sha <sha> --head <branch> --staffing <LITE|BASIC|ULTRA> --allow <none|commit,push,draft_pr> --budget-cents <n> --task-file <file> [--verify <command>] [--author "<name> <email>"] [--title <title>] [--claude-md <file>]',

package/dist/lib/transaction.js

@@ -1,8 +1,8 @@
 import { mkdir, rm, rename, cp } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
-import { managedAgent, marketplaceName, payloadDir, pluginId, statePath } from './layout.js';
-import { errorCode, errorMessage, readJsonIfExists, readTextIfExists, writeFileAtomic, } from './fs.js';
+import { managedAgent, marketplaceName, payloadDir, pluginId, statePath } from "./layout.js";
+import { errorCode, errorMessage, readJsonIfExists, readTextIfExists, writeFileAtomic, } from "./fs.js";
 /** エージェント内容の sha256。state.json と journal の `nextHashes` はこの形式で記録する。 */
 export const digest = (text) => createHash('sha256').update(text).digest('hex');
 /** 配布物を Codex に登録する。install と restore で同じ手順を使う。 */