@iamk77/skill-checklist 0.2.0

package/dist/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_js_1 = require("./commands/init.js");
+const show_js_1 = require("./commands/show.js");
+const verify_js_1 = require("./commands/verify.js");
+const check_js_1 = require("./commands/check.js");
+const phases_js_1 = require("./commands/phases.js");
+const reset_js_1 = require("./commands/reset.js");
+const program = new commander_1.Command()
+    .name('checklist')
+    .description('Flight checklist CLI for Claude Code skills')
+    .version('0.2.0');
+// Flags are uniform across every command so an agent never has to remember
+// which command accepts what. In the normal skill flow none are needed:
+// `--dir` defaults to $CLAUDE_SKILL_DIR / the active checklist, and `--path`
+// defaults to that same dir.
+const DIR_OPT = ['-d, --dir <dir>', 'Directory containing .checklist.yml'];
+const PATH_OPT = ['-p, --path <path>', 'Target skill directory for builtins (defaults to --dir)'];
+program
+    .command('init [dir]')
+    .description('Load .checklist.yml, clear state, show ready summary')
+    .option(...DIR_OPT)
+    .option(...PATH_OPT)
+    .option('--force', 'Clear existing state without prompting')
+    .action(init_js_1.initCommand);
+program
+    .command('show [phase]')
+    .description('Show checklist overview, or a specific phase with readings')
+    .option(...DIR_OPT)
+    .option(...PATH_OPT)
+    .action(show_js_1.showCommand);
+program
+    .command('verify <phase>')
+    .description('Batch verify mechanical checks for a phase')
+    .option(...DIR_OPT)
+    .option(...PATH_OPT)
+    .action(verify_js_1.verifyCommand);
+program
+    .command('check <phase> <item-id>')
+    .description('Manually confirm a human-judgment check item')
+    .option(...DIR_OPT)
+    .option(...PATH_OPT)
+    .action(check_js_1.checkCommand);
+program
+    .command('phases')
+    .description('List all phases')
+    .option(...DIR_OPT)
+    .option(...PATH_OPT)
+    .action(phases_js_1.phasesCommand);
+program
+    .command('reset')
+    .alias('done')
+    .description('End-of-run cleanup: clear this skill\'s state and active pointer')
+    .option(...DIR_OPT)
+    .option(...PATH_OPT)
+    .action(reset_js_1.resetCommand);
+program.parse();

package/dist/loader.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadChecklist = loadChecklist;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const yaml = __importStar(require("js-yaml"));
+const CONFIG_FILE = '.checklist.yml';
+function loadChecklist(dir) {
+    const filePath = path.resolve(dir, CONFIG_FILE);
+    if (!fs.existsSync(filePath)) {
+        // Agents naturally point checklist at the project they are working on, but
+        // a checklist lives in the *skill* directory (next to SKILL.md). Redirect
+        // instead of dead-ending.
+        const skillHint = process.env.CLAUDE_SKILL_DIR
+            ? `\n  this skill's dir is: ${process.env.CLAUDE_SKILL_DIR}\n  try: checklist init "${process.env.CLAUDE_SKILL_DIR}"`
+            : `\n  a checklist lives in the skill directory (next to SKILL.md), not your project/working dir.\n  try: checklist init <skill-dir>`;
+        throw new Error(`${CONFIG_FILE} not found in ${dir}${skillHint}`);
+    }
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const data = yaml.load(raw);
+    if (!data || typeof data !== 'object') {
+        throw new Error(`${CONFIG_FILE} is empty or not a valid YAML object`);
+    }
+    if (!Array.isArray(data.phases)) {
+        throw new Error(`${CONFIG_FILE} missing "phases" array`);
+    }
+    const phases = data.phases.map((p, i) => {
+        const phase = p;
+        if (!phase.name || typeof phase.name !== 'string') {
+            throw new Error(`Phase ${i}: missing "name" field`);
+        }
+        if (!Array.isArray(phase.checks)) {
+            throw new Error(`Phase "${phase.name}": missing "checks" array`);
+        }
+        if (phase.checks.length === 0) {
+            // A phase with no checks is vacuously gate-complete (`[].every` is true),
+            // letting an empty stage pass with zero work. The format is documented as
+            // a non-empty checks list, so reject it at the parse boundary.
+            throw new Error(`Phase "${phase.name}": "checks" array is empty`);
+        }
+        const checks = phase.checks.map((c, j) => {
+            const check = c;
+            if (!check.id || typeof check.id !== 'string') {
+                throw new Error(`Phase "${phase.name}", check ${j}: missing "id"`);
+            }
+            if (!check.description || typeof check.description !== 'string') {
+                throw new Error(`Phase "${phase.name}", check "${check.id}": missing "description"`);
+            }
+            return {
+                id: check.id,
+                description: check.description,
+                verify: typeof check.verify === 'string' ? check.verify : undefined,
+            };
+        });
+        const seenIds = new Set();
+        for (const ch of checks) {
+            if (seenIds.has(ch.id)) {
+                throw new Error(`Phase "${phase.name}": duplicate check id "${ch.id}"`);
+            }
+            seenIds.add(ch.id);
+        }
+        return { name: phase.name, checks };
+    });
+    if (phases.length === 0) {
+        throw new Error(`${CONFIG_FILE}: "phases" array is empty`);
+    }
+    // Phases are addressed BY NAME (findPhaseIndex, case-insensitively). Two phases
+    // sharing a name would make every non-first one unreachable through its only
+    // documented handle, so reject duplicates the same way duplicate check ids are.
+    const seenPhaseNames = new Set();
+    for (const ph of phases) {
+        const key = ph.name.toLowerCase();
+        if (seenPhaseNames.has(key)) {
+            throw new Error(`${CONFIG_FILE}: duplicate phase name "${ph.name}"`);
+        }
+        seenPhaseNames.add(key);
+    }
+    return { phases };
+}

package/dist/resolver.js

@@ -0,0 +1,181 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDir = resolveDir;
+exports.writeActivePointer = writeActivePointer;
+exports.clearActivePointer = clearActivePointer;
+exports.findPhaseIndex = findPhaseIndex;
+exports.runPhase = runPhase;
+exports.gatePriorPhases = gatePriorPhases;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const state_js_1 = require("./state.js");
+const runner_js_1 = require("./runner.js");
+// Single, cwd-independent record of the active checklist dir. `init` writes it
+// (its dir comes from the harness-expanded ${CLAUDE_SKILL_DIR}, so it is
+// reliable), and every later command resolves it no matter which directory they
+// run from — so the skill never has to pass --dir, and there is no cwd-coupled
+// pointer that a stale copy could shadow. Location is overridable via
+// CHECKLIST_HOME (used to sandbox tests).
+const CONFIG_FILE = '.checklist.yml';
+function activePointerPath() {
+    const dir = process.env.CHECKLIST_HOME ||
+        (process.env.XDG_CONFIG_HOME
+            ? path.join(process.env.XDG_CONFIG_HOME, 'checklist')
+            : path.join(os.homedir(), '.config', 'checklist'));
+    return path.join(dir, 'active');
+}
+function resolveDir(explicit) {
+    if (explicit)
+        return explicit;
+    if (process.env.CHECKLIST_DIR)
+        return process.env.CHECKLIST_DIR;
+    // A running skill always knows its own dir; the harness exposes it here. This
+    // lets an agent run any checklist command (even before `init`) with no flags
+    // and no guesswork about where .checklist.yml lives.
+    if (process.env.CLAUDE_SKILL_DIR)
+        return process.env.CLAUDE_SKILL_DIR;
+    const pointerPath = activePointerPath();
+    let raw;
+    try {
+        raw = fs.readFileSync(pointerPath, 'utf-8');
+    }
+    catch {
+        return process.cwd(); // no pointer (ENOENT) or unreadable
+    }
+    const target = raw.trim();
+    if (target) {
+        try {
+            fs.statSync(path.join(target, CONFIG_FILE));
+            return target; // points at a real checklist dir
+        }
+        catch (e) {
+            // Only self-heal when the target is *definitely* gone. statSync returning
+            // ENOENT/ENOTDIR means the dir/file is absent; any other errno (EACCES,
+            // EIO, ELOOP, an NFS stall, ...) means "can't tell" — never delete a valid
+            // pointer over a transient read failure.
+            const code = e.code;
+            if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+                return target;
+            }
+        }
+    }
+    // Empty content, or target is definitely gone: self-heal and fall through.
+    try {
+        fs.unlinkSync(pointerPath);
+    }
+    catch {
+        /* best-effort cleanup; ignore races */
+    }
+    return process.cwd();
+}
+function writeActivePointer(targetDir) {
+    const absDir = path.resolve(targetDir);
+    const pointerPath = activePointerPath();
+    fs.mkdirSync(path.dirname(pointerPath), { recursive: true });
+    fs.writeFileSync(pointerPath, absDir, 'utf-8');
+}
+// Remove the active pointer. With a targetDir, only removes it when it points
+// there (so `reset` of skill A never clobbers an active pointer for skill B).
+// Returns whether a pointer was removed.
+function clearActivePointer(targetDir) {
+    const pointerPath = activePointerPath();
+    let current;
+    try {
+        current = fs.readFileSync(pointerPath, 'utf-8').trim();
+    }
+    catch {
+        return false; // no pointer (handles the ENOENT race too)
+    }
+    if (targetDir && current !== path.resolve(targetDir))
+        return false;
+    try {
+        fs.unlinkSync(pointerPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function findPhaseIndex(config, nameOrIndex) {
+    const num = parseInt(nameOrIndex, 10);
+    if (!isNaN(num) && num >= 0 && num < config.phases.length) {
+        return num;
+    }
+    const idx = config.phases.findIndex(p => p.name.toLowerCase() === nameOrIndex.toLowerCase());
+    if (idx === -1) {
+        throw new Error(`Phase not found: "${nameOrIndex}". Use \`checklist phases\` to list available phases.`);
+    }
+    return idx;
+}
+async function runPhase(phase, phaseIndex, cwd, targetPath) {
+    const checks = await Promise.all(phase.checks.map(item => (0, runner_js_1.runCheck)(item, cwd, targetPath)));
+    let mechanicalPassed = 0;
+    let mechanicalTotal = 0;
+    let manualCount = 0;
+    for (const c of checks) {
+        if (c.kind === 'manual') {
+            manualCount++;
+        }
+        else {
+            mechanicalTotal++;
+            if (c.result?.status === 'pass')
+                mechanicalPassed++;
+        }
+    }
+    return {
+        phaseName: phase.name,
+        phaseIndex,
+        checks,
+        mechanicalPassed,
+        mechanicalTotal,
+        manualCount,
+    };
+}
+function gatePriorPhases(config, targetPhaseIndex, state) {
+    for (let i = 0; i < targetPhaseIndex; i++) {
+        const phase = config.phases[i];
+        const ids = phase.checks.map(c => c.id);
+        if (!(0, state_js_1.isPhaseComplete)(state, i, ids)) {
+            return {
+                passed: false,
+                failedPhase: phase.name,
+                failedPhaseIndex: i,
+            };
+        }
+    }
+    return { passed: true };
+}

package/dist/runner.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCheck = runCheck;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const index_js_1 = require("./builtins/index.js");
+const EXEC_TIMEOUT = 10_000;
+const PREFIX_MAP = {
+    'builtin:': 'builtin',
+    'shell:': 'shell',
+    'script:': 'script',
+};
+function classifyVerify(verify) {
+    for (const [prefix, kind] of Object.entries(PREFIX_MAP)) {
+        if (verify.startsWith(prefix)) {
+            return { kind, value: verify.slice(prefix.length).trim(), explicit: true };
+        }
+    }
+    const firstToken = verify.split(/\s/)[0];
+    if (firstToken.includes('/') || /\.(sh|bash|ts|js|py)$/.test(firstToken)) {
+        return { kind: 'script', value: verify, explicit: false };
+    }
+    return { kind: 'shell', value: verify, explicit: false };
+}
+async function runShell(command, cwd) {
+    try {
+        const stdout = (0, node_child_process_1.execSync)(command, {
+            cwd,
+            timeout: EXEC_TIMEOUT,
+            encoding: 'utf-8',
+            shell: '/bin/bash',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return { status: 'pass', message: stdout || 'OK' };
+    }
+    catch (e) {
+        const err = e;
+        const detail = (err.stderr || err.message || 'command failed').trim();
+        return { status: 'fail', message: detail };
+    }
+}
+async function runBuiltin(name, targetPath) {
+    const handler = (0, index_js_1.getBuiltin)(name);
+    if (!handler) {
+        const available = (0, index_js_1.listBuiltins)().join(', ');
+        return { status: 'error', message: `unknown builtin "${name}". available: ${available}` };
+    }
+    return handler(targetPath);
+}
+async function runScript(scriptPath, cwd, explicit) {
+    const base = path.resolve(cwd);
+    const resolved = path.resolve(base, scriptPath);
+    const rel = path.relative(base, resolved);
+    // Containment: the script must live inside the checklist dir. Absolute paths
+    // are fine as long as they resolve within `base`; escapes (`..`, other roots)
+    // are rejected to prevent a malicious .checklist.yml from executing arbitrary
+    // files elsewhere on disk.
+    if (rel === '..' || rel.startsWith('..' + path.sep) || path.isAbsolute(rel)) {
+        return {
+            status: 'error',
+            message: `script path escapes the checklist dir: "${scriptPath}" (resolved to "${resolved}")`,
+        };
+    }
+    if (!fs.existsSync(resolved)) {
+        const hint = explicit
+            ? `script not found: "${resolved}" (resolved from "${scriptPath}")`
+            : `auto-classified as script (first token contains "/" or has script extension), but file not found: "${resolved}". use "shell:" prefix if this is a shell command`;
+        return { status: 'error', message: hint };
+    }
+    // Containment (canonical): the lexical check above never follows symlinks, but
+    // execution does — a symlink planted inside the dir can point outside it. Re-check
+    // against the real (symlink-resolved) paths before running.
+    const realBase = fs.realpathSync(base);
+    const realResolved = fs.realpathSync(resolved);
+    const realRel = path.relative(realBase, realResolved);
+    if (realRel === '..' || realRel.startsWith('..' + path.sep) || path.isAbsolute(realRel)) {
+        return {
+            status: 'error',
+            message: `script path escapes the checklist dir via symlink: "${scriptPath}" (resolves to "${realResolved}")`,
+        };
+    }
+    return runShell(realResolved, cwd);
+}
+async function runCheck(item, cwd, targetPath) {
+    if (!item.verify) {
+        return { item, kind: 'manual' };
+    }
+    const { kind, value, explicit } = classifyVerify(item.verify);
+    let result;
+    switch (kind) {
+        case 'builtin':
+            result = await runBuiltin(value, targetPath);
+            break;
+        case 'script':
+            result = await runScript(value, cwd, explicit);
+            break;
+        case 'shell':
+            result = await runShell(value, cwd);
+            break;
+    }
+    return { item, kind: 'mechanical', result };
+}

package/dist/state.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadState = loadState;
+exports.saveState = saveState;
+exports.clearState = clearState;
+exports.isItemChecked = isItemChecked;
+exports.getItemResult = getItemResult;
+exports.setItemResult = setItemResult;
+exports.isPhaseComplete = isPhaseComplete;
+exports.phaseProgress = phaseProgress;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const STATE_FILE = '.checklist.state.json';
+function statePath(dir) {
+    return path.resolve(dir, STATE_FILE);
+}
+function loadState(dir) {
+    const p = statePath(dir);
+    if (!fs.existsSync(p)) {
+        return { checked: {} };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        throw new Error(`state file is corrupt: ${p}. run \`checklist init --force\` to reset it`);
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        throw new Error(`state file is malformed: ${p}. run \`checklist init --force\` to reset it`);
+    }
+    // `typeof null === 'object'` and `typeof [] === 'object'`, so a corrupt or
+    // partially-written file shaped like {"checked":null} or {"checked":[]} would
+    // slip past a bare typeof guard and then crash gate evaluation downstream with
+    // an unhandled TypeError. Reject any non-plain-object `checked` here instead,
+    // so the corruption surfaces as the documented malformed-state error.
+    const checked = parsed.checked;
+    if (typeof checked !== 'object' || checked === null || Array.isArray(checked)) {
+        throw new Error(`state file is malformed: ${p}. run \`checklist init --force\` to reset it`);
+    }
+    return parsed;
+}
+function saveState(dir, state) {
+    fs.writeFileSync(statePath(dir), JSON.stringify(state, null, 2), 'utf-8');
+}
+function clearState(dir) {
+    const p = statePath(dir);
+    if (fs.existsSync(p)) {
+        fs.unlinkSync(p);
+    }
+}
+function isItemChecked(state, phaseIndex, itemId) {
+    // An item counts as checked only when its recorded result is a PASS — not
+    // merely present. A stored fail/error, or a once-green check that later
+    // regressed and was re-recorded, must NOT satisfy the gate. The gate is the
+    // safety floor: completeness means current pass-status, not existence of a row.
+    return state.checked[String(phaseIndex)]?.[itemId]?.status === 'pass';
+}
+function getItemResult(state, phaseIndex, itemId) {
+    return state.checked[String(phaseIndex)]?.[itemId];
+}
+function setItemResult(state, phaseIndex, itemId, result) {
+    const key = String(phaseIndex);
+    if (!state.checked[key]) {
+        state.checked[key] = {};
+    }
+    state.checked[key][itemId] = result;
+}
+function isPhaseComplete(state, phaseIndex, itemIds) {
+    return itemIds.every(id => isItemChecked(state, phaseIndex, id));
+}
+function phaseProgress(state, phaseIndex, itemIds) {
+    const done = itemIds.filter(id => isItemChecked(state, phaseIndex, id)).length;
+    return { done, total: itemIds.length };
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@iamk77/skill-checklist",
+  "version": "0.2.0",
+  "description": "Flight checklist CLI that gates a Claude Code skill's phases — a stage cannot open until every check in every prior stage is recorded as passing",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "skill",
+    "checklist",
+    "gate",
+    "cli",
+    "agent"
+  ],
+  "homepage": "https://github.com/IamK77/Skill/tree/main/devtools/checklist#readme",
+  "bugs": {
+    "url": "https://github.com/IamK77/Skill/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/IamK77/Skill.git",
+    "directory": "devtools/checklist"
+  },
+  "author": "IamK77",
+  "license": "Apache-2.0",
+  "bin": {
+    "checklist": "bin/checklist.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "NOTICE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^14.0.0",
+    "gray-matter": "^4.0.3",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^4.1.6",
+    "tsx": "^4.21.0",
+    "typescript": "^5.5.0",
+    "vitest": "^4.1.6"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}