ide-agents 0.1.0 → 0.2.0

package/dist/scan.js

@@ -15,7 +15,7 @@ function parseAllowedScope(data) {
     if (scope === "global" || scope === "project" || scope === "any") {
         return scope;
     }
-    return null;
+    return "any";
 }
 function parseAgentDescription(content, fallbackName) {
     const parsed = matter(content);
@@ -37,45 +37,74 @@ function parseAgentDescription(content, fallbackName) {
     }
     return fallbackName;
 }
-async function scanSkills(repoPath) {
-    const skillsDir = path.join(repoPath, "skills");
-    if (!(await pathExists(skillsDir))) {
+async function parseSkillDirectory(skillDir, dirName) {
+    const skillMdPath = path.join(skillDir, "SKILL.md");
+    const hasSkillMd = await pathExists(skillMdPath);
+    let name = dirName;
+    let description = "";
+    let allowedScope = "any";
+    if (hasSkillMd) {
+        const raw = await readFile(skillMdPath, "utf8");
+        const parsed = matter(raw);
+        if (typeof parsed.data.name === "string" && parsed.data.name.trim()) {
+            name = parsed.data.name.trim();
+        }
+        if (typeof parsed.data.description === "string") {
+            description = parsed.data.description.trim();
+        }
+        allowedScope = parseAllowedScope(parsed.data);
+    }
+    return { id: dirName, name, description, hasSkillMd, allowedScope };
+}
+function toSkillArtifact(sourcePath, parsed) {
+    return {
+        id: parsed.id,
+        kind: "skill",
+        sourcePath,
+        name: parsed.name,
+        description: parsed.description,
+        hasSkillMd: parsed.hasSkillMd,
+        allowedScope: parsed.allowedScope,
+    };
+}
+async function scanSkillsInDirectory(parentDir, sourcePathPrefix) {
+    if (!(await pathExists(parentDir))) {
         return [];
     }
-    const entries = await readdir(skillsDir, { withFileTypes: true });
+    const entries = await readdir(parentDir, { withFileTypes: true });
     const artifacts = [];
     for (const entry of entries) {
         if (!entry.isDirectory())
             continue;
-        const skillDir = path.join(skillsDir, entry.name);
+        if (entry.name.startsWith("."))
+            continue;
+        const skillDir = path.join(parentDir, entry.name);
         const skillMdPath = path.join(skillDir, "SKILL.md");
-        const hasSkillMd = await pathExists(skillMdPath);
-        let name = entry.name;
-        let description = "";
-        let allowedScope = null;
-        if (hasSkillMd) {
-            const raw = await readFile(skillMdPath, "utf8");
-            const parsed = matter(raw);
-            if (typeof parsed.data.name === "string" && parsed.data.name.trim()) {
-                name = parsed.data.name.trim();
-            }
-            if (typeof parsed.data.description === "string") {
-                description = parsed.data.description.trim();
-            }
-            allowedScope = parseAllowedScope(parsed.data);
+        if (!(await pathExists(skillMdPath))) {
+            continue;
         }
-        artifacts.push({
-            id: entry.name,
-            kind: "skill",
-            sourcePath: path.join("skills", entry.name),
-            name,
-            description,
-            hasSkillMd,
-            allowedScope,
-        });
+        const parsed = await parseSkillDirectory(skillDir, entry.name);
+        const relativeSource = sourcePathPrefix
+            ? path.join(sourcePathPrefix, entry.name)
+            : entry.name;
+        artifacts.push(toSkillArtifact(relativeSource, parsed));
     }
     return artifacts.sort((a, b) => a.id.localeCompare(b.id));
 }
+async function scanSkillsNested(repoPath) {
+    return scanSkillsInDirectory(path.join(repoPath, "skills"), "skills");
+}
+/** Repos like bluriesophos/cursorskills: `<repo>/<skill-name>/SKILL.md` at root. */
+async function scanSkillsFlat(repoPath) {
+    return scanSkillsInDirectory(repoPath, "");
+}
+async function scanSkills(repoPath) {
+    const nested = await scanSkillsNested(repoPath);
+    if (nested.length > 0) {
+        return nested;
+    }
+    return scanSkillsFlat(repoPath);
+}
 async function scanAgents(repoPath) {
     const agentsDir = path.join(repoPath, "agents");
     if (!(await pathExists(agentsDir))) {

package/dist/server.js

@@ -6,8 +6,9 @@ import { cloneRepo, fetchRepo, getGitStatusWithoutFetch, pullRepo, } from "./git
 import { applyInstallations } from "./apply.js";
 import { scanRepoArtifacts } from "./scan.js";
 import { getArtifactTargets } from "./targets.js";
-import { getIdeAgentsHome, getRepoPath, getWebDistDir, slugFromUrl, } from "./paths.js";
-import { PACKAGE_VERSION as VERSION } from "./types.js";
+import { expandUserPath, getIdeAgentsHome, getRepoPath, getWebDistDir, slugFromUrl, } from "./paths.js";
+import { defaultAdapterFromIdes, getDefaultIdes } from "./ides.js";
+import { PACKAGE_VERSION as VERSION } from "./version.js";
 export async function createServer(options) {
     const app = Fastify({ logger: false });
     app.setErrorHandler((error, _request, reply) => {
@@ -19,21 +20,70 @@ export async function createServer(options) {
         const config = await readConfig();
         return {
             home: getIdeAgentsHome(),
-            adapter: config.adapter,
             port: options.port,
             version: VERSION,
             defaultProjectPath: options.launchCwd ?? null,
+            ides: config.ides,
         };
     });
+    app.get("/api/settings", async () => {
+        const config = await readConfig();
+        return {
+            ides: config.ides,
+            defaults: getDefaultIdes(),
+            home: getIdeAgentsHome(),
+            version: VERSION,
+        };
+    });
+    app.put("/api/settings", async (request, reply) => {
+        const { ides } = request.body ?? {};
+        if (!ides) {
+            return reply.status(400).send({ error: "ides is required" });
+        }
+        for (const key of ["cursor", "claude", "codex"]) {
+            const entry = ides[key];
+            if (!entry || typeof entry.configPath !== "string" || !entry.configPath.trim()) {
+                return reply.status(400).send({ error: `Invalid config for ${key}` });
+            }
+        }
+        const normalized = {
+            cursor: {
+                enabled: Boolean(ides.cursor.enabled),
+                configPath: expandUserPath(ides.cursor.configPath),
+            },
+            claude: {
+                enabled: Boolean(ides.claude.enabled),
+                configPath: expandUserPath(ides.claude.configPath),
+            },
+            codex: {
+                enabled: Boolean(ides.codex.enabled),
+                configPath: expandUserPath(ides.codex.configPath),
+            },
+        };
+        if (!normalized.cursor.enabled &&
+            !normalized.claude.enabled &&
+            !normalized.codex.enabled) {
+            return reply.status(400).send({ error: "At least one IDE must be enabled" });
+        }
+        const config = await readConfig();
+        config.ides = normalized;
+        config.adapter = defaultAdapterFromIdes(config.ides);
+        await writeConfig(config);
+        return { ides: config.ides };
+    });
     app.get("/api/repos", async () => {
         const config = await readConfig();
         const repos = [];
         for (const repo of config.repos) {
             const git = await getGitStatusWithoutFetch(repo.slug, repo.ref);
+            const repoPath = getRepoPath(repo.slug);
+            const artifacts = await scanRepoArtifacts(repoPath);
             repos.push({
                 ...repo,
-                localPath: getRepoPath(repo.slug),
+                localPath: repoPath,
                 git,
+                skillCount: artifacts.filter((a) => a.kind === "skill").length,
+                agentCount: artifacts.filter((a) => a.kind === "agent").length,
             });
         }
         return { repos };
@@ -97,6 +147,23 @@ export async function createServer(options) {
         const git = await getGitStatusWithoutFetch(repo.slug, repo.ref);
         return { git };
     });
+    app.post("/api/repos/:id/check-updates", async (request, reply) => {
+        const config = await readConfig();
+        const repo = config.repos.find((r) => r.id === request.params.id);
+        if (!repo) {
+            return reply.status(404).send({ error: "Repository not found" });
+        }
+        try {
+            await fetchRepo(repo.slug);
+        }
+        catch (err) {
+            return reply.status(400).send({
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const git = await getGitStatusWithoutFetch(repo.slug, repo.ref);
+        return { git };
+    });
     app.post("/api/repos/:id/pull", async (request, reply) => {
         const config = await readConfig();
         const repo = config.repos.find((r) => r.id === request.params.id);
@@ -124,7 +191,7 @@ export async function createServer(options) {
         const scanned = await scanRepoArtifacts(getRepoPath(repo.slug));
         const artifacts = await Promise.all(scanned.map(async (artifact) => ({
             ...artifact,
-            targets: await getArtifactTargets(artifact, projectPath, config.adapter),
+            targets: await getArtifactTargets(artifact, projectPath, config),
         })));
         return { artifacts };
     });

package/dist/targets.d.ts

@@ -1,4 +1,5 @@
+import type { IdeAgentsConfig } from "./types.js";
 import type { Artifact, ArtifactTargets, Installation, TargetStatus } from "./types.js";
 export declare function getTargetStatus(targetPath: string): Promise<TargetStatus>;
-export declare function getArtifactTargets(artifact: Pick<Artifact, "kind" | "id">, projectPath: string | null, adapterId: string): Promise<ArtifactTargets>;
+export declare function getArtifactTargets(artifact: Pick<Artifact, "kind" | "id">, projectPath: string | null, config: IdeAgentsConfig): Promise<ArtifactTargets>;
 export declare function installationStub(artifact: Pick<Artifact, "kind" | "id" | "sourcePath">, projectPath: string | null): Pick<Installation, "kind" | "targetName" | "sourcePath" | "projectPath">;

package/dist/targets.js

@@ -1,5 +1,5 @@
 import { lstat } from "node:fs/promises";
-import { getAdapter } from "./adapters/cursor.js";
+import { getEnabledAdapters } from "./adapters/index.js";
 export async function getTargetStatus(targetPath) {
     try {
         const stats = await lstat(targetPath);
@@ -18,17 +18,35 @@ export async function getTargetStatus(targetPath) {
         };
     }
 }
-export async function getArtifactTargets(artifact, projectPath, adapterId) {
-    const adapter = getAdapter(adapterId);
+function mergeTargetStatus(current, next) {
+    return {
+        exists: current.exists || next.exists,
+        isSymlink: current.isSymlink || next.isSymlink,
+        blocked: current.blocked || next.blocked,
+    };
+}
+export async function getArtifactTargets(artifact, projectPath, config) {
+    const adapters = getEnabledAdapters(config);
     const installation = {
         kind: artifact.kind,
         targetName: artifact.id,
         projectPath,
     };
-    const global = await getTargetStatus(adapter.getGlobalTargetPath(installation));
+    let global = {
+        exists: false,
+        isSymlink: false,
+        blocked: false,
+    };
     let project = null;
-    if (projectPath) {
-        project = await getTargetStatus(adapter.getProjectTargetPath(installation));
+    for (const adapter of adapters) {
+        const globalStatus = await getTargetStatus(adapter.getGlobalTargetPath(installation));
+        global = mergeTargetStatus(global, globalStatus);
+        if (projectPath) {
+            const projectStatus = await getTargetStatus(adapter.getProjectTargetPath(installation));
+            project = project
+                ? mergeTargetStatus(project, projectStatus)
+                : projectStatus;
+        }
     }
     return { global, project };
 }

package/dist/types.d.ts

@@ -1,6 +1,17 @@
 export type ArtifactKind = "skill" | "agent";
 export type ArtifactAllowedScope = "global" | "project" | "any";
-export type AdapterId = "cursor";
+export type IdeId = "cursor" | "claude" | "codex";
+/** @deprecated use IdeId */
+export type AdapterId = IdeId;
+export interface IdeToolConfig {
+    enabled: boolean;
+    configPath: string;
+}
+export interface IdesConfig {
+    cursor: IdeToolConfig;
+    claude: IdeToolConfig;
+    codex: IdeToolConfig;
+}
 export interface ServerConfig {
     port: number;
 }
@@ -23,7 +34,9 @@ export interface Installation {
 }
 export interface IdeAgentsConfig {
     version: 1;
+    /** @deprecated kept for migration; use ides */
     adapter: AdapterId;
+    ides: IdesConfig;
     server: ServerConfig;
     repos: RepoConfig[];
     installations: Installation[];
@@ -61,6 +74,8 @@ export interface GitStatus {
 export interface RepoWithStatus extends RepoConfig {
     localPath: string;
     git: GitStatus;
+    skillCount: number;
+    agentCount: number;
 }
 export interface ApplyResultItem {
     path: string;
@@ -70,6 +85,5 @@ export interface ApplyResultItem {
 export interface ApplyResult {
     results: ApplyResultItem[];
 }
-export declare const PACKAGE_VERSION = "0.1.0";
 /** @deprecated legacy config field */
 export type Scope = "global" | "project" | "off";

package/dist/types.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = "0.1.0";
+export {};

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_VERSION: string;

package/dist/version.js

@@ -0,0 +1,6 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
+const { version } = require(path.join(fileURLToPath(new URL(".", import.meta.url)), "../package.json"));
+export const PACKAGE_VERSION = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ide-agents",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Local admin for IDE agents and skills from git repos",
   "type": "module",
   "bin": {
@@ -43,15 +43,15 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/sergeychernov/agentdesk.git"
+    "url": "git+https://github.com/sergeychernov/ide-agents.git"
   },
-  "homepage": "https://github.com/sergeychernov/agentdesk#readme",
+  "homepage": "https://ide-agents.vercel.app/",
   "bugs": {
-    "url": "https://github.com/sergeychernov/agentdesk/issues"
+    "url": "https://github.com/sergeychernov/ide-agents/issues"
   },
   "dependencies": {
     "@fastify/static": "^8.1.1",
-    "fastify": "^5.2.1",
+    "fastify": "^5.8.5",
     "gray-matter": "^4.0.3",
     "uuid": "^11.1.0"
   },
@@ -60,18 +60,18 @@
     "@mantine/hooks": "^9.2.2",
     "@tabler/icons-react": "^3.44.0",
     "@types/node": "^22.13.10",
-    "@types/react": "^19.0.10",
-    "@types/react-dom": "^19.0.4",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.2",
     "concurrently": "^9.1.2",
     "postcss": "^8.5.15",
     "postcss-preset-mantine": "^1.18.0",
     "postcss-simple-vars": "^7.0.1",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
     "react-router-dom": "^7.3.0",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
-    "vite": "^6.2.1"
+    "vite": "^8.0.14"
   }
 }