@thesmurph/agentlink 0.1.0

package/dist/scope.js

@@ -0,0 +1,100 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+export function resolveScope(scope, cwd) {
+    const root = scope === "global" ? homedir() : (findRepoRoot(cwd) ?? cwd);
+    const agentsDir = path.join(root, ".agents");
+    return {
+        scope,
+        root,
+        agentsDir,
+        instructions: path.join(root, "AGENTS.md"),
+        skills: path.join(agentsDir, "skills"),
+        stateFile: path.join(agentsDir, "agentlink.json"),
+    };
+}
+/**
+ * Walk up for a `.git` entry (directory, or a file for linked worktrees).
+ * Returns null when no repository root exists above cwd.
+ */
+export function findRepoRoot(cwd) {
+    let dir = path.resolve(cwd);
+    for (;;) {
+        if (existsSync(path.join(dir, ".git")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export function expandHome(input) {
+    if (input === "~")
+        return homedir();
+    if (input.startsWith("~/"))
+        return path.join(homedir(), input.slice(2));
+    return input;
+}
+export function exists(target) {
+    try {
+        statSync(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isDirectory(target) {
+    try {
+        return statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Names of the immediate subdirectories of `dir`, sorted; `[]` when missing. */
+export function listSubdirectories(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const names = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        if (entry.isDirectory()) {
+            names.push(entry.name);
+        }
+        else if (entry.isSymbolicLink()) {
+            // A symlink is only a skill if it resolves to a directory. A dangling or
+            // file-valued link would otherwise become a broken link in every harness.
+            try {
+                if (statSync(path.join(dir, entry.name)).isDirectory())
+                    names.push(entry.name);
+            }
+            catch {
+                /* broken symlink: reported by doctor, never linked */
+            }
+        }
+    }
+    return names.sort();
+}
+/** Names of dot-directories, which the convention reserves and skips. */
+export function listHiddenSubdirectories(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.name.startsWith(".") && (entry.isDirectory() || entry.isSymbolicLink()))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+export function relativeTo(fromDir, target) {
+    const rel = path.relative(fromDir, target);
+    return rel === "" ? "." : rel;
+}

package/dist/ui.js

@@ -0,0 +1,108 @@
+import { emitKeypressEvents } from "node:readline";
+const ESC = String.fromCharCode(27);
+const CURSOR_UP = (n) => (n > 0 ? `${ESC}[${n}A` : "");
+const CLEAR_LINE = `${ESC}[2K`;
+const DIM = `${ESC}[2m`;
+const BOLD = `${ESC}[1m`;
+const RESET = `${ESC}[0m`;
+const CYAN = `${ESC}[36m`;
+export async function selectMany(choices, options) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return choices.filter((c) => c.checked).map((c) => c.id);
+    }
+    return new Promise((resolve) => {
+        emitKeypressEvents(process.stdin);
+        let cursor = 0;
+        let drawnLines = 0;
+        const lines = () => {
+            const out = [];
+            out.push(`${BOLD}${options.title}${RESET}`);
+            if (options.help)
+                out.push(`${DIM}${options.help}${RESET}`);
+            choices.forEach((choice, index) => {
+                const active = index === cursor;
+                const box = choice.checked ? "[x]" : "[ ]";
+                const pointer = active ? `${CYAN}>${RESET}` : " ";
+                const hint = choice.hint ? ` ${DIM}${choice.hint}${RESET}` : "";
+                const label = active ? `${BOLD}${choice.label}${RESET}` : choice.label;
+                out.push(`${pointer} ${box} ${label}${hint}`);
+            });
+            return out;
+        };
+        const draw = () => {
+            const rendered = lines();
+            let output = CURSOR_UP(drawnLines);
+            for (const line of rendered)
+                output += `${CLEAR_LINE}${line}\n`;
+            if (rendered.length < drawnLines) {
+                for (let i = rendered.length; i < drawnLines; i += 1)
+                    output += `${CLEAR_LINE}\n`;
+                output += CURSOR_UP(drawnLines - rendered.length);
+            }
+            drawnLines = rendered.length;
+            process.stdout.write(output);
+        };
+        const cleanup = (result) => {
+            process.stdin.removeListener("keypress", onKey);
+            process.stdin.setRawMode?.(false);
+            process.stdin.pause();
+            resolve(result);
+        };
+        const onKey = (_str, key) => {
+            if (!key)
+                return;
+            const name = key.name ?? "";
+            if (key.ctrl && name === "c") {
+                process.stdout.write("\n");
+                cleanup(null);
+                return;
+            }
+            if (name === "escape") {
+                cleanup(null);
+                return;
+            }
+            if (name === "return" || name === "enter") {
+                process.stdout.write("\n");
+                cleanup(choices.filter((c) => c.checked).map((c) => c.id));
+                return;
+            }
+            if (name === "up" || name === "k") {
+                cursor = (cursor + choices.length - 1) % choices.length;
+                draw();
+                return;
+            }
+            if (name === "down" || name === "j") {
+                cursor = (cursor + 1) % choices.length;
+                draw();
+                return;
+            }
+            if (name === "space") {
+                const choice = choices[cursor];
+                if (choice)
+                    choice.checked = !choice.checked;
+                draw();
+                return;
+            }
+            if (name === "a") {
+                const allOn = choices.every((c) => c.checked);
+                choices.forEach((c) => {
+                    c.checked = !allOn;
+                });
+                draw();
+                return;
+            }
+            if (name === "i") {
+                choices.forEach((c) => {
+                    c.checked = c.group === "detected" ? true : false;
+                });
+                draw();
+                return;
+            }
+        };
+        emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode?.(true);
+        process.stdin.resume();
+        process.stdin.on("keypress", onKey);
+        draw();
+    });
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@thesmurph/agentlink",
+  "version": "0.1.0",
+  "description": "One source of truth for agent instructions and skills, symlinked into every coding-agent harness.",
+  "keywords": [
+    "agents.md",
+    "agent-skills",
+    "claude-code",
+    "codex",
+    "cursor",
+    "symlink",
+    "cli"
+  ],
+  "license": "MIT",
+  "author": "Sean Murphy (https://github.com/smurphnerd)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/smurphnerd/agentlink.git"
+  },
+  "homepage": "https://github.com/smurphnerd/agentlink#readme",
+  "bugs": {
+    "url": "https://github.com/smurphnerd/agentlink/issues"
+  },
+  "type": "module",
+  "bin": {
+    "agentlink": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "CONVENTION.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "dev": "node --experimental-strip-types src/cli.ts",
+    "test": "npm run build && node --test",
+    "test:unit": "node --test",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "@types/node": "^22.0.0"
+  }
+}