aem-ext-daemon 0.1.0 → 0.3.0

package/dist/capabilities/fs.d.ts

@@ -1,5 +1,5 @@
 /**
- * Filesystem capabilities — browse, read, write, list.
+ * Filesystem capabilities — browse, read, write, list, roots.
  */
 export interface BrowseEntry {
     name: string;
@@ -9,6 +9,8 @@ export interface BrowseEntry {
 }
 /** Browse a directory — returns immediate children with metadata. */
 export declare function browse(dirPath: string, showHidden?: boolean): string;
+/** Return useful root paths for folder browsing (home dir, system root, etc). */
+export declare function roots(): string;
 /** Read a file and return its content. */
 export declare function readFile(filePath: string): string;
 /** Write content to a file. Creates parent directories if needed. */

package/dist/capabilities/fs.js

@@ -1,8 +1,9 @@
 /**
- * Filesystem capabilities — browse, read, write, list.
+ * Filesystem capabilities — browse, read, write, list, roots.
  */
 import fs from "node:fs";
 import path from "node:path";
+import os from "node:os";
 /** Browse a directory — returns immediate children with metadata. */
 export function browse(dirPath, showHidden = false) {
     const entries = fs.readdirSync(dirPath, { withFileTypes: true });
@@ -24,6 +25,23 @@ export function browse(dirPath, showHidden = false) {
     });
     return JSON.stringify(result);
 }
+/** Return useful root paths for folder browsing (home dir, system root, etc). */
+export function roots() {
+    const home = os.homedir();
+    const entries = [
+        { name: "Home", path: home },
+        { name: "Desktop", path: path.join(home, "Desktop") },
+        { name: "Documents", path: path.join(home, "Documents") },
+    ];
+    if (process.platform === "darwin") {
+        entries.push({ name: "Volumes", path: "/Volumes" });
+    }
+    else {
+        entries.push({ name: "/", path: "/" });
+    }
+    // Filter to only existing paths
+    return JSON.stringify(entries.filter((e) => fs.existsSync(e.path)));
+}
 /** Read a file and return its content. */
 export function readFile(filePath) {
     if (!fs.existsSync(filePath)) {

package/dist/capabilities/skills.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Skills capabilities — sync skills from local .skills folder,
+ * seed default skills from GitHub if none exist.
+ */
+export interface SkillEntry {
+    name: string;
+    content: string;
+    scripts?: Array<{
+        name: string;
+        content: string;
+    }>;
+}
+/**
+ * Read all skills from the .skills folder in the given workspace root.
+ * Returns an array of skill entries with name, SKILL.md content, and any scripts.
+ */
+export declare function syncSkills(workspaceRoot: string): string;
+/**
+ * Seed default skills into the workspace .skills folder by cloning from GitHub.
+ * Only seeds if .skills folder doesn't already exist.
+ * Uses sparse checkout to only pull the skills subfolder.
+ */
+export declare function seedSkills(workspaceRoot: string): string;

package/dist/capabilities/skills.js

@@ -0,0 +1,119 @@
+/**
+ * Skills capabilities — sync skills from local .skills folder,
+ * seed default skills from GitHub if none exist.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+const DEFAULT_SKILLS_REPO = "https://github.com/znikolovski/skills.git";
+const DEFAULT_SKILLS_PATH = "skills/aem/ui-extensibility/skills";
+/**
+ * Read all skills from the .skills folder in the given workspace root.
+ * Returns an array of skill entries with name, SKILL.md content, and any scripts.
+ */
+export function syncSkills(workspaceRoot) {
+    const skillsDir = path.join(workspaceRoot, ".skills");
+    if (!fs.existsSync(skillsDir)) {
+        return JSON.stringify({ found: false, skills: [] });
+    }
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillMdPath = path.join(skillsDir, entry.name, "SKILL.md");
+        if (!fs.existsSync(skillMdPath))
+            continue;
+        const skill = {
+            name: entry.name,
+            content: fs.readFileSync(skillMdPath, "utf-8"),
+        };
+        // Check for scripts subfolder
+        const scriptsDir = path.join(skillsDir, entry.name, "scripts");
+        if (fs.existsSync(scriptsDir)) {
+            const scriptFiles = fs.readdirSync(scriptsDir).filter((f) => fs.statSync(path.join(scriptsDir, f)).isFile());
+            skill.scripts = scriptFiles.map((f) => ({
+                name: f,
+                content: fs.readFileSync(path.join(scriptsDir, f), "utf-8"),
+            }));
+        }
+        skills.push(skill);
+    }
+    return JSON.stringify({ found: true, skills });
+}
+/**
+ * Seed default skills into the workspace .skills folder by cloning from GitHub.
+ * Only seeds if .skills folder doesn't already exist.
+ * Uses sparse checkout to only pull the skills subfolder.
+ */
+export function seedSkills(workspaceRoot) {
+    const skillsDir = path.join(workspaceRoot, ".skills");
+    if (fs.existsSync(skillsDir)) {
+        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+        const skillCount = entries.filter((e) => e.isDirectory()).length;
+        if (skillCount > 0) {
+            return JSON.stringify({
+                seeded: false,
+                reason: "Skills folder already exists with " + skillCount + " skills",
+            });
+        }
+    }
+    // Clone into a temp dir, then copy the skills subfolder
+    const tmpDir = path.join(workspaceRoot, ".skills-tmp-" + Date.now());
+    try {
+        // Shallow clone the repo
+        execSync(`git clone --depth 1 --filter=blob:none --sparse "${DEFAULT_SKILLS_REPO}" "${tmpDir}"`, { timeout: 60_000, stdio: "pipe" });
+        // Sparse checkout just the skills path
+        execSync(`git -C "${tmpDir}" sparse-checkout set "${DEFAULT_SKILLS_PATH}"`, {
+            timeout: 30_000,
+            stdio: "pipe",
+        });
+        // Copy skills into .skills
+        const srcDir = path.join(tmpDir, DEFAULT_SKILLS_PATH);
+        if (!fs.existsSync(srcDir)) {
+            throw new Error("Skills path not found in cloned repo: " + DEFAULT_SKILLS_PATH);
+        }
+        fs.mkdirSync(skillsDir, { recursive: true });
+        const skillDirs = fs.readdirSync(srcDir, { withFileTypes: true });
+        for (const dir of skillDirs) {
+            if (!dir.isDirectory())
+                continue;
+            copyDirRecursive(path.join(srcDir, dir.name), path.join(skillsDir, dir.name));
+        }
+        // Count what we seeded
+        const seededSkills = fs
+            .readdirSync(skillsDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+        return JSON.stringify({ seeded: true, skills: seededSkills });
+    }
+    catch (err) {
+        return JSON.stringify({
+            seeded: false,
+            reason: err.message,
+        });
+    }
+    finally {
+        // Clean up temp dir
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+}
+function copyDirRecursive(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}

package/dist/dispatcher.js

@@ -9,6 +9,7 @@ import { getWorkspaceRoot, setWorkspaceRoot } from "./identity.js";
 import * as fsCap from "./capabilities/fs.js";
 import * as gitCap from "./capabilities/git.js";
 import * as shellCap from "./capabilities/shell.js";
+import * as skillsCap from "./capabilities/skills.js";
 /**
  * Validate that a given path is within the workspace root.
  * Prevents path traversal attacks.
@@ -30,9 +31,13 @@ function validatePath(targetPath) {
 export async function dispatch(command, payload, connection) {
     switch (command) {
         // ─── Filesystem ─────────────────────────────────────
+        case "fs:roots": {
+            return fsCap.roots();
+        }
         case "fs:browse": {
+            // fs:browse allows absolute paths for folder picking (not sandboxed to workspace)
             const target = payload.path
-                ? validatePath(payload.path)
+                ? path.resolve(payload.path)
                 : getWorkspaceRoot();
             return fsCap.browse(target, payload.showHidden);
         }
@@ -86,6 +91,19 @@ export async function dispatch(command, payload, connection) {
                 : getWorkspaceRoot();
             return shellCap.exec(payload.command, cwd);
         }
+        // ─── Skills ────────────────────────────────────────
+        case "skills:sync": {
+            const workspace = getWorkspaceRoot();
+            if (!workspace)
+                throw new Error("No workspace root configured.");
+            return skillsCap.syncSkills(workspace);
+        }
+        case "skills:seed": {
+            const workspace = getWorkspaceRoot();
+            if (!workspace)
+                throw new Error("No workspace root configured.");
+            return skillsCap.seedSkills(workspace);
+        }
         default:
             throw new Error(`Unknown command: ${command}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aem-ext-daemon",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Local daemon for AEM Extension Builder — connects your machine to the cloud UI",
   "type": "module",
   "bin": {