@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/bootstrap/skills-installer.js

@@ -1,17 +1,18 @@
 // adapters/mcp-ts/src/bootstrap/skills-installer.ts
 // Skill bundle installation, activation, and health check
 // Skills are prebundled in the npm package (no network required)
-import fs from "node:fs";
+import { readFile, stat, readdir, mkdir, copyFile, writeFile, unlink, rm } from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
 import { SKILL_SPEC } from "./registry.js";
+import { existsAsync, readJsonFileAsync, readTextFileAsync } from "../../kernel/async-fs.js";
 // ============================================================
 // Path Utilities
 // ============================================================
 /**
  * Find package root by looking for package.json
  */
-function findPackageRoot() {
+async function findPackageRoot() {
     // Start from current module's directory
     let dir = path.dirname(new URL(import.meta.url).pathname);
     // On Windows, remove leading slash from /C:/...
@@ -21,7 +22,7 @@ function findPackageRoot() {
     for (let i = 0; i < 10; i++) {
         const pkgPath = path.join(dir, "package.json");
         try {
-            if (fs.existsSync(pkgPath)) {
+            if (await existsAsync(pkgPath)) {
                 return dir;
             }
         }
@@ -38,14 +39,17 @@ function findPackageRoot() {
 /**
  * Get the path to the prebundled skills directory in the npm package
  */
-export function getSkillsBundlePath() {
-    const pkgRoot = findPackageRoot();
+export async function getSkillsBundlePath() {
+    const pkgRoot = await findPackageRoot();
     if (!pkgRoot)
         return null;
     const skillsDir = path.join(pkgRoot, SKILL_SPEC.bundlePath);
     try {
-        if (fs.existsSync(skillsDir) && fs.statSync(skillsDir).isDirectory()) {
-            return skillsDir;
+        if (await existsAsync(skillsDir)) {
+            const s = await stat(skillsDir);
+            if (s.isDirectory()) {
+                return skillsDir;
+            }
         }
     }
     catch {
@@ -66,32 +70,20 @@ export function getProjectSkillsPath(projectRoot) {
 /**
  * Load the skills index from the prebundled directory
  */
-export function loadSkillsIndex() {
-    const bundlePath = getSkillsBundlePath();
+export async function loadSkillsIndex() {
+    const bundlePath = await getSkillsBundlePath();
     if (!bundlePath)
         return null;
     const indexPath = path.join(bundlePath, "index.json");
-    try {
-        const content = fs.readFileSync(indexPath, "utf-8");
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
+    return readJsonFileAsync(indexPath);
 }
 /**
  * Load the activated skills index from the project
  */
-export function loadActivatedSkillsIndex(projectRoot) {
+export async function loadActivatedSkillsIndex(projectRoot) {
     const skillsPath = getProjectSkillsPath(projectRoot);
     const indexPath = path.join(skillsPath, "index.json");
-    try {
-        const content = fs.readFileSync(indexPath, "utf-8");
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
+    return readJsonFileAsync(indexPath);
 }
 // ============================================================
 // Health Check
@@ -99,9 +91,9 @@ export function loadActivatedSkillsIndex(projectRoot) {
 /**
  * Calculate SHA256 hash of a file
  */
-function calculateSha256(filePath) {
+async function calculateSha256(filePath) {
     try {
-        const content = fs.readFileSync(filePath);
+        const content = await readFile(filePath);
         return crypto.createHash("sha256").update(content).digest("hex");
     }
     catch {
@@ -111,9 +103,9 @@ function calculateSha256(filePath) {
 /**
  * Check health of a single skill in the bundle
  */
-function checkSkillHealth(bundlePath, skill) {
+async function checkSkillHealth(bundlePath, skill) {
     const filePath = path.join(bundlePath, skill.file);
-    if (!fs.existsSync(filePath)) {
+    if (!(await existsAsync(filePath))) {
         return {
             id: skill.id,
             status: "missing",
@@ -122,7 +114,7 @@ function checkSkillHealth(bundlePath, skill) {
             error: `Skill file not found: ${skill.file}`
         };
     }
-    const actualSha = calculateSha256(filePath);
+    const actualSha = await calculateSha256(filePath);
     if (!actualSha) {
         return {
             id: skill.id,
@@ -151,8 +143,8 @@ function checkSkillHealth(bundlePath, skill) {
 /**
  * Check health of the entire skills bundle
  */
-export function getSkillsHealth() {
-    const bundlePath = getSkillsBundlePath();
+export async function getSkillsHealth() {
+    const bundlePath = await getSkillsBundlePath();
     if (!bundlePath) {
         return {
             installed: false,
@@ -162,7 +154,7 @@ export function getSkillsHealth() {
             summary: { total: 0, ok: 0, missing: 0, corrupted: 0 }
         };
     }
-    const index = loadSkillsIndex();
+    const index = await loadSkillsIndex();
     if (!index) {
         return {
             installed: true,
@@ -172,7 +164,7 @@ export function getSkillsHealth() {
             summary: { total: 0, ok: 0, missing: 0, corrupted: 0 }
         };
     }
-    const skills = index.skills.map(skill => checkSkillHealth(bundlePath, skill));
+    const skills = await Promise.all(index.skills.map(skill => checkSkillHealth(bundlePath, skill)));
     const summary = {
         total: skills.length,
         ok: skills.filter(s => s.status === "ok").length,
@@ -193,22 +185,22 @@ export function getSkillsHealth() {
 /**
  * List all available skills from the prebundled directory
  */
-export function listAvailableSkills() {
-    const index = loadSkillsIndex();
+export async function listAvailableSkills() {
+    const index = await loadSkillsIndex();
     return index?.skills ?? [];
 }
 /**
  * List activated skills in the project
  */
-export function listActivatedSkills(projectRoot) {
-    const index = loadActivatedSkillsIndex(projectRoot);
+export async function listActivatedSkills(projectRoot) {
+    const index = await loadActivatedSkillsIndex(projectRoot);
     return index?.activated ?? [];
 }
 /**
  * Get skill metadata by ID
  */
-export function getSkillById(skillId) {
-    const skills = listAvailableSkills();
+export async function getSkillById(skillId) {
+    const skills = await listAvailableSkills();
     return skills.find(s => s.id === skillId) ?? null;
 }
 // ============================================================
@@ -218,11 +210,11 @@ export function getSkillById(skillId) {
  * Activate skills for a project by copying them to .vibe/skills/
  */
 export async function activateSkills(projectRoot, skillIds) {
-    const bundlePath = getSkillsBundlePath();
+    const bundlePath = await getSkillsBundlePath();
     if (!bundlePath) {
         return { activated: [], errors: ["Skill bundle not found in package"] };
     }
-    const index = loadSkillsIndex();
+    const index = await loadSkillsIndex();
     if (!index) {
         return { activated: [], errors: ["Skills index not found or invalid"] };
     }
@@ -237,7 +229,7 @@ export async function activateSkills(projectRoot, skillIds) {
     const projectSkillsPath = getProjectSkillsPath(projectRoot);
     // Ensure .vibe/skills/ directory exists
     try {
-        await fs.promises.mkdir(projectSkillsPath, { recursive: true });
+        await mkdir(projectSkillsPath, { recursive: true });
     }
     catch (e) {
         return {
@@ -252,7 +244,9 @@ export async function activateSkills(projectRoot, skillIds) {
         const srcPath = path.join(bundlePath, skill.file);
         const destPath = path.join(projectSkillsPath, skill.file);
         try {
-            await fs.promises.copyFile(srcPath, destPath);
+            // Support nested skill paths (e.g. "packs/foo/SKILL.md")
+            await mkdir(path.dirname(destPath), { recursive: true });
+            await copyFile(srcPath, destPath);
             activated.push(skill.id);
         }
         catch (e) {
@@ -270,7 +264,7 @@ export async function activateSkills(projectRoot, skillIds) {
         };
         const indexPath = path.join(projectSkillsPath, "index.json");
         try {
-            await fs.promises.writeFile(indexPath, JSON.stringify(activatedIndex, null, 2), "utf-8");
+            await writeFile(indexPath, JSON.stringify(activatedIndex, null, 2), "utf-8");
         }
         catch (e) {
             errors.push(`Failed to write index.json: ${e instanceof Error ? e.message : String(e)}`);
@@ -283,7 +277,7 @@ export async function activateSkills(projectRoot, skillIds) {
  */
 export async function deactivateSkill(projectRoot, skillId) {
     const projectSkillsPath = getProjectSkillsPath(projectRoot);
-    const activatedIndex = loadActivatedSkillsIndex(projectRoot);
+    const activatedIndex = await loadActivatedSkillsIndex(projectRoot);
     if (!activatedIndex) {
         return { success: false, error: "No activated skills found" };
     }
@@ -294,8 +288,8 @@ export async function deactivateSkill(projectRoot, skillId) {
     // Remove the skill file
     const skillPath = path.join(projectSkillsPath, skillMeta.file);
     try {
-        if (fs.existsSync(skillPath)) {
-            await fs.promises.unlink(skillPath);
+        if (await existsAsync(skillPath)) {
+            await unlink(skillPath);
         }
     }
     catch (e) {
@@ -311,7 +305,7 @@ export async function deactivateSkill(projectRoot, skillId) {
         // Remove the index file if no skills remain
         const indexPath = path.join(projectSkillsPath, "index.json");
         try {
-            await fs.promises.unlink(indexPath);
+            await unlink(indexPath);
         }
         catch {
             // ignore
@@ -325,7 +319,7 @@ export async function deactivateSkill(projectRoot, skillId) {
             skills: newSkills
         };
         const indexPath = path.join(projectSkillsPath, "index.json");
-        await fs.promises.writeFile(indexPath, JSON.stringify(updatedIndex, null, 2), "utf-8");
+        await writeFile(indexPath, JSON.stringify(updatedIndex, null, 2), "utf-8");
     }
     return { success: true };
 }
@@ -336,8 +330,8 @@ export async function deactivateSkill(projectRoot, skillId) {
  * Ensure skills are installed and healthy
  * Returns the bundle path if successful
  */
-export function ensureSkills() {
-    const health = getSkillsHealth();
+export async function ensureSkills() {
+    const health = await getSkillsHealth();
     // For prebundled skills, we can't "repair" - they're part of the package
     // If they're corrupted, the user needs to reinstall the package
     return {
@@ -348,32 +342,30 @@ export function ensureSkills() {
 /**
  * Get skill content by ID
  */
-export function getSkillContent(skillId) {
-    const bundlePath = getSkillsBundlePath();
+export async function getSkillContent(skillId) {
+    const bundlePath = await getSkillsBundlePath();
     if (!bundlePath)
         return null;
-    const skill = getSkillById(skillId);
+    const skill = await getSkillById(skillId);
     if (!skill)
         return null;
     const filePath = path.join(bundlePath, skill.file);
-    try {
-        return fs.readFileSync(filePath, "utf-8");
-    }
-    catch {
-        return null;
-    }
+    return readTextFileAsync(filePath);
 }
 /**
  * Get the path to the prebundled skillpacks directory in the npm package
  */
-export function getSkillpacksBundlePath() {
-    const pkgRoot = findPackageRoot();
+export async function getSkillpacksBundlePath() {
+    const pkgRoot = await findPackageRoot();
     if (!pkgRoot)
         return null;
     const skillpacksDir = path.join(pkgRoot, "skills_packs");
     try {
-        if (fs.existsSync(skillpacksDir) && fs.statSync(skillpacksDir).isDirectory()) {
-            return skillpacksDir;
+        if (await existsAsync(skillpacksDir)) {
+            const s = await stat(skillpacksDir);
+            if (s.isDirectory()) {
+                return skillpacksDir;
+            }
         }
     }
     catch {
@@ -395,32 +387,54 @@ export function getGlobalSkillpacksPath() {
     const homeDir = process.env.HOME || process.env.USERPROFILE || "";
     return path.join(homeDir, ".vibe-pm", "skills_packs");
 }
+function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function parseSkillpackJson(value) {
+    const root = asRecord(value);
+    if (!root)
+        return null;
+    const pack = asRecord(root.pack);
+    if (!pack || typeof pack.id !== "string")
+        return null;
+    if (!Array.isArray(root.skills))
+        return null;
+    return {
+        pack: {
+            id: pack.id,
+            version: typeof pack.version === "string" ? pack.version : undefined,
+            title: typeof pack.title === "string" ? pack.title : undefined,
+            description: typeof pack.description === "string" ? pack.description : undefined,
+        },
+        skills: root.skills,
+    };
+}
 /**
  * List available skillpacks from the bundle
  */
-export function listBundledSkillpacks() {
-    const bundlePath = getSkillpacksBundlePath();
+export async function listBundledSkillpacks() {
+    const bundlePath = await getSkillpacksBundlePath();
     if (!bundlePath)
         return [];
     const result = [];
     try {
-        const entries = fs.readdirSync(bundlePath, { withFileTypes: true });
+        const entries = await readdir(bundlePath, { withFileTypes: true });
         for (const entry of entries) {
             if (!entry.isDirectory())
                 continue;
             const skillpackPath = path.join(bundlePath, entry.name, "skillpack.json");
-            if (!fs.existsSync(skillpackPath))
+            if (!(await existsAsync(skillpackPath)))
                 continue;
             try {
-                const content = fs.readFileSync(skillpackPath, "utf-8");
-                const parsed = JSON.parse(content);
-                if (parsed?.pack?.id && parsed?.skills) {
+                const parsed = await readJsonFileAsync(skillpackPath);
+                const skillpack = parseSkillpackJson(parsed);
+                if (skillpack) {
                     result.push({
-                        id: parsed.pack.id,
-                        version: parsed.pack.version ?? "unknown",
-                        title: parsed.pack.title ?? parsed.pack.id,
-                        description: parsed.pack.description ?? "",
-                        skillCount: parsed.skills.length
+                        id: skillpack.pack.id,
+                        version: skillpack.pack.version ?? "unknown",
+                        title: skillpack.pack.title ?? skillpack.pack.id,
+                        description: skillpack.pack.description ?? "",
+                        skillCount: skillpack.skills.length
                     });
                 }
             }
@@ -437,9 +451,9 @@ export function listBundledSkillpacks() {
 /**
  * Check health of a single skillpack
  */
-function checkSkillpackHealth(packPath, packId) {
+async function checkSkillpackHealth(packPath, packId) {
     const skillpackFile = path.join(packPath, "skillpack.json");
-    if (!fs.existsSync(skillpackFile)) {
+    if (!(await existsAsync(skillpackFile))) {
         return {
             id: packId,
             status: "missing",
@@ -450,10 +464,9 @@ function checkSkillpackHealth(packPath, packId) {
         };
     }
     try {
-        const content = fs.readFileSync(skillpackFile, "utf-8");
-        const parsed = JSON.parse(content);
-        // Basic validation
-        if (!parsed?.pack?.id || !parsed?.skills || !Array.isArray(parsed.skills)) {
+        const parsed = await readJsonFileAsync(skillpackFile);
+        const skillpack = parseSkillpackJson(parsed);
+        if (!skillpack) {
             return {
                 id: packId,
                 status: "index_invalid",
@@ -464,11 +477,11 @@ function checkSkillpackHealth(packPath, packId) {
             };
         }
         return {
-            id: parsed.pack.id,
+            id: skillpack.pack.id,
             status: "ok",
-            version: parsed.pack.version ?? null,
+            version: skillpack.pack.version ?? null,
             path: packPath,
-            skillCount: parsed.skills.length
+            skillCount: skillpack.skills.length
         };
     }
     catch (e) {
@@ -485,8 +498,8 @@ function checkSkillpackHealth(packPath, packId) {
 /**
  * Get health of all bundled skillpacks
  */
-export function getSkillpacksHealth() {
-    const bundlePath = getSkillpacksBundlePath();
+export async function getSkillpacksHealth() {
+    const bundlePath = await getSkillpacksBundlePath();
     if (!bundlePath) {
         return {
             installed: false,
@@ -497,12 +510,12 @@ export function getSkillpacksHealth() {
     }
     const packs = [];
     try {
-        const entries = fs.readdirSync(bundlePath, { withFileTypes: true });
+        const entries = await readdir(bundlePath, { withFileTypes: true });
         for (const entry of entries) {
             if (!entry.isDirectory())
                 continue;
             const packPath = path.join(bundlePath, entry.name);
-            packs.push(checkSkillpackHealth(packPath, entry.name));
+            packs.push(await checkSkillpackHealth(packPath, entry.name));
         }
     }
     catch {
@@ -525,11 +538,11 @@ export function getSkillpacksHealth() {
  * Install (copy) skillpacks to the project directory
  */
 export async function installSkillpacksToProject(projectRoot, packIds) {
-    const bundlePath = getSkillpacksBundlePath();
+    const bundlePath = await getSkillpacksBundlePath();
     if (!bundlePath) {
         return { installed: [], errors: ["Skillpacks bundle not found in package"] };
     }
-    const availablePacks = listBundledSkillpacks();
+    const availablePacks = await listBundledSkillpacks();
     if (availablePacks.length === 0) {
         return { installed: [], errors: ["No skillpacks found in bundle"] };
     }
@@ -538,7 +551,7 @@ export async function installSkillpacksToProject(projectRoot, packIds) {
     const projectPath = getProjectSkillpacksPath(projectRoot);
     // Ensure .vibe/skills_packs/ directory exists
     try {
-        await fs.promises.mkdir(projectPath, { recursive: true });
+        await mkdir(projectPath, { recursive: true });
     }
     catch (e) {
         return {
@@ -552,21 +565,21 @@ export async function installSkillpacksToProject(projectRoot, packIds) {
     for (const packId of toInstall) {
         const srcDir = path.join(bundlePath, packId);
         const destDir = path.join(projectPath, packId);
-        if (!fs.existsSync(srcDir)) {
+        if (!(await existsAsync(srcDir))) {
             errors.push(`Skillpack ${packId} not found in bundle`);
             continue;
         }
         try {
             // Create destination directory
-            await fs.promises.mkdir(destDir, { recursive: true });
+            await mkdir(destDir, { recursive: true });
             // Copy all files in the skillpack directory
-            const files = await fs.promises.readdir(srcDir);
+            const files = await readdir(srcDir);
             for (const file of files) {
                 const srcFile = path.join(srcDir, file);
                 const destFile = path.join(destDir, file);
-                const stat = await fs.promises.stat(srcFile);
-                if (stat.isFile()) {
-                    await fs.promises.copyFile(srcFile, destFile);
+                const s = await stat(srcFile);
+                if (s.isFile()) {
+                    await copyFile(srcFile, destFile);
                 }
             }
             installed.push(packId);
@@ -583,11 +596,11 @@ export async function installSkillpacksToProject(projectRoot, packIds) {
 export async function removeSkillpackFromProject(projectRoot, packId) {
     const projectPath = getProjectSkillpacksPath(projectRoot);
     const packDir = path.join(projectPath, packId);
-    if (!fs.existsSync(packDir)) {
+    if (!(await existsAsync(packDir))) {
         return { success: false, error: `Skillpack ${packId} is not installed` };
     }
     try {
-        await fs.promises.rm(packDir, { recursive: true, force: true });
+        await rm(packDir, { recursive: true, force: true });
         return { success: true };
     }
     catch (e) {
@@ -601,8 +614,8 @@ export async function removeSkillpackFromProject(projectRoot, packId) {
  * Ensure skillpacks are ready (for vibe setup)
  * Returns health status without automatically copying
  */
-export function ensureSkillpacks() {
-    const health = getSkillpacksHealth();
+export async function ensureSkillpacks() {
+    const health = await getSkillpacksHealth();
     return {
         bundlePath: health.bundlePath,
         health

package/build/mcp/chunking/artifacts.d.ts

@@ -1,9 +1,49 @@
-import { ChunkData, ChunkManifest } from "./types.js";
+import { ChunkData, ChunkManifest } from './types.js';
+import { CreateChainResult } from '../../kernel/blocks/chain.js';
+import type { BlockDeps } from '../../kernel/deps.js';
+/**
+ * Options for dual-write mode.
+ */
+export interface WriteOptions {
+    /** Write to Block Store (default: true) */
+    writeToBlockStore?: boolean;
+    /** Write legacy chunk files (default: true for backward compatibility) */
+    writeLegacyChunks?: boolean;
+}
+/**
+ * Result from writeChunkArtifacts with optional Block Store info.
+ */
+export interface WriteChunkResult {
+    /** Legacy chunk directory path */
+    chunkDir: string;
+    /** Block Store chain result (if writeToBlockStore enabled) */
+    chainResult?: CreateChainResult;
+}
+/**
+ * Write chunk artifacts with optional Block Store dual-write.
+ *
+ * By default, writes to both legacy chunks AND Block Store for backward compatibility.
+ * Set options to control write behavior:
+ * - writeToBlockStore: false - Skip Block Store (legacy-only mode)
+ * - writeLegacyChunks: false - Skip legacy chunks (Block Store-only mode)
+ *
+ * @example
+ * ```typescript
+ * // Default: dual-write (both legacy and Block Store)
+ * writeChunkArtifacts({ workspaceRoot, runId, chunks, manifest });
+ *
+ * // Legacy-only mode
+ * writeChunkArtifacts({ workspaceRoot, runId, chunks, manifest }, { writeToBlockStore: false });
+ *
+ * // Block Store-only mode (no legacy files)
+ * writeChunkArtifacts({ workspaceRoot, runId, chunks, manifest }, { writeLegacyChunks: false });
+ * ```
+ */
 export declare function writeChunkArtifacts(params: {
     workspaceRoot: string;
     runId: string;
     chunks: ChunkData[];
     manifest: ChunkManifest;
-}): {
-    chunkDir: string;
-};
+    /** Source file path for Block Store chain */
+    sourcePath?: string;
+}, options?: WriteOptions, deps?: BlockDeps): WriteChunkResult;