@dhruvwill/skills-cli 1.0.0

package/tests/hash.test.ts

@@ -0,0 +1,119 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdir, rm, writeFile } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { hashDirectory, directoryExists, compareDirectories } from "../src/lib/hash.ts";
+
+describe("Hash Utilities", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `skills-hash-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  describe("directoryExists", () => {
+    test("returns true for existing directory", async () => {
+      expect(await directoryExists(testDir)).toBe(true);
+    });
+
+    test("returns false for non-existing directory", async () => {
+      expect(await directoryExists(join(testDir, "nonexistent"))).toBe(false);
+    });
+
+    test("returns false for file path", async () => {
+      const filePath = join(testDir, "file.txt");
+      await writeFile(filePath, "content");
+      expect(await directoryExists(filePath)).toBe(false);
+    });
+  });
+
+  describe("hashDirectory", () => {
+    test("returns 'empty' for empty directory", async () => {
+      const hash = await hashDirectory(testDir);
+      expect(hash).toBe("empty");
+    });
+
+    test("returns consistent hash for same content", async () => {
+      await writeFile(join(testDir, "file1.txt"), "content1");
+      await writeFile(join(testDir, "file2.txt"), "content2");
+
+      const hash1 = await hashDirectory(testDir);
+      const hash2 = await hashDirectory(testDir);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    test("returns different hash for different content", async () => {
+      await writeFile(join(testDir, "file.txt"), "content1");
+      const hash1 = await hashDirectory(testDir);
+
+      await writeFile(join(testDir, "file.txt"), "content2");
+      const hash2 = await hashDirectory(testDir);
+
+      expect(hash1).not.toBe(hash2);
+    });
+
+    test("includes nested directories in hash", async () => {
+      await mkdir(join(testDir, "subdir"), { recursive: true });
+      await writeFile(join(testDir, "subdir", "nested.txt"), "nested content");
+
+      const hash1 = await hashDirectory(testDir);
+
+      await writeFile(join(testDir, "subdir", "nested.txt"), "modified content");
+      const hash2 = await hashDirectory(testDir);
+
+      expect(hash1).not.toBe(hash2);
+    });
+
+    test("returns 'empty' for non-existing directory", async () => {
+      const hash = await hashDirectory(join(testDir, "nonexistent"));
+      expect(hash).toBe("empty");
+    });
+  });
+
+  describe("compareDirectories", () => {
+    let sourceDir: string;
+    let targetDir: string;
+
+    beforeEach(async () => {
+      sourceDir = join(testDir, "source");
+      targetDir = join(testDir, "target");
+      await mkdir(sourceDir, { recursive: true });
+      await mkdir(targetDir, { recursive: true });
+    });
+
+    test("returns 'synced' for identical directories", async () => {
+      await writeFile(join(sourceDir, "file.txt"), "content");
+      await writeFile(join(targetDir, "file.txt"), "content");
+
+      const status = await compareDirectories(sourceDir, targetDir);
+      expect(status).toBe("synced");
+    });
+
+    test("returns 'not synced' for different directories", async () => {
+      await writeFile(join(sourceDir, "file.txt"), "content1");
+      await writeFile(join(targetDir, "file.txt"), "content2");
+
+      const status = await compareDirectories(sourceDir, targetDir);
+      expect(status).toBe("not synced");
+    });
+
+    test("returns 'target missing' for non-existing target", async () => {
+      await writeFile(join(sourceDir, "file.txt"), "content");
+      await rm(targetDir, { recursive: true });
+
+      const status = await compareDirectories(sourceDir, targetDir);
+      expect(status).toBe("target missing");
+    });
+
+    test("returns 'synced' for two empty directories", async () => {
+      const status = await compareDirectories(sourceDir, targetDir);
+      expect(status).toBe("synced");
+    });
+  });
+});

package/tests/paths.test.ts

@@ -0,0 +1,173 @@
+import { describe, test, expect } from "bun:test";
+import { parseGitUrl, getRemoteNamespace, getLocalNamespace } from "../src/lib/paths.ts";
+
+describe("parseGitUrl", () => {
+  describe("GitHub URLs", () => {
+    test("parses basic GitHub HTTPS URL", () => {
+      const result = parseGitUrl("https://github.com/owner/repo");
+      expect(result).toEqual({
+        host: "github.com",
+        owner: "owner",
+        repo: "repo",
+        cloneUrl: "https://github.com/owner/repo.git",
+      });
+    });
+
+    test("parses GitHub URL with .git suffix", () => {
+      const result = parseGitUrl("https://github.com/owner/repo.git");
+      expect(result).toEqual({
+        host: "github.com",
+        owner: "owner",
+        repo: "repo",
+        cloneUrl: "https://github.com/owner/repo.git",
+      });
+    });
+
+    test("parses GitHub URL with tree subdirectory", () => {
+      const result = parseGitUrl("https://github.com/owner/repo/tree/main/path/to/skill");
+      expect(result).toEqual({
+        host: "github.com",
+        owner: "owner",
+        repo: "repo",
+        branch: "main",
+        subdir: "path/to/skill",
+        cloneUrl: "https://github.com/owner/repo.git",
+      });
+    });
+
+    test("parses GitHub URL with blob subdirectory", () => {
+      const result = parseGitUrl("https://github.com/owner/repo/blob/main/skills/my-skill");
+      expect(result).toEqual({
+        host: "github.com",
+        owner: "owner",
+        repo: "repo",
+        branch: "main",
+        subdir: "skills/my-skill",
+        cloneUrl: "https://github.com/owner/repo.git",
+      });
+    });
+
+    test("parses GitHub SSH URL", () => {
+      const result = parseGitUrl("git@github.com:owner/repo.git");
+      expect(result).toEqual({
+        host: "github.com",
+        owner: "owner",
+        repo: "repo",
+        cloneUrl: "git@github.com:owner/repo.git",
+      });
+    });
+  });
+
+  describe("GitLab URLs", () => {
+    test("parses basic GitLab URL", () => {
+      const result = parseGitUrl("https://gitlab.com/owner/repo");
+      expect(result).toEqual({
+        host: "gitlab.com",
+        owner: "owner",
+        repo: "repo",
+        cloneUrl: "https://gitlab.com/owner/repo.git",
+      });
+    });
+
+    test("parses GitLab URL with subdirectory", () => {
+      const result = parseGitUrl("https://gitlab.com/owner/repo/-/tree/main/skills/my-skill");
+      expect(result).toEqual({
+        host: "gitlab.com",
+        owner: "owner",
+        repo: "repo",
+        branch: "main",
+        subdir: "skills/my-skill",
+        cloneUrl: "https://gitlab.com/owner/repo.git",
+      });
+    });
+
+    test("parses GitLab SSH URL", () => {
+      const result = parseGitUrl("git@gitlab.com:owner/repo.git");
+      expect(result).toEqual({
+        host: "gitlab.com",
+        owner: "owner",
+        repo: "repo",
+        cloneUrl: "git@gitlab.com:owner/repo.git",
+      });
+    });
+  });
+
+  describe("Bitbucket URLs", () => {
+    test("parses basic Bitbucket URL", () => {
+      const result = parseGitUrl("https://bitbucket.org/owner/repo");
+      expect(result).toEqual({
+        host: "bitbucket.org",
+        owner: "owner",
+        repo: "repo",
+        cloneUrl: "https://bitbucket.org/owner/repo.git",
+      });
+    });
+
+    test("parses Bitbucket URL with subdirectory", () => {
+      const result = parseGitUrl("https://bitbucket.org/owner/repo/src/main/skills/my-skill");
+      expect(result).toEqual({
+        host: "bitbucket.org",
+        owner: "owner",
+        repo: "repo",
+        branch: "main",
+        subdir: "skills/my-skill",
+        cloneUrl: "https://bitbucket.org/owner/repo.git",
+      });
+    });
+  });
+
+  describe("Generic Git URLs", () => {
+    test("parses self-hosted HTTPS URL", () => {
+      const result = parseGitUrl("https://git.company.com/owner/repo.git");
+      expect(result).toEqual({
+        host: "git.company.com",
+        owner: "owner",
+        repo: "repo",
+        cloneUrl: "https://git.company.com/owner/repo.git",
+      });
+    });
+
+    test("parses generic SSH URL", () => {
+      const result = parseGitUrl("git@git.company.com:owner/repo.git");
+      expect(result).toEqual({
+        host: "git.company.com",
+        owner: "owner",
+        repo: "repo",
+        cloneUrl: "git@git.company.com:owner/repo.git",
+      });
+    });
+  });
+
+  describe("Invalid URLs", () => {
+    test("returns null for invalid URL", () => {
+      expect(parseGitUrl("not-a-url")).toBeNull();
+      expect(parseGitUrl("")).toBeNull();
+      expect(parseGitUrl("ftp://example.com")).toBeNull();
+    });
+  });
+});
+
+describe("getRemoteNamespace", () => {
+  test("returns owner/repo for basic URL", () => {
+    const parsed = parseGitUrl("https://github.com/owner/repo")!;
+    expect(getRemoteNamespace(parsed)).toBe("owner/repo");
+  });
+
+  test("returns owner/skill-name for subdirectory URL", () => {
+    const parsed = parseGitUrl("https://github.com/owner/repo/tree/main/skills/my-skill")!;
+    expect(getRemoteNamespace(parsed)).toBe("owner/my-skill");
+  });
+
+  test("handles nested subdirectories", () => {
+    const parsed = parseGitUrl("https://github.com/owner/repo/tree/main/path/to/deep/skill")!;
+    expect(getRemoteNamespace(parsed)).toBe("owner/skill");
+  });
+});
+
+describe("getLocalNamespace", () => {
+  test("extracts folder name from path", () => {
+    expect(getLocalNamespace("/home/user/my-skills")).toBe("local/my-skills");
+    expect(getLocalNamespace("C:\\Users\\Admin\\skills")).toBe("local/skills");
+    expect(getLocalNamespace("./relative-path")).toBe("local/relative-path");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}