youmd 0.4.4 → 0.5.0

package/dist/lib/skills.js

@@ -0,0 +1,677 @@
+"use strict";
+/**
+ * Skill engine — install, remove, resolve, sync, link.
+ *
+ * Manages the lifecycle of skills from the catalog to the filesystem.
+ * Skills are SKILL.md files with identity-aware template variables.
+ */
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSkillDir = getSkillDir;
+exports.getSkillPath = getSkillPath;
+exports.readSkillFile = readSkillFile;
+exports.resolveSkillSource = resolveSkillSource;
+exports.resolveSkillSourceAsync = resolveSkillSourceAsync;
+exports.installSkill = installSkill;
+exports.installSkillAsync = installSkillAsync;
+exports.removeSkill = removeSkill;
+exports.useSkill = useSkill;
+exports.syncAllSkills = syncAllSkills;
+exports.syncAffectedSkills = syncAffectedSkills;
+exports.linkToAgent = linkToAgent;
+exports.initProject = initProject;
+exports.trackSkillEvent = trackSkillEvent;
+exports.getMetrics = getMetrics;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const config_1 = require("./config");
+const skill_catalog_1 = require("./skill-catalog");
+const skill_renderer_1 = require("./skill-renderer");
+const config_2 = require("./config");
+const api_1 = require("./api");
+// ─── Skill File I/O ───────────────────────────────────────────────────
+/**
+ * Get the directory for an installed skill.
+ */
+function getSkillDir(skillName) {
+    return path.join((0, config_1.getSkillsDir)(), skillName);
+}
+/**
+ * Get the SKILL.md path for an installed skill.
+ */
+function getSkillPath(skillName) {
+    return path.join(getSkillDir(skillName), "SKILL.md");
+}
+/**
+ * Read a skill's SKILL.md content and frontmatter.
+ */
+function readSkillFile(skillName) {
+    const skillPath = getSkillPath(skillName);
+    if (!fs.existsSync(skillPath))
+        return null;
+    try {
+        const raw = fs.readFileSync(skillPath, "utf-8");
+        const { data, content } = (0, gray_matter_1.default)(raw);
+        return { content: content.trim(), metadata: data };
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Source Resolution ────────────────────────────────────────────────
+/**
+ * Resolve a skill source to its raw markdown content.
+ *
+ * Supported sources:
+ *   bundled:path/to/file.md — relative to repo root
+ *   local:/absolute/path.md — local filesystem
+ *   github:owner/repo/path  — (future) GitHub raw content
+ */
+function resolveSkillSource(source) {
+    if (source.startsWith("bundled:")) {
+        const relativePath = source.slice("bundled:".length);
+        const filename = path.basename(relativePath);
+        // Priority 1: cli/skills/ directory (npm package ships these)
+        const pkgRoot = path.resolve(__dirname, "..", "..");
+        const pkgSkillsPath = path.join(pkgRoot, "skills", filename);
+        if (fs.existsSync(pkgSkillsPath)) {
+            return fs.readFileSync(pkgSkillsPath, "utf-8");
+        }
+        // Priority 2: repo root (development mode)
+        const repoRoot = path.resolve(__dirname, "..", "..", "..");
+        const repoPath = path.join(repoRoot, relativePath);
+        if (fs.existsSync(repoPath)) {
+            return fs.readFileSync(repoPath, "utf-8");
+        }
+        // Priority 3: relative to package root
+        const altPath = path.join(pkgRoot, relativePath);
+        if (fs.existsSync(altPath)) {
+            return fs.readFileSync(altPath, "utf-8");
+        }
+        return null;
+    }
+    if (source.startsWith("local:")) {
+        const filePath = source.slice("local:".length);
+        if (fs.existsSync(filePath)) {
+            return fs.readFileSync(filePath, "utf-8");
+        }
+        return null;
+    }
+    // Plain file path
+    if (fs.existsSync(source)) {
+        return fs.readFileSync(source, "utf-8");
+    }
+    return null;
+}
+/**
+ * Async source resolver — handles remote sources (GitHub).
+ *
+ * github:owner/repo/path → https://raw.githubusercontent.com/owner/repo/main/path
+ * Also supports full https:// URLs to raw markdown files.
+ */
+async function resolveSkillSourceAsync(source) {
+    // Try sync first (bundled, local, file path)
+    const syncResult = resolveSkillSource(source);
+    if (syncResult)
+        return syncResult;
+    // GitHub: github:owner/repo/path/to/file.md
+    if (source.startsWith("github:")) {
+        const ghPath = source.slice("github:".length);
+        const parts = ghPath.split("/");
+        if (parts.length < 3)
+            return null;
+        const owner = parts[0];
+        const repo = parts[1];
+        const filePath = parts.slice(2).join("/");
+        // Try main, then master
+        for (const branch of ["main", "master"]) {
+            const url = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${filePath}`;
+            try {
+                const res = await fetch(url);
+                if (res.ok) {
+                    return await res.text();
+                }
+            }
+            catch {
+                // try next branch
+            }
+        }
+        return null;
+    }
+    // Direct HTTPS URL to raw markdown
+    if (source.startsWith("https://") || source.startsWith("http://")) {
+        try {
+            const res = await fetch(source);
+            if (res.ok) {
+                return await res.text();
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+// ─── Install / Remove ─────────────────────────────────────────────────
+/**
+ * Install a skill from its source to ~/.youmd/skills/<name>/SKILL.md.
+ * Uses sync resolution for local/bundled, falls back to async for remote.
+ */
+function installSkill(skillName) {
+    const catalog = (0, skill_catalog_1.readSkillCatalog)();
+    const entry = (0, skill_catalog_1.findSkill)(catalog, skillName);
+    if (!entry) {
+        return { ok: false, error: `skill "${skillName}" not found in catalog` };
+    }
+    // Resolve source (sync only — async handled by installSkillAsync)
+    const content = resolveSkillSource(entry.source);
+    if (!content) {
+        // If source is remote, caller should use installSkillAsync instead
+        if (entry.source.startsWith("github:") || entry.source.startsWith("https://")) {
+            return { ok: false, error: `remote source — use installSkillAsync for: ${entry.source}` };
+        }
+        return { ok: false, error: `could not resolve source: ${entry.source}` };
+    }
+    // Create skill directory and write SKILL.md
+    const skillDir = getSkillDir(entry.name);
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, "SKILL.md"), content);
+    // Render an interpolated version alongside the raw one
+    const identity = (0, skill_renderer_1.loadIdentityData)();
+    const rendered = (0, skill_renderer_1.renderSkillTemplate)(content, identity);
+    fs.writeFileSync(path.join(skillDir, "RENDERED.md"), rendered);
+    // Mark installed in catalog
+    (0, skill_catalog_1.setSkillInstalled)(catalog, entry.name, true);
+    // Track metrics
+    trackSkillEvent(entry.name, "install");
+    // Sync to Convex (non-blocking)
+    syncInstallToRemote(entry);
+    return { ok: true };
+}
+/**
+ * Async install — handles remote sources (GitHub, HTTPS URLs).
+ */
+async function installSkillAsync(skillName) {
+    const catalog = (0, skill_catalog_1.readSkillCatalog)();
+    const entry = (0, skill_catalog_1.findSkill)(catalog, skillName);
+    if (!entry) {
+        return { ok: false, error: `skill "${skillName}" not found in catalog` };
+    }
+    // Try sync first
+    let content = resolveSkillSource(entry.source);
+    // Fall back to async
+    if (!content) {
+        content = await resolveSkillSourceAsync(entry.source);
+    }
+    if (!content) {
+        return { ok: false, error: `could not resolve source: ${entry.source}` };
+    }
+    const skillDir = getSkillDir(entry.name);
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, "SKILL.md"), content);
+    const identity = (0, skill_renderer_1.loadIdentityData)();
+    const rendered = (0, skill_renderer_1.renderSkillTemplate)(content, identity);
+    fs.writeFileSync(path.join(skillDir, "RENDERED.md"), rendered);
+    (0, skill_catalog_1.setSkillInstalled)(catalog, entry.name, true);
+    trackSkillEvent(entry.name, "install");
+    syncInstallToRemote(entry);
+    return { ok: true };
+}
+/**
+ * Remove an installed skill.
+ */
+function removeSkill(skillName) {
+    const catalog = (0, skill_catalog_1.readSkillCatalog)();
+    const entry = (0, skill_catalog_1.findSkill)(catalog, skillName);
+    if (!entry) {
+        return { ok: false, error: `skill "${skillName}" not found in catalog` };
+    }
+    const skillDir = getSkillDir(entry.name);
+    if (fs.existsSync(skillDir)) {
+        fs.rmSync(skillDir, { recursive: true, force: true });
+    }
+    (0, skill_catalog_1.setSkillInstalled)(catalog, entry.name, false);
+    trackSkillEvent(entry.name, "remove");
+    // Sync removal to Convex (non-blocking, log failures)
+    if ((0, config_2.isAuthenticated)()) {
+        (0, api_1.removeSkillInstall)(entry.name).catch((err) => {
+            // Non-fatal: remote sync failed but local removal succeeded
+            if (process.env.DEBUG)
+                console.error(`[skill sync] remove failed: ${err}`);
+        });
+    }
+    return { ok: true };
+}
+// ─── Use / Render ─────────────────────────────────────────────────────
+/**
+ * Use a skill — render it with current identity data.
+ * Returns the rendered content.
+ */
+function useSkill(skillName) {
+    const catalog = (0, skill_catalog_1.readSkillCatalog)();
+    const entry = (0, skill_catalog_1.findSkill)(catalog, skillName);
+    if (!entry) {
+        return { ok: false, error: `skill "${skillName}" not found in catalog` };
+    }
+    // Install if not already
+    if (!entry.installed) {
+        const installResult = installSkill(skillName);
+        if (!installResult.ok)
+            return installResult;
+    }
+    const skillFile = readSkillFile(entry.name);
+    if (!skillFile) {
+        return { ok: false, error: `could not read SKILL.md for "${skillName}"` };
+    }
+    const identity = (0, skill_renderer_1.loadIdentityData)();
+    const readiness = (0, skill_renderer_1.checkTemplateReadiness)(skillFile.content, identity);
+    const rendered = (0, skill_renderer_1.renderSkillTemplate)(skillFile.content, identity);
+    // Update rendered version
+    const skillDir = getSkillDir(entry.name);
+    fs.writeFileSync(path.join(skillDir, "RENDERED.md"), rendered);
+    trackSkillEvent(entry.name, "use");
+    // Sync usage to Convex (non-blocking, log failures)
+    if ((0, config_2.isAuthenticated)()) {
+        (0, api_1.trackSkillUsage)(entry.name).catch((err) => {
+            if (process.env.DEBUG)
+                console.error(`[skill sync] usage tracking failed: ${err}`);
+        });
+    }
+    return { ok: true, content: rendered, readiness };
+}
+// ─── Sync ─────────────────────────────────────────────────────────────
+/**
+ * Re-interpolate all installed skills against current identity data.
+ */
+function syncAllSkills() {
+    const catalog = (0, skill_catalog_1.readSkillCatalog)();
+    const identity = (0, skill_renderer_1.loadIdentityData)();
+    const synced = [];
+    const errors = [];
+    for (const entry of catalog.skills) {
+        if (!entry.installed)
+            continue;
+        const skillFile = readSkillFile(entry.name);
+        if (!skillFile) {
+            errors.push(`${entry.name}: SKILL.md not found`);
+            continue;
+        }
+        try {
+            const rendered = (0, skill_renderer_1.renderSkillTemplate)(skillFile.content, identity);
+            const skillDir = getSkillDir(entry.name);
+            fs.writeFileSync(path.join(skillDir, "RENDERED.md"), rendered);
+            synced.push(entry.name);
+        }
+        catch (err) {
+            errors.push(`${entry.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return { synced, errors };
+}
+/**
+ * Sync only skills affected by specific identity field changes.
+ */
+function syncAffectedSkills(changedFields) {
+    const catalog = (0, skill_catalog_1.readSkillCatalog)();
+    const identity = (0, skill_renderer_1.loadIdentityData)();
+    const synced = [];
+    const errors = [];
+    const affected = catalog.skills.filter((s) => s.installed && s.identity_fields.some((f) => changedFields.includes(f)));
+    for (const entry of affected) {
+        const skillFile = readSkillFile(entry.name);
+        if (!skillFile) {
+            errors.push(`${entry.name}: SKILL.md not found`);
+            continue;
+        }
+        try {
+            const rendered = (0, skill_renderer_1.renderSkillTemplate)(skillFile.content, identity);
+            const skillDir = getSkillDir(entry.name);
+            fs.writeFileSync(path.join(skillDir, "RENDERED.md"), rendered);
+            synced.push(entry.name);
+        }
+        catch (err) {
+            errors.push(`${entry.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return { synced, errors };
+}
+/**
+ * Link installed skills to an agent's directory.
+ *
+ * claude → .claude/skills/youmd/
+ * cursor → .cursor/rules/youmd.md (single file concatenation)
+ * codex  → .codex/skills/youmd/
+ */
+function linkToAgent(target) {
+    const catalog = (0, skill_catalog_1.readSkillCatalog)();
+    const installedSkills = catalog.skills.filter((s) => s.installed);
+    if (installedSkills.length === 0) {
+        return { ok: false, error: "no skills installed. run: youmd skill install <name>" };
+    }
+    const cwd = process.cwd();
+    switch (target) {
+        case "claude": {
+            const targetDir = path.join(cwd, ".claude", "skills", "youmd");
+            fs.mkdirSync(targetDir, { recursive: true });
+            for (const entry of installedSkills) {
+                const rendered = getRenderedContent(entry.name);
+                if (rendered) {
+                    fs.writeFileSync(path.join(targetDir, `${entry.name}.md`), rendered);
+                }
+            }
+            return { ok: true, path: targetDir };
+        }
+        case "cursor": {
+            const targetDir = path.join(cwd, ".cursor", "rules");
+            fs.mkdirSync(targetDir, { recursive: true });
+            // Cursor prefers a single concatenated file
+            const parts = [];
+            parts.push("# You.md Identity Skills\n");
+            parts.push(`> Auto-generated by youmd skill link. Do not edit manually.\n`);
+            for (const entry of installedSkills) {
+                const rendered = getRenderedContent(entry.name);
+                if (rendered) {
+                    parts.push(`\n---\n\n## ${entry.name}\n\n${rendered}`);
+                }
+            }
+            const outPath = path.join(targetDir, "youmd.md");
+            fs.writeFileSync(outPath, parts.join("\n"));
+            return { ok: true, path: outPath };
+        }
+        case "codex": {
+            const targetDir = path.join(cwd, ".codex", "skills", "youmd");
+            fs.mkdirSync(targetDir, { recursive: true });
+            for (const entry of installedSkills) {
+                const rendered = getRenderedContent(entry.name);
+                if (rendered) {
+                    fs.writeFileSync(path.join(targetDir, `${entry.name}.md`), rendered);
+                }
+            }
+            return { ok: true, path: targetDir };
+        }
+        default:
+            return { ok: false, error: `unknown agent target: ${target}` };
+    }
+}
+function getRenderedContent(skillName) {
+    const renderedPath = path.join(getSkillDir(skillName), "RENDERED.md");
+    if (fs.existsSync(renderedPath)) {
+        return fs.readFileSync(renderedPath, "utf-8");
+    }
+    // Fallback: render on the fly
+    const skillFile = readSkillFile(skillName);
+    if (!skillFile)
+        return null;
+    return (0, skill_renderer_1.renderSkillTemplate)(skillFile.content);
+}
+// ─── Init Project (Compound Command) ─────────────────────────────────
+/**
+ * Initialize a project with skills: install core skills, generate CLAUDE.md,
+ * scaffold project-context/, and link to .claude/skills/.
+ */
+function initProject() {
+    const steps = [];
+    const project = (0, config_1.detectProjectContext)();
+    const cwd = process.cwd();
+    // Step 1: Install core skills
+    for (const name of ["claude-md-generator", "project-context-init"]) {
+        const result = installSkill(name);
+        steps.push({
+            name: `install ${name}`,
+            ok: result.ok,
+            detail: result.error,
+        });
+    }
+    // Step 2: Generate or merge CLAUDE.md
+    const identity = (0, skill_renderer_1.loadIdentityData)();
+    const projectName = project?.name || path.basename(cwd);
+    const claudeMdPath = path.join(cwd, "CLAUDE.md");
+    if (fs.existsSync(claudeMdPath)) {
+        // Merge: append identity section if not already present
+        const existing = fs.readFileSync(claudeMdPath, "utf-8");
+        const IDENTITY_MARKER = "<!-- youmd:identity -->";
+        if (existing.includes(IDENTITY_MARKER)) {
+            steps.push({ name: "CLAUDE.md", ok: true, detail: "identity section already present" });
+        }
+        else {
+            const identitySection = generateIdentitySection(identity);
+            if (identitySection) {
+                fs.writeFileSync(claudeMdPath, existing.trimEnd() + "\n\n" + identitySection);
+                steps.push({ name: "CLAUDE.md", ok: true, detail: "identity section appended" });
+            }
+            else {
+                steps.push({ name: "CLAUDE.md", ok: true, detail: "exists, no identity data to add" });
+            }
+        }
+    }
+    else {
+        const claudeMd = generateClaudeMd(identity, projectName);
+        fs.writeFileSync(claudeMdPath, claudeMd);
+        steps.push({ name: "CLAUDE.md", ok: true, detail: "generated" });
+    }
+    // Step 3: Scaffold project-context/
+    const pcDir = path.join(cwd, "project-context");
+    if (fs.existsSync(pcDir)) {
+        steps.push({ name: "project-context/", ok: true, detail: "already exists, skipped" });
+    }
+    else {
+        scaffoldProjectContext(pcDir, identity, project?.name || path.basename(cwd));
+        steps.push({ name: "project-context/", ok: true, detail: "scaffolded" });
+    }
+    // Step 4: Link to .claude/skills/
+    const linkResult = linkToAgent("claude");
+    steps.push({
+        name: "link .claude/skills/youmd/",
+        ok: linkResult.ok,
+        detail: linkResult.error || linkResult.path,
+    });
+    // Step 5: Also link to Cursor if .cursor/ exists
+    if (fs.existsSync(path.join(cwd, ".cursor"))) {
+        const cursorResult = linkToAgent("cursor");
+        steps.push({
+            name: "link .cursor/rules/youmd.md",
+            ok: cursorResult.ok,
+            detail: cursorResult.error || cursorResult.path,
+        });
+    }
+    return { ok: steps.every((s) => s.ok), steps };
+}
+function generateClaudeMd(identity, projectName) {
+    const parts = [];
+    parts.push(`# ${projectName} — Coding Agent Operating Manual\n`);
+    parts.push(`> Generated by You.md skill system. Powered by your identity context.\n`);
+    if (identity.profile.about) {
+        parts.push(`\n## Who You're Working With\n\n${identity.profile.about}\n`);
+    }
+    if (identity.preferences.agent) {
+        parts.push(`\n## Agent Preferences\n\n${identity.preferences.agent}\n`);
+    }
+    if (identity.directives.agent) {
+        parts.push(`\n## Directives\n\n${identity.directives.agent}\n`);
+    }
+    if (identity.voice.overall) {
+        parts.push(`\n## Voice & Communication\n\n${identity.voice.overall}\n`);
+    }
+    parts.push(`\n## Project\n\n- **Name:** ${projectName}\n`);
+    // Detect stack
+    const cwd = process.cwd();
+    const stackHints = [];
+    if (fs.existsSync(path.join(cwd, "package.json"))) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+            if (pkg.dependencies?.next)
+                stackHints.push("Next.js");
+            if (pkg.dependencies?.react)
+                stackHints.push("React");
+            if (pkg.dependencies?.typescript || pkg.devDependencies?.typescript)
+                stackHints.push("TypeScript");
+            if (pkg.dependencies?.convex)
+                stackHints.push("Convex");
+        }
+        catch { /* skip */ }
+    }
+    if (fs.existsSync(path.join(cwd, "Cargo.toml")))
+        stackHints.push("Rust");
+    if (fs.existsSync(path.join(cwd, "go.mod")))
+        stackHints.push("Go");
+    if (fs.existsSync(path.join(cwd, "pyproject.toml")))
+        stackHints.push("Python");
+    if (stackHints.length > 0) {
+        parts.push(`- **Stack:** ${stackHints.join(", ")}\n`);
+    }
+    return parts.join("\n");
+}
+/**
+ * Generate an identity section to append to an existing CLAUDE.md.
+ * Returns null if no identity data is available.
+ */
+function generateIdentitySection(identity) {
+    const sections = [];
+    if (identity.profile.about) {
+        sections.push(`## Who You're Working With\n\n${identity.profile.about}`);
+    }
+    if (identity.preferences.agent) {
+        sections.push(`## Agent Preferences\n\n${identity.preferences.agent}`);
+    }
+    if (identity.directives.agent) {
+        sections.push(`## Directives\n\n${identity.directives.agent}`);
+    }
+    if (identity.voice.overall) {
+        sections.push(`## Voice & Communication\n\n${identity.voice.overall}`);
+    }
+    if (sections.length === 0)
+        return null;
+    return [
+        "<!-- youmd:identity -->",
+        "<!-- Auto-generated by You.md skill system. Re-run `youmd skill init-project` to update. -->",
+        "",
+        "---",
+        "",
+        "# You.md Identity Context",
+        "",
+        ...sections,
+        "",
+    ].join("\n");
+}
+function scaffoldProjectContext(dir, identity, projectName) {
+    fs.mkdirSync(dir, { recursive: true });
+    const owner = identity.username || "you";
+    const date = new Date().toISOString().slice(0, 10);
+    const files = {
+        "PRD.md": `# ${projectName} — Product Requirements\n\n> Owner: ${owner}\n> Created: ${date}\n\n## Vision\n\n(describe the product vision)\n\n## User Journeys\n\n(describe key user flows)\n`,
+        "TODO.md": `# ${projectName} — Task Tracking\n\n> Updated: ${date}\n\n## In Progress\n\n## Up Next\n\n## Done\n`,
+        "FEATURES.md": `# ${projectName} — Feature Inventory\n\n> Updated: ${date}\n\n| Feature | Status | Notes |\n|---|---|---|\n`,
+        "CHANGELOG.md": `# ${projectName} — Changelog\n\n## ${date}\n\n- Project initialized with You.md skill system\n`,
+        "ARCHITECTURE.md": `# ${projectName} — Architecture\n\n> Updated: ${date}\n\n## Overview\n\n(describe system architecture)\n\n## Stack\n\n(list technologies)\n`,
+        "CURRENT_STATE.md": `# ${projectName} — Current State\n\n> Updated: ${date}\n\n## Deployed\n\n## Known Issues\n\n## Next Priorities\n`,
+        "STYLE_GUIDE.md": `# ${projectName} — Style Guide\n\n> Updated: ${date}\n\n(describe design system, colors, typography)\n`,
+        "feature-requests-active.md": `# ${projectName} — Active Feature Requests\n\n> Updated: ${date}\n\n| Request | Status | Source | Notes |\n|---|---|---|---|\n`,
+    };
+    for (const [filename, content] of Object.entries(files)) {
+        const filePath = path.join(dir, filename);
+        if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, content);
+        }
+    }
+}
+// ─── Remote Sync (non-blocking) ───────────────────────────────────────
+/**
+ * Sync a local skill install to Convex. Fire-and-forget.
+ */
+function syncInstallToRemote(entry) {
+    if (!(0, config_2.isAuthenticated)())
+        return;
+    (0, api_1.recordSkillInstall)({
+        skillName: entry.name,
+        source: entry.source,
+        scope: entry.scope,
+        identityFields: entry.identity_fields,
+    }).catch((err) => {
+        if (process.env.DEBUG)
+            console.error(`[skill sync] install sync failed: ${err}`);
+    });
+}
+function readMetrics() {
+    const metricsPath = (0, config_1.getSkillMetricsPath)();
+    if (fs.existsSync(metricsPath)) {
+        try {
+            return JSON.parse(fs.readFileSync(metricsPath, "utf-8"));
+        }
+        catch {
+            // reset
+        }
+    }
+    return { skills: {}, identityFields: {}, lastUpdated: new Date().toISOString() };
+}
+function writeMetrics(metrics) {
+    (0, config_1.ensureSkillsDir)();
+    metrics.lastUpdated = new Date().toISOString();
+    fs.writeFileSync((0, config_1.getSkillMetricsPath)(), JSON.stringify(metrics, null, 2) + "\n");
+}
+function trackSkillEvent(skillName, event) {
+    const metrics = readMetrics();
+    if (!metrics.skills[skillName]) {
+        metrics.skills[skillName] = { uses: 0, installs: 0, lastUsed: "" };
+    }
+    const now = new Date().toISOString();
+    if (event === "use") {
+        metrics.skills[skillName].uses++;
+        metrics.skills[skillName].lastUsed = now;
+    }
+    else if (event === "install") {
+        metrics.skills[skillName].installs++;
+        metrics.skills[skillName].lastInstalled = now;
+    }
+    // Track identity field references from the skill's catalog entry
+    const catalog = (0, skill_catalog_1.readSkillCatalog)();
+    const entry = (0, skill_catalog_1.findSkill)(catalog, skillName);
+    if (entry && event === "use") {
+        for (const field of entry.identity_fields) {
+            if (!metrics.identityFields[field]) {
+                metrics.identityFields[field] = { references: 0 };
+            }
+            metrics.identityFields[field].references++;
+        }
+    }
+    writeMetrics(metrics);
+}
+function getMetrics() {
+    return readMetrics();
+}
+//# sourceMappingURL=skills.js.map