@skillsgate/tui 0.1.9 → 0.1.12

package/bin/skillsgate-tui

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { execFileSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
+import fs from "node:fs";
 import os from "node:os";
 
 const platform = os.platform();
@@ -20,35 +21,47 @@ if (!pkg) {
   process.exit(1);
 }
 
-// Try multiple resolution strategies since global installs place optional
-// deps as siblings rather than nested under this package's node_modules.
 const binName = platform === "win32" ? "skillsgate-tui.exe" : "skillsgate-tui";
 const require = createRequire(import.meta.url);
 const thisDir = path.dirname(fileURLToPath(import.meta.url));
 
-const candidates = [
-  // 1. Nested node_modules (local installs)
-  () => require.resolve(`@skillsgate/${pkg}/${binName}`),
-  // 2. Sibling in global node_modules (npm install -g)
-  //    thisDir = .../node_modules/@skillsgate/tui/bin → go up 3 to node_modules
-  () => path.join(thisDir, "..", "..", "..", `@skillsgate/${pkg}`, binName),
-];
+function findBinary() {
+  const candidates = [
+    // Nested node_modules (local installs)
+    () => require.resolve(`@skillsgate/${pkg}/${binName}`),
+    // Sibling in global node_modules (npm install -g)
+    () => path.join(thisDir, "..", "..", "..", `@skillsgate/${pkg}`, binName),
+  ];
 
-let binPath = null;
-for (const resolve of candidates) {
+  for (const resolve of candidates) {
+    try {
+      const p = resolve();
+      fs.accessSync(p, fs.constants.X_OK);
+      return p;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+let binPath = findBinary();
+
+// Auto-install the platform binary if missing (npm v11+ skips optionalDeps for global installs)
+if (!binPath) {
+  const version = require("../package.json").version;
+  const fullPkg = `@skillsgate/${pkg}@${version}`;
+  console.error(`Installing platform binary (${fullPkg})...`);
   try {
-    const p = resolve();
-    // Verify it exists by importing fs synchronously
-    require("fs").accessSync(p, require("fs").constants.X_OK);
-    binPath = p;
-    break;
+    execSync(`npm install -g ${fullPkg}`, { stdio: "inherit", timeout: 30000 });
+    binPath = findBinary();
   } catch {
-    continue;
+    // fall through to error below
   }
 }
 
 if (!binPath) {
-  console.error("Platform binary not found. Try reinstalling: npm install -g @skillsgate/tui");
+  console.error(`Platform binary not found. Run manually: npm install -g @skillsgate/${pkg}`);
   process.exit(1);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillsgate/tui",
-  "version": "0.1.9",
+  "version": "0.1.12",
   "type": "module",
   "bin": {
     "skillsgate-tui": "bin/skillsgate-tui"
@@ -16,11 +16,11 @@
     "gray-matter": "4.0.3"
   },
   "optionalDependencies": {
-    "@skillsgate/tui-darwin-arm64": "0.1.9",
-    "@skillsgate/tui-darwin-x64": "0.1.9",
-    "@skillsgate/tui-linux-x64": "0.1.9",
-    "@skillsgate/tui-linux-arm64": "0.1.9",
-    "@skillsgate/tui-win32-x64": "0.1.9"
+    "@skillsgate/tui-darwin-arm64": "0.1.12",
+    "@skillsgate/tui-darwin-x64": "0.1.12",
+    "@skillsgate/tui-linux-x64": "0.1.12",
+    "@skillsgate/tui-linux-arm64": "0.1.12",
+    "@skillsgate/tui-win32-x64": "0.1.12"
   },
   "peerDependencies": {
     "react": "19.1.5"

package/src/components/agent-filter.tsx

@@ -58,11 +58,11 @@ export function AgentFilter() {
       style={{
         flexDirection: "column",
         width: 22,
-        borderRight: true,
+        border: true,
         borderColor: isFocused ? colors.primary : colors.border,
         backgroundColor: colors.bg,
         paddingTop: 0,
-      }}
+      } as any}
     >
       {/* Library section header */}
       <box style={{ paddingLeft: 1, height: 1, backgroundColor: colors.bgAlt }}>

package/src/components/help-overlay.tsx

@@ -10,6 +10,8 @@ const SHORTCUTS_LEFT: ShortcutEntry[] = [
   { key: "g", description: "Jump to first item" },
   { key: "G", description: "Jump to last item" },
   { key: "v", description: "View skill detail" },
+  { key: "n", description: "Create local skill (home)" },
+  { key: "c", description: "Manage collections (home)" },
   { key: "/", description: "Focus search input" },
   { key: "Tab", description: "Cycle focus: agents > search > list" },
   { key: "Esc", description: "Clear search / go back" },

package/src/components/layout.tsx

@@ -95,9 +95,10 @@ export function Layout() {
     if (state.showHelp) return
 
     // Tab switching (only when not in detail/form views)
-    const inFormView = state.activeView === "detail" || state.activeView === "add-server"
-      || state.activeView === "edit-server" || state.activeView === "settings"
-      || state.activeView === "server-skills" || state.activeView === "login"
+    const activeView = state.activeView as string
+    const inFormView = activeView === "detail" || activeView === "add-server"
+      || activeView === "edit-server" || activeView === "settings"
+      || activeView === "server-skills" || activeView === "login"
     if (!inFormView) {
       if (key.name === "1") dispatch({ type: "NAVIGATE", view: "home" })
       if (key.name === "2") dispatch({ type: "NAVIGATE", view: "discover" })
@@ -109,7 +110,7 @@ export function Layout() {
     }
 
     // "s" to open settings (only from home/favorites views when not in search)
-    if (key.name === "s" && state.focusedPane !== "search"
+    if (key.name === "s" && (state.focusedPane as string) !== "search"
       && state.activeView !== "discover" && state.activeView !== "detail"
       && !inFormView) {
       dispatch({ type: "NAVIGATE", view: "settings" })
@@ -139,20 +140,20 @@ export function Layout() {
       if (state.installedFilter) {
         dispatch({ type: "SET_INSTALLED_FILTER", filter: "" })
       }
-      if (state.focusedPane === "search") {
+      if ((state.focusedPane as string) === "search") {
         dispatch({ type: "SET_FOCUSED_PANE", pane: "list" })
       }
       return
     }
 
     // "l" to navigate to login view (always -- allows re-login if token expired)
-    if (key.name === "l" && state.focusedPane !== "search" && state.activeView !== "detail" && state.activeView !== "login") {
+    if (key.name === "l" && (state.focusedPane as string) !== "search" && activeView !== "detail" && activeView !== "login") {
       dispatch({ type: "NAVIGATE", view: "login" })
       return
     }
 
     // "r" to refresh installed skills (when not typing in search, not on login view)
-    if (key.name === "r" && state.focusedPane !== "search" && state.activeView !== "detail" && state.activeView !== "login") {
+    if (key.name === "r" && (state.focusedPane as string) !== "search" && activeView !== "detail" && activeView !== "login") {
       dispatch({ type: "REFRESH_SKILLS" })
       return
     }
@@ -186,7 +187,7 @@ export function Layout() {
         }}
       >
         <text fg={colors.primary}>
-          <strong>SkillsGate TUI</strong> <span fg={colors.textDim}>v0.1.0</span>
+          <strong>SkillsGate TUI</strong> <span fg={colors.textDim}>v0.1.12</span>
         </text>
       </box>
 
@@ -194,7 +195,7 @@ export function Layout() {
       <tab-select
         options={TAB_OPTIONS}
         focused={state.activeView !== "detail" && !state.showHelp}
-        selectedIndex={activeTabIndex >= 0 ? activeTabIndex : 0}
+        {...({ selectedIndex: activeTabIndex >= 0 ? activeTabIndex : 0 } as any)}
         selectedBackgroundColor={colors.tabActive}
         selectedTextColor={colors.tabText}
         textColor={colors.textDim}

package/src/data/use-installed-skills.ts

@@ -1,14 +1,97 @@
 import { useEffect } from "react"
 import fs from "node:fs/promises"
 import path from "node:path"
+import os from "node:os"
 import matter from "gray-matter"
 import { useStore, useDispatch } from "../store/context.js"
+import { useDb } from "../db/context.js"
 import { agents } from "../../../cli/src/core/agents.js"
 import { readSkillLock } from "../../../cli/src/core/skill-lock.js"
 import { SKILL_MD } from "../../../cli/src/constants.js"
 import type { EnrichedSkill } from "../store/types.js"
 import type { AgentType, SkillLockFile } from "../../../cli/src/types.js"
 
+const home = os.homedir()
+const PROJECT_PROBES = [
+  ".claude/skills",
+  ".cursor/skills",
+  ".cursor/rules",
+  ".codex/skills",
+  ".github/skills",
+  ".windsurf/skills",
+  ".continue/skills",
+  ".cline/skills",
+  ".amp/skills",
+  ".opencode/skills",
+  ".goose/skills",
+  ".junie/skills",
+  ".kilo-code/skills",
+  ".pear-ai/skills",
+  ".roo-code/skills",
+  ".trae/skills",
+  ".zed/skills",
+  ".agents/skills",
+]
+
+function getScopeForPath(resolvedPath: string): "global" | "project" | "custom" {
+  const globalRoots = [
+    path.join(home, ".agents", "skills"),
+    ...Object.values(agents).map((agent) => agent.globalSkillsDir),
+  ].map((root) => path.resolve(root))
+
+  if (globalRoots.some((root) => resolvedPath.startsWith(root))) {
+    return "global"
+  }
+
+  if (resolvedPath.split(path.sep).some((segment) => segment.startsWith("."))) {
+    return "project"
+  }
+
+  return "custom"
+}
+
+function getProjectNameForPath(resolvedPath: string): string | null {
+  const parts = path.resolve(resolvedPath).split(path.sep).filter(Boolean)
+  for (let i = 1; i < parts.length; i++) {
+    if (parts[i].startsWith(".")) {
+      return parts[i - 1] || null
+    }
+  }
+  return null
+}
+
+async function listSupportingFiles(skillDir: string): Promise<Array<{ relativePath: string; size: number }>> {
+  const files: Array<{ relativePath: string; size: number }> = []
+
+  async function walk(currentDir: string, prefix = ""): Promise<void> {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true })
+    for (const entry of entries) {
+      const absolutePath = path.join(currentDir, entry.name)
+      const relativePath = prefix ? path.join(prefix, entry.name) : entry.name
+
+      if (entry.isDirectory()) {
+        await walk(absolutePath, relativePath)
+        continue
+      }
+
+      if (!entry.isFile() || relativePath === SKILL_MD) continue
+      const stat = await fs.stat(absolutePath)
+      files.push({
+        relativePath: relativePath.split(path.sep).join("/"),
+        size: stat.size,
+      })
+    }
+  }
+
+  try {
+    await walk(skillDir)
+  } catch {
+    return []
+  }
+
+  return files.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
+}
+
 /**
  * Scans all detected agent globalSkillsDir paths for SKILL.md files,
  * parses them with gray-matter, enriches with lock file data, and
@@ -17,6 +100,7 @@ import type { AgentType, SkillLockFile } from "../../../cli/src/types.js"
 export function useInstalledSkills() {
   const dispatch = useDispatch()
   const { installedLoading } = useStore()
+  const { settings } = useDb()
 
   useEffect(() => {
     // Only scan when installedLoading is true (initial mount or refresh triggered)
@@ -41,26 +125,37 @@ export function useInstalledSkills() {
               // Include both real directories and symlinks (skills are often symlinked)
               if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
 
-              const skillMdPath = path.join(skillsDir, entry.name, SKILL_MD)
+              const skillDirPath = path.join(skillsDir, entry.name)
+              const canonicalPath = await fs.realpath(skillDirPath).catch(() => skillDirPath)
+              const skillMdPath = path.join(skillDirPath, SKILL_MD)
               try {
                 const raw = await fs.readFile(skillMdPath, "utf-8")
                 const { data: frontmatter } = matter(raw)
                 const skillName = entry.name
+                const canonicalPath = await fs.realpath(skillDirPath).catch(() => skillDirPath)
+                const scope = getScopeForPath(canonicalPath)
+                const supportingFiles = await listSupportingFiles(canonicalPath)
 
-                const existing = skillMap.get(skillName)
+                const existing = skillMap.get(canonicalPath)
                 if (existing) {
                   // Skill already seen from another agent - add this agent
                   if (!existing.agents.includes(agent.name)) {
                     existing.agents.push(agent.name)
                   }
                 } else {
-                  skillMap.set(skillName, {
+                  skillMap.set(canonicalPath, {
                     name: skillName,
                     description:
                       (frontmatter.description as string) ??
                       extractFirstLine(raw),
                     filePath: skillMdPath,
+                    canonicalPath,
                     agents: [agent.name],
+                    scope,
+                    projectName:
+                      scope === "project" ? getProjectNameForPath(canonicalPath) : null,
+                    hasSupportingFiles: supportingFiles.length > 0,
+                    supportingFiles,
                     metadata: frontmatter as Record<string, unknown>,
                     lock: lock.skills[skillName],
                   })
@@ -74,6 +169,17 @@ export function useInstalledSkills() {
           }
         }
 
+        const customScanPaths = settings.get<string[]>("scan.customPaths", [])
+        for (const customPath of customScanPaths) {
+          const resolvedRoot = path.resolve(customPath.replace(/^~(?=$|\/|\\)/, home))
+          const collected = await collectCustomSkills(resolvedRoot, lock)
+          for (const skill of collected) {
+            if (!skillMap.has(skill.canonicalPath)) {
+              skillMap.set(skill.canonicalPath, skill)
+            }
+          }
+        }
+
         if (cancelled) return
 
         const skills = Array.from(skillMap.values()).sort((a, b) =>
@@ -103,6 +209,75 @@ export function useInstalledSkills() {
   }, [installedLoading])
 }
 
+async function collectCustomSkills(
+  rootPath: string,
+  lock: SkillLockFile,
+): Promise<EnrichedSkill[]> {
+  const results: EnrichedSkill[] = []
+
+  async function maybeCollect(skillDir: string, scope: "project" | "custom") {
+    const skillMdPath = path.join(skillDir, SKILL_MD)
+    try {
+      const raw = await fs.readFile(skillMdPath, "utf-8")
+      const { data: frontmatter } = matter(raw)
+      const canonicalPath = await fs.realpath(skillDir).catch(() => skillDir)
+      const folderName = path.basename(skillDir)
+      const supportingFiles = await listSupportingFiles(canonicalPath)
+      results.push({
+        name: String((frontmatter.name as string) ?? folderName),
+        description:
+          (frontmatter.description as string) ?? extractFirstLine(raw),
+        filePath: skillMdPath,
+        canonicalPath,
+        agents: [],
+        scope,
+        projectName:
+          scope === "project" ? getProjectNameForPath(canonicalPath) : null,
+        hasSupportingFiles: supportingFiles.length > 0,
+        supportingFiles,
+        metadata: frontmatter as Record<string, unknown>,
+        lock: lock.skills[folderName],
+      })
+    } catch {
+      // ignore
+    }
+  }
+
+  await maybeCollect(rootPath, "custom")
+
+  let entries: Array<{ name: string; isDirectory: () => boolean }> = []
+  try {
+    entries = await fs.readdir(rootPath, { withFileTypes: true })
+  } catch {
+    return results
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    await maybeCollect(path.join(rootPath, entry.name), "custom")
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const projectRoot = path.join(rootPath, entry.name)
+    for (const probe of PROJECT_PROBES) {
+      const probeDir = path.join(projectRoot, probe)
+      let probeEntries: Array<{ name: string; isDirectory: () => boolean }> = []
+      try {
+        probeEntries = await fs.readdir(probeDir, { withFileTypes: true })
+      } catch {
+        continue
+      }
+      for (const skillEntry of probeEntries) {
+        if (!skillEntry.isDirectory()) continue
+        await maybeCollect(path.join(probeDir, skillEntry.name), "project")
+      }
+    }
+  }
+
+  return results
+}
+
 /** Extracts the first non-empty, non-heading line from markdown content. */
 function extractFirstLine(content: string): string {
   const lines = content.split("\n")

package/src/data/use-skill-actions.ts

@@ -1,5 +1,6 @@
 import { useCallback } from "react"
 import { useStore, useDispatch } from "../store/context.js"
+import { useDb } from "../db/context.js"
 import type { EnrichedSkill } from "../store/types.js"
 
 // CLI core imports -- these share the same Bun runtime
@@ -36,6 +37,7 @@ interface UseSkillActionsResult {
 export function useSkillActions(): UseSkillActionsResult {
   const state = useStore()
   const dispatch = useDispatch()
+  const { settings } = useDb()
 
   /**
    * Install a skill from its source (GitHub URL, SkillsGate slug, or install command).
@@ -69,6 +71,21 @@ export function useSkillActions(): UseSkillActionsResult {
         return
       }
 
+      const defaultAgents = settings.get<string[]>("install.defaultAgents", [])
+      const mirrorAgents = settings.get<string[]>("sync.mirrorAgents", [])
+      const preferredNames =
+        defaultAgents.length > 0
+          ? Array.from(new Set([...defaultAgents, ...mirrorAgents]))
+          : Array.from(
+              new Set([
+                ...installedAgents.map((agent) => agent.name),
+                ...mirrorAgents,
+              ]),
+            )
+      const targetAgents = installedAgents.filter((agent) =>
+        preferredNames.includes(agent.name),
+      )
+
       let tmpDir: string
       if (source.type === "skillsgate") {
         // Download from SkillsGate API
@@ -112,7 +129,7 @@ export function useSkillActions(): UseSkillActionsResult {
 
         for (const skillToInstall of targetSkills) {
           // Install to all detected agents
-          for (const agent of installedAgents) {
+          for (const agent of targetAgents) {
             const result = await installSkillForAgent(
               skillToInstall,
               agent,
@@ -141,7 +158,7 @@ export function useSkillActions(): UseSkillActionsResult {
           type: "SHOW_NOTIFICATION",
           notification: {
             type: "success",
-            message: `Installed ${targetSkills.length} skill(s): ${skillNames} to ${installedAgents.length} agent(s)`,
+            message: `Installed ${targetSkills.length} skill(s): ${skillNames} to ${targetAgents.length} agent(s)`,
           },
         })
       } finally {

package/src/db/skills.ts

@@ -135,4 +135,28 @@ export class RemoteSkillStore {
       .get(id) as { content: string | null } | null
     return row?.content ?? null
   }
+
+  getByPath(serverId: string, remotePath: string): RemoteSkill | null {
+    const row = this.db
+      .query(
+        "SELECT * FROM remote_skills WHERE server_id = ? AND remote_path = ? LIMIT 1",
+      )
+      .get(serverId, remotePath) as SkillRow | null
+    return row ? rowToSkill(row) : null
+  }
+
+  updateContent(
+    serverId: string,
+    remotePath: string,
+    content: string,
+    contentHash: string,
+  ): void {
+    this.db
+      .query(
+        `UPDATE remote_skills
+         SET content = ?, content_hash = ?, synced_at = datetime('now')
+         WHERE server_id = ? AND remote_path = ?`,
+      )
+      .run(content, contentHash, serverId, remotePath)
+  }
 }

package/src/db/ssh.ts

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process"
+import { spawn, spawnSync } from "node:child_process"
 import os from "node:os"
 import path from "node:path"
 import fs from "node:fs"
@@ -95,6 +95,50 @@ export async function testConnection(
   }
 }
 
+export async function readRemoteFile(
+  server: RemoteServer,
+  remotePath: string,
+): Promise<string> {
+  const escaped = `'${remotePath.replace(/'/g, "'\\''")}'`
+  const result = await sshExec(server, `cat ${escaped}`)
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || "Failed to read remote file")
+  }
+  return result.stdout
+}
+
+export async function writeRemoteFile(
+  server: RemoteServer,
+  remotePath: string,
+  content: string,
+): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const escaped = `'${remotePath.replace(/'/g, "'\\''")}'`
+    const command = `mkdir -p "$(dirname ${escaped})" && cat > ${escaped}`
+    const args = [...buildSshArgs(server), command]
+    const proc = spawn("ssh", args, {
+      stdio: ["pipe", "pipe", "pipe"],
+    })
+
+    let stderr = ""
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString("utf-8")
+    })
+
+    proc.on("error", (err) => reject(new Error(err.message)))
+    proc.on("close", (code) => {
+      if ((code ?? 1) === 0) {
+        resolve()
+      } else {
+        reject(new Error(stderr.trim() || `SSH exited with code ${code ?? 1}`))
+      }
+    })
+
+    proc.stdin.write(content, "utf-8")
+    proc.stdin.end()
+  })
+}
+
 // ---------- Remote Skill Scanner ----------
 
 function shellQuotePath(remotePath: string): string {

package/src/store/types.ts

@@ -20,8 +20,16 @@ export interface EnrichedSkill {
   name: string
   description: string
   filePath: string
+  canonicalPath: string
   /** Which agents have this skill installed (by agent name) */
   agents: AgentType[]
+  scope: "global" | "project" | "custom"
+  projectName: string | null
+  hasSupportingFiles: boolean
+  supportingFiles: Array<{
+    relativePath: string
+    size: number
+  }>
   /** Frontmatter metadata from the SKILL.md */
   metadata: Record<string, unknown>
   /** Lock file entry if tracked */

package/src/types/bun-sqlite.d.ts

@@ -0,0 +1,12 @@
+declare module "bun:sqlite" {
+  export class Database {
+    constructor(path: string)
+    query(sql: string): {
+      all(...params: unknown[]): unknown[]
+      get(...params: unknown[]): unknown
+      run(...params: unknown[]): { changes: number }
+    }
+    exec(sql: string): void
+    close(): void
+  }
+}

package/src/views/add-server.tsx

@@ -201,16 +201,16 @@ export function AddServerView({ editServerId, onServerCountChange }: AddServerVi
             <input
               placeholder={field.placeholder}
               focused={i === focusedFieldIndex && !state.showHelp && !saving}
-              defaultValue={values[field.name]}
+              {...({ defaultValue: values[field.name] } as any)}
               onInput={(value: string) => handleFieldChange(field.name, value)}
-              onSubmit={() => {
+              onSubmit={(() => {
                 // When pressing Enter on the last field, save
                 if (i === FIELDS.length - 1) {
                   handleSave()
                 } else {
                   setFocusedFieldIndex(i + 1)
                 }
-              }}
+              }) as any}
             />
           </box>
         </box>

package/src/views/discover.tsx

@@ -100,7 +100,7 @@ export function DiscoverView() {
       if (searchMode === "keyword") {
         if (!isAuthenticated) {
           dispatch({
-            type: "SET_NOTIFICATION",
+            type: "SHOW_NOTIFICATION",
             notification: { type: "info", message: "Sign in to use AI search (press l)" },
           })
           return
@@ -154,10 +154,10 @@ export function DiscoverView() {
                 : "Search by keyword... (Enter to search)"
             }
             focused={state.activeView === "discover" && !state.showHelp}
-            onSubmit={(value: string) => {
+            onSubmit={((value: string) => {
               setQuery(value)
               setSelectedIndex(0)
-            }}
+            }) as any}
           />
         ) : (
           <text fg={colors.textDim}>/ to search, Tab to cycle panes</text>
@@ -213,10 +213,10 @@ export function DiscoverView() {
         <box
           style={{
             width: "40%",
-            borderRight: true,
+            border: true,
             borderColor: state.focusedPane === "list" ? colors.primary : colors.border,
             flexDirection: "column",
-          }}
+          } as any}
         >
           {/* List header */}
           <box style={{ height: 1, paddingLeft: 1, backgroundColor: colors.bgAlt }}>
@@ -396,7 +396,12 @@ function catalogSkillToEnriched(skill: CatalogSkill): import("../store/types.js"
     name: skill.name,
     description: skill.summary || skill.description || "",
     filePath: "", // No local file for catalog items
+    canonicalPath: "",
     agents: [],
+    scope: "custom",
+    projectName: null,
+    hasSupportingFiles: false,
+    supportingFiles: [],
     metadata: {
       categories: skill.categories,
       capabilities: skill.capabilities,