youmd 0.4.9 → 0.6.0

package/dist/lib/skills.js

@@ -0,0 +1,876 @@
+"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.
+    // Cycle 53: was previously accepting http:// as well. Skill installs are
+    // executable content — fetching them over insecure HTTP allows MITM
+    // injection of malicious skill code. HTTPS-only.
+    if (source.startsWith("https://")) {
+        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, warn on failure)
+    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, warn on failure)
+    if ((0, config_2.isAuthenticated)()) {
+        (0, api_1.removeSkillInstall)(entry.name).catch((err) => {
+            const chalk = require("chalk");
+            console.log(chalk.dim(`  sync: ${entry.name} remote removal sync failed (non-fatal)`));
+            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, warn on failure)
+    if ((0, config_2.isAuthenticated)()) {
+        (0, api_1.trackSkillUsage)(entry.name).catch((err) => {
+            const chalk = require("chalk");
+            console.log(chalk.dim(`  sync: usage tracking failed for ${entry.name} (non-fatal)`));
+            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) ─────────────────────────────────
+const BOOTSTRAP_START = "<!-- youmd:bootstrap:start -->";
+const BOOTSTRAP_END = "<!-- youmd:bootstrap:end -->";
+/**
+ * Initialize a project with additive agent bootstrap files, scaffolded
+ * project-context docs, a generated .you layer, and host-linked skills.
+ */
+function initProject(options = {}) {
+    const steps = [];
+    const project = (0, config_1.detectProjectContext)();
+    const cwd = process.cwd();
+    const identity = (0, skill_renderer_1.loadIdentityData)();
+    const projectName = project?.name || path.basename(cwd);
+    const agentsPath = path.join(cwd, "AGENTS.md");
+    const claudePath = path.join(cwd, "CLAUDE.md");
+    const projectContextDir = path.join(cwd, "project-context");
+    const youDir = path.join(cwd, ".you");
+    const requestedMode = options.mode ?? "auto";
+    const resolvedMode = resolveInitProjectMode({
+        mode: requestedMode,
+        hasAgentFile: fs.existsSync(agentsPath),
+        hasClaudeFile: fs.existsSync(claudePath),
+        hasProjectContext: fs.existsSync(projectContextDir),
+    });
+    // Step 1: Install core skills that power the generated layer
+    for (const name of ["claude-md-generator", "project-context-init"]) {
+        const result = installSkill(name);
+        steps.push({
+            name: `install ${name}`,
+            ok: result.ok,
+            detail: result.ok ? "ready" : result.error,
+        });
+    }
+    // Step 2: Create/update the generated .you layer
+    const youResult = scaffoldYouLayer(youDir, identity, projectName);
+    steps.push({
+        name: ".you/",
+        ok: true,
+        detail: youResult,
+    });
+    // Step 3: Scaffold or update first-class entrypoints
+    if (resolvedMode === "zero-touch") {
+        steps.push({
+            name: "top-level agent files",
+            ok: true,
+            detail: "zero-touch mode — left AGENTS.md and CLAUDE.md unchanged",
+        });
+    }
+    else {
+        const agentResult = ensureAgentInstructionFiles({
+            cwd,
+            projectName,
+            identity,
+        });
+        steps.push({
+            name: "agent instruction files",
+            ok: true,
+            detail: agentResult,
+        });
+    }
+    // Step 4: Scaffold the canonical project-context/ directory
+    if (resolvedMode === "zero-touch") {
+        steps.push({
+            name: "project-context/",
+            ok: true,
+            detail: "zero-touch mode — left canonical project-context untouched",
+        });
+    }
+    else {
+        const scaffolded = scaffoldProjectContext(projectContextDir, identity, projectName);
+        steps.push({
+            name: "project-context/",
+            ok: true,
+            detail: scaffolded,
+        });
+    }
+    // Step 5: Link rendered skills into host-specific discovery paths
+    const linkTargets = ["claude"];
+    if (fs.existsSync(path.join(cwd, ".cursor")))
+        linkTargets.push("cursor");
+    if (fs.existsSync(path.join(cwd, ".codex")))
+        linkTargets.push("codex");
+    for (const target of linkTargets) {
+        const result = linkToAgent(target);
+        const label = target === "claude"
+            ? "link .claude/skills/youmd/"
+            : target === "cursor"
+                ? "link .cursor/rules/youmd.md"
+                : "link .codex/skills/youmd/";
+        steps.push({
+            name: label,
+            ok: result.ok,
+            detail: result.error || result.path,
+        });
+    }
+    return { ok: steps.every((s) => s.ok), mode: resolvedMode, steps };
+}
+function resolveInitProjectMode(args) {
+    if (args.mode !== "auto")
+        return args.mode;
+    if (!args.hasAgentFile && !args.hasClaudeFile && !args.hasProjectContext) {
+        return "scaffold";
+    }
+    return "additive";
+}
+function generateAgentMd(identity, projectName) {
+    const parts = [];
+    parts.push(`# ${projectName} — Agent Operating Manual\n`);
+    parts.push(`> Bootstrapped by You.md. This is the repo-visible instruction layer agents should read first.\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## Workflow\n`);
+    parts.push(`- Read \`project-context/CURRENT_STATE.md\` and \`project-context/feature-requests-active.md\` before substantial work.\n`);
+    parts.push(`- Track multi-part user asks in \`project-context/feature-requests-active.md\` rather than silently handling only part of the request.\n`);
+    parts.push(`- Treat updates to \`project-context/TODO.md\`, \`FEATURES.md\`, \`CHANGELOG.md\`, \`feature-requests-active.md\`, and \`PROMPTS.md\` as part of "done" after meaningful development sessions.\n`);
+    parts.push(`- Read \`.you/AGENT.md\`, \`.you/STACK-MAP.md\`, and \`.you/project-context/\` for additive You.md-generated context.\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");
+}
+function generateClaudeMd(projectName) {
+    return [
+        `# ${projectName} — Claude Entry Point`,
+        "",
+        "> This repo uses `AGENTS.md` as the canonical human-owned instruction layer.",
+        "> Read `AGENTS.md`, `project-context/`, and `.you/` before substantial work.",
+        "",
+    ].join("\n");
+}
+/**
+ * Generate an additive managed bootstrap block for existing top-level
+ * instruction files without rewriting user-owned content.
+ */
+function generateBootstrapBlock(target, includeCompanion) {
+    const companionLine = includeCompanion && target === "CLAUDE.md"
+        ? "- Also read `AGENTS.md` for repo-native operating instructions.\n"
+        : includeCompanion && target === "AGENTS.md"
+            ? "- Keep `CLAUDE.md` as the Claude-specific entrypoint if this repo uses it.\n"
+            : "";
+    return [
+        BOOTSTRAP_START,
+        `<!-- Auto-generated by You.md. Re-run \`youmd skill init-project\` to refresh this managed block. -->`,
+        "",
+        "## You.md Bootstrap",
+        "",
+        "- Read `project-context/CURRENT_STATE.md` and `project-context/feature-requests-active.md` before substantial work.",
+        "- Track multi-part asks in `project-context/feature-requests-active.md` rather than silently handling only one part.",
+        "- Treat updates to `project-context/TODO.md`, `FEATURES.md`, `CHANGELOG.md`, `feature-requests-active.md`, and `PROMPTS.md` as part of done after meaningful development sessions.",
+        "- Read `.you/AGENT.md`, `.you/STACK-MAP.md`, and `.you/project-context/` for additive You.md-generated context.",
+        companionLine.trimEnd(),
+        "",
+        BOOTSTRAP_END,
+        "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function upsertManagedBootstrap(existing, target, includeCompanion) {
+    const block = generateBootstrapBlock(target, includeCompanion).trim();
+    const pattern = new RegExp(`${escapeRegex(BOOTSTRAP_START)}[\\s\\S]*?${escapeRegex(BOOTSTRAP_END)}`, "m");
+    if (pattern.test(existing)) {
+        const replaced = existing.replace(pattern, block);
+        return {
+            content: replaced === existing ? existing : replaced,
+            status: replaced === existing ? "unchanged" : "updated",
+        };
+    }
+    const trimmed = existing.trimEnd();
+    return {
+        content: trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`,
+        status: "added",
+    };
+}
+function ensureAgentInstructionFiles(args) {
+    const agentsPath = path.join(args.cwd, "AGENTS.md");
+    const claudePath = path.join(args.cwd, "CLAUDE.md");
+    const hasAgents = fs.existsSync(agentsPath);
+    const hasClaude = fs.existsSync(claudePath);
+    const notes = [];
+    if (!hasAgents) {
+        fs.writeFileSync(agentsPath, generateAgentMd(args.identity, args.projectName));
+        notes.push("created AGENTS.md");
+    }
+    else {
+        const existing = fs.readFileSync(agentsPath, "utf-8");
+        const update = upsertManagedBootstrap(existing, "AGENTS.md", hasClaude);
+        fs.writeFileSync(agentsPath, update.content);
+        notes.push(`${update.status} AGENTS.md bootstrap`);
+    }
+    if (!hasClaude) {
+        fs.writeFileSync(claudePath, `${generateClaudeMd(args.projectName)}\n${generateBootstrapBlock("CLAUDE.md", true)}`);
+        notes.push("created CLAUDE.md");
+    }
+    else {
+        const existing = fs.readFileSync(claudePath, "utf-8");
+        const update = upsertManagedBootstrap(existing, "CLAUDE.md", true);
+        fs.writeFileSync(claudePath, update.content);
+        notes.push(`${update.status} CLAUDE.md bootstrap`);
+    }
+    return notes.join("; ");
+}
+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`,
+        "PROMPTS.md": `# ${projectName} — Prompt Archive\n\n> Updated: ${date}\n> Total sessions: 0\n> Total prompts: 0\n\n## Notes\n\nAppend user messages here after each development session so future agents can search exact wording.\n`,
+    };
+    const created = [];
+    const skipped = [];
+    for (const [filename, content] of Object.entries(files)) {
+        const filePath = path.join(dir, filename);
+        if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, content);
+            created.push(filename);
+        }
+        else {
+            skipped.push(filename);
+        }
+    }
+    if (created.length === 0) {
+        return `all canonical files already present (${skipped.length} checked)`;
+    }
+    return `created ${created.length} file(s): ${created.join(", ")}`;
+}
+function scaffoldYouLayer(dir, identity, projectName) {
+    const projectContextDir = path.join(dir, "project-context");
+    fs.mkdirSync(projectContextDir, { recursive: true });
+    const writes = [
+        [path.join(dir, "AGENT.md"), generateYouAgentMd(identity, projectName)],
+        [path.join(dir, "STACK-MAP.md"), generateStackMap(projectName)],
+        [
+            path.join(projectContextDir, "README.md"),
+            generateYouProjectContextReadme(projectName),
+        ],
+    ];
+    const created = [];
+    const updated = [];
+    for (const [filePath, content] of writes) {
+        const existed = fs.existsSync(filePath);
+        fs.writeFileSync(filePath, content);
+        (existed ? updated : created).push(path.relative(dir, filePath));
+    }
+    const parts = [];
+    if (created.length > 0)
+        parts.push(`created ${created.join(", ")}`);
+    if (updated.length > 0)
+        parts.push(`updated ${updated.join(", ")}`);
+    return parts.join("; ");
+}
+function generateYouAgentMd(identity, projectName) {
+    const lines = [
+        `# You.md Generated Agent Context`,
+        "",
+        `> This is the You.md-owned additive layer for \`${projectName}\`. Top-level repo files stay user-owned.`,
+        "",
+        "## Purpose",
+        "",
+        "- Provide additive identity and workflow context without overwriting human-maintained docs.",
+        "- Keep cross-agent expectations consistent across Claude, Codex, Cursor, and similar tools.",
+        "",
+    ];
+    if (identity.profile.about) {
+        lines.push("## Identity", "", identity.profile.about, "");
+    }
+    if (identity.preferences.agent) {
+        lines.push("## Agent Preferences", "", identity.preferences.agent, "");
+    }
+    if (identity.directives.agent) {
+        lines.push("## Directives", "", identity.directives.agent, "");
+    }
+    if (identity.voice.overall) {
+        lines.push("## Voice", "", identity.voice.overall, "");
+    }
+    lines.push("## Operating Expectations", "");
+    lines.push("- Read the repo-visible instruction file(s) first.");
+    lines.push("- Treat `project-context/` as the canonical shared working context.");
+    lines.push("- Use this `.you/` layer as additive guidance and generated metadata, not as a replacement for repo-owned docs.");
+    lines.push("");
+    return lines.join("\n");
+}
+function generateStackMap(projectName) {
+    return [
+        "# You.md Stack Map",
+        "",
+        `> Generated for \`${projectName}\`. This file explains what You.md owns versus what the repo/user owns.`,
+        "",
+        "## Ownership",
+        "",
+        "- `AGENTS.md` / `CLAUDE.md`: human-owned entrypoints with a managed additive You.md bootstrap block.",
+        "- `project-context/`: canonical shared repo context. You.md only fills missing files unless a human explicitly asks for deeper changes.",
+        "- `.you/`: You.md-owned generated layer for additive cross-agent context.",
+        "- `.claude/skills/youmd`, `.codex/skills/youmd`, `.cursor/rules/youmd.md`: host-specific rendered skill surfaces when linked.",
+        "",
+        "## Maintenance Rules",
+        "",
+        "- Update only the managed You.md block inside top-level instruction files.",
+        "- Never delete or rewrite user-authored repo context without explicit approval.",
+        "- Prefer additive file creation and managed-block refreshes over broad merges.",
+        "",
+    ].join("\n");
+}
+function generateYouProjectContextReadme(projectName) {
+    return [
+        "# You.md Supplemental Project Context",
+        "",
+        `This directory holds additive, generated context for \`${projectName}\`.`,
+        "",
+        "- Keep canonical project docs in `project-context/`.",
+        "- Keep generated cross-agent context in `.you/`.",
+        "- Use this layer when You.md needs to preserve shared behavior without clobbering hand-written repo docs.",
+        "",
+    ].join("\n");
+}
+function escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// ─── 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) => {
+        // Dim warning instead of silent swallow
+        const chalk = require("chalk");
+        console.log(chalk.dim(`  sync: ${entry.name} remote sync failed (non-fatal)`));
+        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