@chakresh/kresh 0.1.14 → 0.1.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chakresh/kresh",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "bin": {
     "kresh": "./src/index.js"
   },

package/src/commands/install.js

@@ -60,8 +60,23 @@ export async function installSkill(skillSlug, isRetry = false) {
       }
     }
 
+    const { agentType } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'agentType',
+        message: 'Which AI Agent are you installing this skill for?',
+        choices: [
+          { name: 'Antigravity (.agents/skills)', value: '.agents/skills' },
+          { name: 'Claude Code (.claude/skills)', value: '.claude/skills' },
+          { name: 'Codex (.codex/skills)', value: '.codex/skills' },
+          { name: 'Cursor (.cursor/skills)', value: '.cursor/skills' },
+          { name: 'Standard / Other (skills)', value: 'skills' }
+        ]
+      }
+    ]);
+
     spinner.start('Writing skill files locally...');
-    const savedDir = await writeLocalSkill(skillSlug, skillContent, metadata);
+    const savedDir = await writeLocalSkill(skillSlug, skillContent, metadata, agentType);
 
     spinner.succeed(`Successfully installed ${logger.bold(metadata.name)} (v${metadata.currentVersion}) by @${metadata.ownerUsername}`);
     logger.info(`Saved to: ${logger.bold(savedDir)}`);

package/src/services/api.js

@@ -1,7 +1,7 @@
 import axios from 'axios';
 import { getToken } from './auth.js';
 
-const baseURL = process.env.KRESH_API_URL || 'http://localhost:3000'; // Assume localhost for local testing
+const baseURL = process.env.KRESH_API_URL || 'https://kresh.vercel.app';
 
 export const api = axios.create({
   baseURL,

package/src/services/filesystem.js

@@ -1,6 +1,8 @@
 import fs from 'fs/promises';
 import path from 'path';
 
+const BASE_DIRS = ['skills', '.agents/skills', '.claude/skills', '.codex/skills', '.cursor/skills'];
+
 /**
  * Helper to find the workspace or project root directory by scanning up.
  */
@@ -49,140 +51,152 @@ export async function getWorkspaceRoot(startDir = process.cwd()) {
 /**
  * Writes the SKILL.md and metadata.json files directly in a folder named after the skill's slug (excluding @owner scope folder) inside the skills folder.
  */
-export async function writeLocalSkill(slug, skillContent, metadata) {
+export async function writeLocalSkill(slug, skillContent, metadata, baseDir = 'skills') {
   try {
     const rootDir = await getWorkspaceRoot();
     const folderName = (slug || metadata.slug).split('/').pop();
-    const targetDir = path.join(rootDir, 'skills', folderName);
+    const targetDir = path.join(rootDir, baseDir, folderName);
     
     await fs.mkdir(targetDir, { recursive: true });
     await fs.writeFile(path.join(targetDir, 'SKILL.md'), skillContent, 'utf8');
     await fs.writeFile(path.join(targetDir, 'metadata.json'), JSON.stringify(metadata, null, 2), 'utf8');
     return targetDir;
   } catch (error) {
-    console.error('Failed to write skill files in the skills directory:', error);
+    console.error(`Failed to write skill files in the ${baseDir} directory:`, error);
     throw new Error(`Local file system write failed: ${error.message}`);
   }
 }
 
-/**
- * Reads the local metadata.json of a specific skill if it exists.
- */
 export async function readLocalSkillMetadata(slug) {
-  try {
-    const rootDir = await getWorkspaceRoot();
-    const folderName = slug.split('/').pop();
-    const metadataPath = path.join(rootDir, 'skills', folderName, 'metadata.json');
-    const data = await fs.readFile(metadataPath, 'utf8');
-    return JSON.parse(data);
-  } catch (error) {
-    // Also try legacy path for backwards compatibility
+  const rootDir = await getWorkspaceRoot();
+  const folderName = slug.split('/').pop();
+  
+  for (const baseDir of BASE_DIRS) {
     try {
-      const rootDir = await getWorkspaceRoot();
-      const legacyPath = path.join(rootDir, 'skills', slug, 'metadata.json');
-      const data = await fs.readFile(legacyPath, 'utf8');
+      const metadataPath = path.join(rootDir, baseDir, folderName, 'metadata.json');
+      const data = await fs.readFile(metadataPath, 'utf8');
       return JSON.parse(data);
-    } catch (e) {
-      return null;
+    } catch (error) {
+      // Also try legacy path for backwards compatibility
+      try {
+        const legacyPath = path.join(rootDir, baseDir, slug, 'metadata.json');
+        const data = await fs.readFile(legacyPath, 'utf8');
+        return JSON.parse(data);
+      } catch (e) {
+        // Continue to the next baseDir
+      }
     }
   }
+  return null;
 }
 
-/**
- * Removes the skill directory.
- */
 export async function removeLocalSkill(slug) {
   try {
     const rootDir = await getWorkspaceRoot();
     const folderName = slug.split('/').pop();
-    const targetDir = path.join(rootDir, 'skills', folderName);
-    await fs.rm(targetDir, { recursive: true, force: true });
-    
-    // Also clean up legacy directory if it exists
-    const legacyDir = path.join(rootDir, 'skills', slug);
-    await fs.rm(legacyDir, { recursive: true, force: true });
     
-    // Clean up empty parent directory (e.g. @username) if it becomes empty
-    if (slug.includes('/')) {
-      const parts = slug.split('/');
-      const parentDir = path.join(rootDir, 'skills', parts[0]);
-      try {
-        const files = await fs.readdir(parentDir);
-        if (files.length === 0) {
-          await fs.rmdir(parentDir);
+    for (const baseDir of BASE_DIRS) {
+      const targetDir = path.join(rootDir, baseDir, folderName);
+      await fs.rm(targetDir, { recursive: true, force: true });
+      
+      // Also clean up legacy directory if it exists
+      const legacyDir = path.join(rootDir, baseDir, slug);
+      await fs.rm(legacyDir, { recursive: true, force: true });
+      
+      // Clean up empty parent directory (e.g. @username) if it becomes empty
+      if (slug.includes('/')) {
+        const parts = slug.split('/');
+        const parentDir = path.join(rootDir, baseDir, parts[0]);
+        try {
+          const files = await fs.readdir(parentDir);
+          if (files.length === 0) {
+            await fs.rmdir(parentDir);
+          }
+        } catch (e) {
+          // Ignore
         }
-      } catch (e) {
-        // Ignore
       }
     }
     return true;
   } catch (error) {
-    console.error('Failed to remove skill files from the skills directory:', error);
+    console.error('Failed to remove skill files from the skills directories:', error);
     throw new Error(`Local file system removal failed: ${error.message}`);
   }
 }
 
-/**
- * Lists all installed skills by inspecting the skills directory.
- */
 export async function listLocalSkills() {
   try {
     const rootDir = await getWorkspaceRoot();
-    const skillsDir = path.join(rootDir, 'skills');
-    let entries = [];
-    try {
-      entries = await fs.readdir(skillsDir, { withFileTypes: true });
-    } catch (e) {
-      if (e.code === 'ENOENT') return [];
-      throw e;
-    }
-
     const skills = [];
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (entry.name.startsWith('@')) {
-          // Legacy support: It's a user scope directory, scan subdirectories inside it
-          const scopeDir = path.join(skillsDir, entry.name);
-          let subEntries = [];
-          try {
-            subEntries = await fs.readdir(scopeDir, { withFileTypes: true });
-          } catch (e) {
-            continue;
-          }
-          
-          for (const subEntry of subEntries) {
-            if (subEntry.isDirectory()) {
-              const scopedSlug = `${entry.name}/${subEntry.name}`;
-              const metadata = await readLocalSkillMetadata(scopedSlug);
-              if (metadata) {
+    const seenSlugs = new Set();
+    
+    for (const baseDir of BASE_DIRS) {
+      const skillsDir = path.join(rootDir, baseDir);
+      let entries = [];
+      try {
+        entries = await fs.readdir(skillsDir, { withFileTypes: true });
+      } catch (e) {
+        continue;
+      }
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (entry.name.startsWith('@')) {
+            // Legacy support: It's a user scope directory, scan subdirectories inside it
+            const scopeDir = path.join(skillsDir, entry.name);
+            let subEntries = [];
+            try {
+              subEntries = await fs.readdir(scopeDir, { withFileTypes: true });
+            } catch (e) {
+              continue;
+            }
+            
+            for (const subEntry of subEntries) {
+              if (subEntry.isDirectory()) {
+                const scopedSlug = `${entry.name}/${subEntry.name}`;
+                if (seenSlugs.has(scopedSlug)) continue;
+                
+                try {
+                  const metadataPath = path.join(skillsDir, entry.name, subEntry.name, 'metadata.json');
+                  const data = await fs.readFile(metadataPath, 'utf8');
+                  const metadata = JSON.parse(data);
+                  if (metadata) {
+                    skills.push({
+                      slug: metadata.slug || scopedSlug,
+                      installed: true,
+                      version: metadata.version || metadata.currentVersion || 'unknown',
+                      name: metadata.name || 'unknown',
+                      description: metadata.description || ''
+                    });
+                    seenSlugs.add(scopedSlug);
+                  }
+                } catch (e) {
+                  // Ignore
+                }
+              }
+            }
+          } else {
+            // New format: Directly under skills/
+            try {
+              const metadataPath = path.join(skillsDir, entry.name, 'metadata.json');
+              const data = await fs.readFile(metadataPath, 'utf8');
+              const metadata = JSON.parse(data);
+              const slug = metadata.slug || entry.name;
+              
+              if (metadata && !seenSlugs.has(slug)) {
                 skills.push({
-                  slug: metadata.slug || scopedSlug,
+                  slug: slug,
                   installed: true,
                   version: metadata.version || metadata.currentVersion || 'unknown',
                   name: metadata.name || 'unknown',
                   description: metadata.description || ''
                 });
+                seenSlugs.add(slug);
               }
+            } catch (e) {
+              // Ignore if metadata is invalid/missing
             }
           }
-        } else {
-          // New format: Directly under skills/
-          try {
-            const metadataPath = path.join(skillsDir, entry.name, 'metadata.json');
-            const data = await fs.readFile(metadataPath, 'utf8');
-            const metadata = JSON.parse(data);
-            if (metadata) {
-              skills.push({
-                slug: metadata.slug || entry.name,
-                installed: true,
-                version: metadata.version || metadata.currentVersion || 'unknown',
-                name: metadata.name || 'unknown',
-                description: metadata.description || ''
-              });
-            }
-          } catch (e) {
-            // Ignore if metadata is invalid/missing
-          }
         }
       }
     }