codymaster 5.2.0 → 7.0.1

package/dist/handoff/io.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Handoff JSON read/write helpers.
+ *
+ * Files live under `<projectPath>/.cm/handoff/<name>.json`.
+ * Validation is intentionally lightweight (no zod dep) — schema field +
+ * required key presence is enough to catch drift early.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandoffError = void 0;
+exports.handoffPath = handoffPath;
+exports.ensureHandoffDir = ensureHandoffDir;
+exports.validateHandoff = validateHandoff;
+exports.writeHandoff = writeHandoff;
+exports.readHandoff = readHandoff;
+exports.listHandoffs = listHandoffs;
+exports.clearHandoffs = clearHandoffs;
+exports.nowIso = nowIso;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const contracts_js_1 = require("./contracts.js");
+class HandoffError extends Error {
+}
+exports.HandoffError = HandoffError;
+function handoffDir(projectPath) {
+    return path_1.default.join(projectPath, '.cm', 'handoff');
+}
+function handoffPath(projectPath, schema) {
+    return path_1.default.join(handoffDir(projectPath), contracts_js_1.HANDOFF_FILENAMES[schema]);
+}
+function ensureHandoffDir(projectPath) {
+    const d = handoffDir(projectPath);
+    if (!fs_1.default.existsSync(d))
+        fs_1.default.mkdirSync(d, { recursive: true });
+}
+/** Required top-level keys for every envelope. */
+const ENVELOPE_KEYS = ['schema', 'emitted_at', 'emitted_by', 'data'];
+/** Per-schema required keys inside `data`. */
+const DATA_KEYS = {
+    'intent@1': ['problem', 'success_criteria', 'constraints', 'options_considered'],
+    'plan@1': ['goal', 'decisions', 'first_tasks'],
+    'exec@1': ['completed_tasks', 'pending_tasks', 'files_changed', 'test_status'],
+    'review@1': ['verdict', 'findings', 'must_fix_count'],
+    'quality@1': ['gates_passed', 'gates_failed', 'safe_to_ship', 'evidence'],
+    'retro@1': ['sprint_id', 'learnings'],
+    'party@1': ['topic', 'personas'],
+};
+function validateHandoff(obj) {
+    if (!obj || typeof obj !== 'object') {
+        throw new HandoffError('handoff must be an object');
+    }
+    const o = obj;
+    for (const k of ENVELOPE_KEYS) {
+        if (!(k in o))
+            throw new HandoffError(`handoff missing key: ${k}`);
+    }
+    const schema = o.schema;
+    if (typeof schema !== 'string' || !(schema in contracts_js_1.HANDOFF_FILENAMES)) {
+        throw new HandoffError(`unknown schema: ${String(schema)}`);
+    }
+    const data = o.data;
+    if (!data || typeof data !== 'object') {
+        throw new HandoffError('handoff.data must be an object');
+    }
+    const required = DATA_KEYS[schema];
+    for (const k of required) {
+        if (!(k in data)) {
+            throw new HandoffError(`handoff[${schema}].data missing key: ${k}`);
+        }
+    }
+}
+function writeHandoff(projectPath, handoff) {
+    validateHandoff(handoff);
+    ensureHandoffDir(projectPath);
+    const file = handoffPath(projectPath, handoff.schema);
+    fs_1.default.writeFileSync(file, JSON.stringify(handoff, null, 2), 'utf8');
+    return file;
+}
+function readHandoff(projectPath, schema) {
+    const file = handoffPath(projectPath, schema);
+    if (!fs_1.default.existsSync(file))
+        return null;
+    const raw = fs_1.default.readFileSync(file, 'utf8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new HandoffError(`handoff file is not valid JSON: ${file}`);
+    }
+    validateHandoff(parsed);
+    if (parsed.schema !== schema) {
+        throw new HandoffError(`handoff schema mismatch: expected ${schema}, got ${parsed.schema}`);
+    }
+    return parsed;
+}
+function listHandoffs(projectPath) {
+    const d = handoffDir(projectPath);
+    if (!fs_1.default.existsSync(d))
+        return [];
+    return fs_1.default.readdirSync(d).filter((f) => f.endsWith('.json'));
+}
+function clearHandoffs(projectPath) {
+    const d = handoffDir(projectPath);
+    if (!fs_1.default.existsSync(d))
+        return 0;
+    let n = 0;
+    for (const f of fs_1.default.readdirSync(d)) {
+        if (f.endsWith('.json')) {
+            fs_1.default.unlinkSync(path_1.default.join(d, f));
+            n++;
+        }
+    }
+    return n;
+}
+function nowIso() {
+    return new Date().toISOString();
+}

package/dist/index.js

@@ -31,9 +31,6 @@ function main() {
         // ─── Registration ──────────────────────────────────────────────────────────
         // Register all modular commands
         (0, command_registry_1.registerAllCommands)(program);
-        // ─── Update Check ──────────────────────────────────────────────────────────
-        // Run update check in background (non-blocking)
-        (0, update_check_1.checkForUpdates)().catch(() => { });
         // ─── Execution ─────────────────────────────────────────────────────────────
         // Parse arguments and execute
         program.parse(process.argv);
@@ -41,6 +38,13 @@ function main() {
         if (process.argv.length <= 2) {
             program.help();
         }
+        // ─── Update Check (after command runs, non-blocking) ───────────────────────
+        // Show update notification in background after command completes
+        (0, update_check_1.checkForUpdates)().then((info) => {
+            if (info) {
+                (0, update_check_1.promptForUpgrade)(info).catch(() => { });
+            }
+        }).catch(() => { });
     });
 }
 // Error handling for uncaught exceptions

package/dist/indexer/stack-detect.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * Stack Detection Engine — scan a project root for ecosystem signals
+ * (package.json, pyproject.toml, Cargo.toml, go.mod, Gemfile) and emit
+ * a token-light suggestion list.
+ *
+ * Output is intentionally compact — designed to be embedded into the
+ * agent context at session start without bloating the budget.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectStack = detectStack;
+exports.renderStackMarkdown = renderStackMarkdown;
+exports.writeProjectSkills = writeProjectSkills;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const FRAMEWORK_TO_SKILLS = {
+    react: ['cm-design-system'],
+    next: ['cm-design-system', 'cm-safe-deploy'],
+    vue: ['cm-design-system'],
+    svelte: ['cm-design-system'],
+    vite: ['cm-design-system'],
+    express: ['cm-safe-deploy'],
+    fastify: ['cm-safe-deploy'],
+    vitest: ['cm-tdd'],
+    jest: ['cm-tdd'],
+    playwright: ['cm-browse'],
+    django: ['cm-safe-deploy'],
+    flask: ['cm-safe-deploy'],
+    fastapi: ['cm-safe-deploy'],
+    pytest: ['cm-tdd'],
+    rails: ['cm-safe-deploy'],
+    rspec: ['cm-tdd'],
+    axum: ['cm-safe-deploy'],
+    actix: ['cm-safe-deploy'],
+    gin: ['cm-safe-deploy'],
+    echo: ['cm-safe-deploy'],
+};
+const KIND_DEFAULT_SKILLS = {
+    node: ['cm-tdd', 'cm-clean-code', 'cm-quality-gate'],
+    python: ['cm-tdd', 'cm-clean-code', 'cm-quality-gate'],
+    rust: ['cm-tdd', 'cm-clean-code', 'cm-quality-gate'],
+    go: ['cm-tdd', 'cm-clean-code', 'cm-quality-gate'],
+    ruby: ['cm-tdd', 'cm-clean-code', 'cm-quality-gate'],
+    unknown: ['cm-quality-gate'],
+};
+function readText(p) {
+    try {
+        if (!fs_1.default.existsSync(p))
+            return null;
+        return fs_1.default.readFileSync(p, 'utf8');
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function safeParseJson(s) {
+    if (!s)
+        return null;
+    try {
+        return JSON.parse(s);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function detectNode(root) {
+    var _a, _b;
+    const pkg = safeParseJson(readText(path_1.default.join(root, 'package.json')));
+    if (!pkg)
+        return [];
+    const deps = Object.assign(Object.assign({}, ((_a = pkg.dependencies) !== null && _a !== void 0 ? _a : {})), ((_b = pkg.devDependencies) !== null && _b !== void 0 ? _b : {}));
+    const out = [];
+    const map = [
+        ['react', 'react'],
+        ['next', 'next'],
+        ['vue', 'vue'],
+        ['svelte', 'svelte'],
+        ['vite', 'vite'],
+        ['express', 'express'],
+        ['fastify', 'fastify'],
+        ['vitest', 'vitest'],
+        ['jest', 'jest'],
+        ['@playwright/test', 'playwright'],
+    ];
+    for (const [pkgName, fwId] of map) {
+        if (deps[pkgName]) {
+            out.push({ id: fwId, source: 'package.json', version: String(deps[pkgName]) });
+        }
+    }
+    return out;
+}
+function detectPython(root) {
+    const out = [];
+    const py = readText(path_1.default.join(root, 'pyproject.toml'));
+    const req = readText(path_1.default.join(root, 'requirements.txt'));
+    const blob = `${py !== null && py !== void 0 ? py : ''}\n${req !== null && req !== void 0 ? req : ''}`;
+    const map = [
+        [/\bdjango\b/i, 'django'],
+        [/\bflask\b/i, 'flask'],
+        [/\bfastapi\b/i, 'fastapi'],
+        [/\bpytest\b/i, 'pytest'],
+    ];
+    for (const [re, id] of map) {
+        if (re.test(blob)) {
+            out.push({ id, source: py ? 'pyproject.toml' : 'requirements.txt' });
+        }
+    }
+    return out;
+}
+function detectRust(root) {
+    const c = readText(path_1.default.join(root, 'Cargo.toml'));
+    if (!c)
+        return [];
+    const out = [];
+    if (/\baxum\s*=/.test(c))
+        out.push({ id: 'axum', source: 'Cargo.toml' });
+    if (/\bactix-web\s*=/.test(c))
+        out.push({ id: 'actix', source: 'Cargo.toml' });
+    return out;
+}
+function detectGo(root) {
+    const m = readText(path_1.default.join(root, 'go.mod'));
+    if (!m)
+        return [];
+    const out = [];
+    if (/gin-gonic\/gin/.test(m))
+        out.push({ id: 'gin', source: 'go.mod' });
+    if (/labstack\/echo/.test(m))
+        out.push({ id: 'echo', source: 'go.mod' });
+    return out;
+}
+function detectRuby(root) {
+    const g = readText(path_1.default.join(root, 'Gemfile'));
+    if (!g)
+        return [];
+    const out = [];
+    if (/['"]rails['"]/.test(g))
+        out.push({ id: 'rails', source: 'Gemfile' });
+    if (/['"]rspec['"]/.test(g))
+        out.push({ id: 'rspec', source: 'Gemfile' });
+    return out;
+}
+function detectStack(root) {
+    var _a;
+    const kinds = [];
+    if (fs_1.default.existsSync(path_1.default.join(root, 'package.json')))
+        kinds.push('node');
+    if (fs_1.default.existsSync(path_1.default.join(root, 'pyproject.toml')) ||
+        fs_1.default.existsSync(path_1.default.join(root, 'requirements.txt')))
+        kinds.push('python');
+    if (fs_1.default.existsSync(path_1.default.join(root, 'Cargo.toml')))
+        kinds.push('rust');
+    if (fs_1.default.existsSync(path_1.default.join(root, 'go.mod')))
+        kinds.push('go');
+    if (fs_1.default.existsSync(path_1.default.join(root, 'Gemfile')))
+        kinds.push('ruby');
+    if (kinds.length === 0)
+        kinds.push('unknown');
+    const frameworks = [
+        ...detectNode(root),
+        ...detectPython(root),
+        ...detectRust(root),
+        ...detectGo(root),
+        ...detectRuby(root),
+    ];
+    const suggested = new Set();
+    for (const k of kinds)
+        for (const s of KIND_DEFAULT_SKILLS[k])
+            suggested.add(s);
+    for (const f of frameworks)
+        for (const s of (_a = FRAMEWORK_TO_SKILLS[f.id]) !== null && _a !== void 0 ? _a : [])
+            suggested.add(s);
+    return {
+        root,
+        kinds,
+        frameworks,
+        suggested_skills: [...suggested].sort(),
+        generated_at: new Date().toISOString(),
+    };
+}
+/**
+ * Render the stack report as a token-light Markdown block suitable for
+ * `.cm/project-skills.md`. Caller is responsible for writing it.
+ */
+function renderStackMarkdown(r) {
+    const lines = [];
+    lines.push('# Project Stack');
+    lines.push('');
+    lines.push(`Generated: ${r.generated_at}`);
+    lines.push('');
+    lines.push(`Ecosystems: ${r.kinds.join(', ')}`);
+    if (r.frameworks.length) {
+        lines.push('');
+        lines.push('Frameworks:');
+        for (const f of r.frameworks) {
+            const v = f.version ? ` (${f.version})` : '';
+            lines.push(`- ${f.id}${v}  [${f.source}]`);
+        }
+    }
+    if (r.suggested_skills.length) {
+        lines.push('');
+        lines.push('Suggested skills:');
+        for (const s of r.suggested_skills)
+            lines.push(`- ${s}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function writeProjectSkills(root, r) {
+    const dir = path_1.default.join(root, '.cm');
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    const file = path_1.default.join(dir, 'project-skills.md');
+    fs_1.default.writeFileSync(file, renderStackMarkdown(r), 'utf8');
+    return file;
+}

package/dist/install/copy.js

@@ -0,0 +1,98 @@
+"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.copySkills = copySkills;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const paths_1 = require("./paths");
+const profiles_1 = require("./profiles");
+/**
+ * Copy skills to a target directory according to profile + format.
+ * Mirrors install.sh `install_skills_to()` behavior.
+ *
+ *  raw  → cp -r skills/cm-foo/  →  <target>/cm-foo/
+ *  md   → cp    SKILL.md         →  <target>/cm-foo.md
+ *  mdc  → wrap with frontmatter  →  <target>/cm-foo.mdc   (Cursor format)
+ */
+function copySkills(target, format, opts) {
+    const root = (0, paths_1.findCmRoot)();
+    const allow = (0, profiles_1.loadProfileAllowlist)(opts.profile, root);
+    const allSkills = (0, profiles_1.listAllSkills)(root);
+    const installed = [];
+    const skipped = [];
+    if (!opts.dryRun)
+        fs.mkdirSync(target, { recursive: true });
+    for (const skillName of allSkills) {
+        if (allow && !allow.includes(skillName)) {
+            skipped.push(skillName);
+            continue;
+        }
+        const skillDir = path.join(root, 'skills', skillName);
+        const skillMd = path.join(skillDir, 'SKILL.md');
+        if (!fs.existsSync(skillMd)) {
+            skipped.push(skillName);
+            continue;
+        }
+        if (opts.dryRun) {
+            installed.push(skillName);
+            continue;
+        }
+        if (format === 'mdc') {
+            const out = path.join(target, `${skillName}.mdc`);
+            const body = fs.readFileSync(skillMd, 'utf-8');
+            const fm = `---\ndescription: ${skillName}\nglobs: *\n---\n`;
+            fs.writeFileSync(out, fm + body);
+        }
+        else if (format === 'md') {
+            fs.copyFileSync(skillMd, path.join(target, `${skillName}.md`));
+        }
+        else {
+            copyDirRecursive(skillDir, path.join(target, skillName));
+        }
+        installed.push(skillName);
+    }
+    return { installed, skipped };
+}
+function copyDirRecursive(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const s = path.join(src, entry.name);
+        const d = path.join(dest, entry.name);
+        if (entry.isDirectory())
+            copyDirRecursive(s, d);
+        else if (entry.isFile())
+            fs.copyFileSync(s, d);
+    }
+}

package/dist/install/engine.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPlatforms = detectPlatforms;
+exports.listPlatforms = listPlatforms;
+exports.installToPlatform = installToPlatform;
+exports.installToMany = installToMany;
+const platforms_1 = require("./platforms");
+function detectPlatforms() {
+    return platforms_1.PLATFORMS.map((platform) => {
+        const r = platform.detect();
+        return { platform, installed: r.installed, detail: r.detail };
+    });
+}
+function listPlatforms() {
+    return [...platforms_1.PLATFORMS];
+}
+function installToPlatform(id, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const p = (0, platforms_1.getPlatform)(id);
+        if (!p)
+            throw new Error(`Unknown platform: ${id}. Run 'cm install --list' to see options.`);
+        return p.install(opts);
+    });
+}
+function installToMany(ids, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = [];
+        for (const id of ids) {
+            results.push(yield installToPlatform(id, opts));
+        }
+        return results;
+    });
+}

package/dist/install/paths.js

@@ -0,0 +1,70 @@
+"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.findCmRoot = findCmRoot;
+exports.homeDir = homeDir;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Locate the repository / install root that contains `skills/`.
+ * Resolves in this order:
+ *   1. Env var CM_HOME (explicit override)
+ *   2. Walk up from __dirname looking for skills/ + package.json
+ *   3. ~/.cody-master (legacy bash installer cache)
+ */
+function findCmRoot() {
+    if (process.env.CM_HOME && fs.existsSync(path.join(process.env.CM_HOME, 'skills'))) {
+        return process.env.CM_HOME;
+    }
+    let dir = __dirname;
+    for (let i = 0; i < 6; i++) {
+        if (fs.existsSync(path.join(dir, 'skills')) &&
+            fs.existsSync(path.join(dir, 'package.json'))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const fallback = path.join(home, '.cody-master');
+    if (fs.existsSync(path.join(fallback, 'skills')))
+        return fallback;
+    throw new Error('Cannot locate CodyMaster skills directory. Set CM_HOME or run from the repo root.');
+}
+function homeDir() {
+    return process.env.HOME || process.env.USERPROFILE || '';
+}

package/dist/install/platforms/_simple.js

@@ -0,0 +1,85 @@
+"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;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineSimplePlatform = defineSimplePlatform;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const paths_1 = require("../paths");
+const copy_1 = require("../copy");
+function defineSimplePlatform(cfg) {
+    return {
+        id: cfg.id,
+        name: cfg.name,
+        emoji: cfg.emoji,
+        detect() {
+            for (const p of cfg.detectPaths) {
+                const expanded = p.startsWith('~') ? path.join((0, paths_1.homeDir)(), p.slice(1)) : p;
+                if (fs.existsSync(expanded))
+                    return { installed: true, detail: p };
+            }
+            if (cfg.detectCommand) {
+                const r = require('child_process').spawnSync(cfg.detectCommand, ['--version'], { stdio: 'pipe' });
+                if (r.status === 0)
+                    return { installed: true, detail: `${cfg.detectCommand} on PATH` };
+            }
+            return { installed: false };
+        },
+        install(opts) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const target = cfg.targetPath(opts);
+                const { installed, skipped } = (0, copy_1.copySkills)(target, cfg.format, opts);
+                const hints = typeof cfg.postInstallHints === 'function'
+                    ? cfg.postInstallHints(target)
+                    : cfg.postInstallHints || [];
+                return {
+                    platform: cfg.id,
+                    installed,
+                    skipped,
+                    targetPath: target,
+                    postInstallHints: hints,
+                };
+            });
+        },
+    };
+}