ide-agents 0.1.0

package/dist/paths.js

@@ -0,0 +1,57 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function getIdeAgentsHome() {
+    return path.join(homedir(), ".ide-agents");
+}
+export function getConfigPath() {
+    return path.join(getIdeAgentsHome(), "config.json");
+}
+export function getStatePath() {
+    return path.join(getIdeAgentsHome(), "state.json");
+}
+export function getReposDir() {
+    return path.join(getIdeAgentsHome(), "repos");
+}
+export function getRepoPath(slug) {
+    return path.join(getReposDir(), slug);
+}
+export function slugFromUrl(url) {
+    const normalized = url
+        .replace(/^git@([^:]+):(.+)\.git$/, "https://$1/$2")
+        .replace(/^file:\/\//, "file://")
+        .replace(/\.git$/, "")
+        .replace(/\/$/, "");
+    if (normalized.startsWith("file://")) {
+        const localPath = normalized.slice("file://".length);
+        return localPath
+            .replace(/^\/+/, "")
+            .replace(/[^a-zA-Z0-9]+/g, "-")
+            .replace(/^-+|-+$/g, "")
+            .toLowerCase() || "local-repo";
+    }
+    try {
+        const parsed = new URL(normalized);
+        const host = parsed.hostname.replace(/\./g, "-");
+        const pathname = parsed.pathname
+            .replace(/^\//, "")
+            .replace(/\//g, "-")
+            .replace(/[^a-zA-Z0-9-]/g, "-")
+            .replace(/-+/g, "-")
+            .replace(/^-|-$/g, "");
+        return `${host}-${pathname}`.toLowerCase();
+    }
+    catch {
+        return normalized
+            .replace(/[^a-zA-Z0-9]+/g, "-")
+            .replace(/^-+|-+$/g, "")
+            .toLowerCase();
+    }
+}
+export function getWebDistDir() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(moduleDir, "../web/dist");
+}
+export function resolveProjectPath(projectPath) {
+    return path.resolve(projectPath);
+}

package/dist/scan.d.ts

@@ -0,0 +1,2 @@
+import type { Artifact } from "./types.js";
+export declare function scanRepoArtifacts(repoPath: string): Promise<Artifact[]>;

package/dist/scan.js

@@ -0,0 +1,112 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import matter from "gray-matter";
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseAllowedScope(data) {
+    const scope = data.scope;
+    if (scope === "global" || scope === "project" || scope === "any") {
+        return scope;
+    }
+    return null;
+}
+function parseAgentDescription(content, fallbackName) {
+    const parsed = matter(content);
+    if (typeof parsed.data.description === "string" && parsed.data.description.trim()) {
+        return parsed.data.description.trim();
+    }
+    const body = parsed.content.trim();
+    if (!body) {
+        return "";
+    }
+    for (const line of body.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("#")) {
+            return trimmed.replace(/^#+\s*/, "");
+        }
+        return trimmed;
+    }
+    return fallbackName;
+}
+async function scanSkills(repoPath) {
+    const skillsDir = path.join(repoPath, "skills");
+    if (!(await pathExists(skillsDir))) {
+        return [];
+    }
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    const artifacts = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillDir = path.join(skillsDir, 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);
+        }
+        artifacts.push({
+            id: entry.name,
+            kind: "skill",
+            sourcePath: path.join("skills", entry.name),
+            name,
+            description,
+            hasSkillMd,
+            allowedScope,
+        });
+    }
+    return artifacts.sort((a, b) => a.id.localeCompare(b.id));
+}
+async function scanAgents(repoPath) {
+    const agentsDir = path.join(repoPath, "agents");
+    if (!(await pathExists(agentsDir))) {
+        return [];
+    }
+    const entries = await readdir(agentsDir, { withFileTypes: true });
+    const artifacts = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md"))
+            continue;
+        const agentPath = path.join(agentsDir, entry.name);
+        const id = entry.name.replace(/\.md$/, "");
+        const raw = await readFile(agentPath, "utf8");
+        const parsed = matter(raw);
+        const description = parseAgentDescription(raw, id);
+        const allowedScope = parseAllowedScope(parsed.data);
+        artifacts.push({
+            id,
+            kind: "agent",
+            sourcePath: path.join("agents", entry.name),
+            name: id,
+            description,
+            allowedScope,
+        });
+    }
+    return artifacts.sort((a, b) => a.id.localeCompare(b.id));
+}
+export async function scanRepoArtifacts(repoPath) {
+    const [skills, agents] = await Promise.all([
+        scanSkills(repoPath),
+        scanAgents(repoPath),
+    ]);
+    return [...skills, ...agents];
+}

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+import Fastify from "fastify";
+export interface ServerOptions {
+    port: number;
+    host?: string;
+    launchCwd?: string;
+}
+export declare function createServer(options: ServerOptions): Promise<Fastify.FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, Fastify.FastifyBaseLogger, Fastify.FastifyTypeProviderDefault>>;
+export declare function startServer(options: ServerOptions): Promise<Fastify.FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, Fastify.FastifyBaseLogger, Fastify.FastifyTypeProviderDefault>>;

package/dist/server.js

@@ -0,0 +1,195 @@
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import { v4 as uuidv4 } from "uuid";
+import { addRecentProject, readConfig, writeConfig, } from "./config.js";
+import { cloneRepo, fetchRepo, getGitStatusWithoutFetch, pullRepo, } from "./git.js";
+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";
+export async function createServer(options) {
+    const app = Fastify({ logger: false });
+    app.setErrorHandler((error, _request, reply) => {
+        reply.status(500).send({
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+    app.get("/api/status", async () => {
+        const config = await readConfig();
+        return {
+            home: getIdeAgentsHome(),
+            adapter: config.adapter,
+            port: options.port,
+            version: VERSION,
+            defaultProjectPath: options.launchCwd ?? null,
+        };
+    });
+    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);
+            repos.push({
+                ...repo,
+                localPath: getRepoPath(repo.slug),
+                git,
+            });
+        }
+        return { repos };
+    });
+    app.post("/api/repos", async (request, reply) => {
+        const { url, ref = "main", id } = request.body ?? {};
+        if (!url?.trim()) {
+            return reply.status(400).send({ error: "url is required" });
+        }
+        const config = await readConfig();
+        const slug = slugFromUrl(url.trim());
+        const repoId = id?.trim() || slug;
+        if (config.repos.some((r) => r.id === repoId)) {
+            return reply.status(409).send({ error: `Repository id already exists: ${repoId}` });
+        }
+        try {
+            await cloneRepo(url.trim(), slug, ref);
+        }
+        catch (err) {
+            return reply.status(400).send({
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const repo = { id: repoId, url: url.trim(), ref, slug };
+        config.repos.push(repo);
+        await writeConfig(config);
+        const git = await getGitStatusWithoutFetch(slug, ref);
+        return {
+            repo: {
+                ...repo,
+                localPath: getRepoPath(slug),
+                git,
+            },
+        };
+    });
+    app.delete("/api/repos/:id", async (request, reply) => {
+        const config = await readConfig();
+        const index = config.repos.findIndex((r) => r.id === request.params.id);
+        if (index === -1) {
+            return reply.status(404).send({ error: "Repository not found" });
+        }
+        config.repos.splice(index, 1);
+        config.installations = config.installations.filter((i) => i.repoId !== request.params.id);
+        await writeConfig(config);
+        return { ok: true };
+    });
+    app.post("/api/repos/:id/fetch", 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);
+        if (!repo) {
+            return reply.status(404).send({ error: "Repository not found" });
+        }
+        try {
+            await pullRepo(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.get("/api/repos/:id/artifacts", 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" });
+        }
+        const projectPath = request.query.projectPath?.trim() || null;
+        const scanned = await scanRepoArtifacts(getRepoPath(repo.slug));
+        const artifacts = await Promise.all(scanned.map(async (artifact) => ({
+            ...artifact,
+            targets: await getArtifactTargets(artifact, projectPath, config.adapter),
+        })));
+        return { artifacts };
+    });
+    app.get("/api/installations", async () => {
+        const config = await readConfig();
+        return {
+            installations: config.installations,
+            recentProjects: config.recentProjects,
+        };
+    });
+    app.put("/api/installations", async (request, reply) => {
+        const { installations } = request.body ?? {};
+        if (!Array.isArray(installations)) {
+            return reply.status(400).send({ error: "installations array is required" });
+        }
+        const config = await readConfig();
+        const normalized = installations.map((installation) => ({
+            ...installation,
+            id: installation.id || uuidv4(),
+        }));
+        for (const installation of normalized) {
+            if (installation.project && installation.projectPath) {
+                const updated = await addRecentProject(config, installation.projectPath);
+                config.recentProjects = updated.recentProjects;
+            }
+        }
+        config.installations = normalized;
+        await writeConfig(config);
+        return { installations: config.installations };
+    });
+    app.post("/api/apply", async (_request, reply) => {
+        const config = await readConfig();
+        try {
+            const result = await applyInstallations(config);
+            return result;
+        }
+        catch (err) {
+            return reply.status(400).send({
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    });
+    app.post("/api/open", async (request, reply) => {
+        const { url } = request.body ?? {};
+        if (!url?.trim()) {
+            return reply.status(400).send({ error: "url is required" });
+        }
+        return { url: url.trim() };
+    });
+    const webDist = getWebDistDir();
+    await app.register(fastifyStatic, {
+        root: webDist,
+        prefix: "/",
+        wildcard: false,
+    });
+    app.setNotFoundHandler((request, reply) => {
+        if (request.url.startsWith("/api/")) {
+            return reply.status(404).send({ error: "Not found" });
+        }
+        return reply.sendFile("index.html", webDist);
+    });
+    return app;
+}
+export async function startServer(options) {
+    const app = await createServer(options);
+    await app.listen({ port: options.port, host: options.host ?? "127.0.0.1" });
+    return app;
+}

package/dist/targets.d.ts

@@ -0,0 +1,4 @@
+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 installationStub(artifact: Pick<Artifact, "kind" | "id" | "sourcePath">, projectPath: string | null): Pick<Installation, "kind" | "targetName" | "sourcePath" | "projectPath">;

package/dist/targets.js

@@ -0,0 +1,42 @@
+import { lstat } from "node:fs/promises";
+import { getAdapter } from "./adapters/cursor.js";
+export async function getTargetStatus(targetPath) {
+    try {
+        const stats = await lstat(targetPath);
+        const isSymlink = stats.isSymbolicLink();
+        return {
+            exists: true,
+            isSymlink,
+            blocked: !isSymlink,
+        };
+    }
+    catch {
+        return {
+            exists: false,
+            isSymlink: false,
+            blocked: false,
+        };
+    }
+}
+export async function getArtifactTargets(artifact, projectPath, adapterId) {
+    const adapter = getAdapter(adapterId);
+    const installation = {
+        kind: artifact.kind,
+        targetName: artifact.id,
+        projectPath,
+    };
+    const global = await getTargetStatus(adapter.getGlobalTargetPath(installation));
+    let project = null;
+    if (projectPath) {
+        project = await getTargetStatus(adapter.getProjectTargetPath(installation));
+    }
+    return { global, project };
+}
+export function installationStub(artifact, projectPath) {
+    return {
+        kind: artifact.kind,
+        targetName: artifact.id,
+        sourcePath: artifact.sourcePath,
+        projectPath,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+export type ArtifactKind = "skill" | "agent";
+export type ArtifactAllowedScope = "global" | "project" | "any";
+export type AdapterId = "cursor";
+export interface ServerConfig {
+    port: number;
+}
+export interface RepoConfig {
+    id: string;
+    url: string;
+    ref: string;
+    slug: string;
+}
+export interface Installation {
+    id: string;
+    repoId: string;
+    kind: ArtifactKind;
+    artifactId: string;
+    sourcePath: string;
+    targetName: string;
+    global: boolean;
+    project: boolean;
+    projectPath: string | null;
+}
+export interface IdeAgentsConfig {
+    version: 1;
+    adapter: AdapterId;
+    server: ServerConfig;
+    repos: RepoConfig[];
+    installations: Installation[];
+    recentProjects: string[];
+}
+/** @deprecated renamed to IdeAgentsConfig */
+export type AgentDeskConfig = IdeAgentsConfig;
+export interface TargetStatus {
+    exists: boolean;
+    isSymlink: boolean;
+    blocked: boolean;
+}
+export interface ArtifactTargets {
+    global: TargetStatus;
+    project: TargetStatus | null;
+}
+export interface Artifact {
+    id: string;
+    kind: ArtifactKind;
+    sourcePath: string;
+    name: string;
+    description: string;
+    hasSkillMd?: boolean;
+    allowedScope: ArtifactAllowedScope | null;
+    targets?: ArtifactTargets;
+}
+export interface GitStatus {
+    branch: string | null;
+    sha: string | null;
+    dirty: boolean;
+    behind: number | null;
+    ahead: number | null;
+    error?: string;
+}
+export interface RepoWithStatus extends RepoConfig {
+    localPath: string;
+    git: GitStatus;
+}
+export interface ApplyResultItem {
+    path: string;
+    action: "created" | "removed" | "skipped";
+    error?: string;
+}
+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

@@ -0,0 +1 @@
+export const PACKAGE_VERSION = "0.1.0";

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "ide-agents",
+  "version": "0.1.0",
+  "description": "Local admin for IDE agents and skills from git repos",
+  "type": "module",
+  "bin": {
+    "ide-agents": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "web/dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build:server": "tsc",
+    "build:web": "vite build --config web/vite.config.ts",
+    "build": "npm run build:server && npm run build:web",
+    "prepublishOnly": "npm run build",
+    "dev:server": "tsx watch src/cli.ts --no-open",
+    "dev:web": "vite --config web/vite.config.ts",
+    "dev": "concurrently -n server,web -c blue,green \"npm run dev:server\" \"npm run dev:web\"",
+    "start": "node dist/cli.js",
+    "docs:install": "npm install --prefix docs",
+    "docs:start": "npm --prefix docs start",
+    "docs:build": "npm --prefix docs run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "ide-agents",
+    "cursor",
+    "skills",
+    "agents",
+    "subagents",
+    "cli",
+    "symlink",
+    "ide",
+    "ai"
+  ],
+  "author": "sergeychernov",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sergeychernov/agentdesk.git"
+  },
+  "homepage": "https://github.com/sergeychernov/agentdesk#readme",
+  "bugs": {
+    "url": "https://github.com/sergeychernov/agentdesk/issues"
+  },
+  "dependencies": {
+    "@fastify/static": "^8.1.1",
+    "fastify": "^5.2.1",
+    "gray-matter": "^4.0.3",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@mantine/core": "^9.2.2",
+    "@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",
+    "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-router-dom": "^7.3.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "vite": "^6.2.1"
+  }
+}