@vikasitai/vikasit-code 2.0.7 → 2.0.8

package/test/share/share-next.test.ts

@@ -1,76 +0,0 @@
-import { test, expect, mock } from "bun:test"
-import { ShareNext } from "../../src/share/share-next"
-import { AccessToken, Account, AccountID, OrgID } from "../../src/account"
-import { Config } from "../../src/config/config"
-
-test("ShareNext.request uses legacy share API without active org account", async () => {
-  const originalActive = Account.active
-  const originalConfigGet = Config.get
-
-  Account.active = mock(async () => undefined)
-  Config.get = mock(async () => ({ enterprise: { url: "https://legacy-share.example.com" } }))
-
-  try {
-    const req = await ShareNext.request()
-
-    expect(req.api.create).toBe("/api/share")
-    expect(req.api.sync("shr_123")).toBe("/api/share/shr_123/sync")
-    expect(req.api.remove("shr_123")).toBe("/api/share/shr_123")
-    expect(req.api.data("shr_123")).toBe("/api/share/shr_123/data")
-    expect(req.baseUrl).toBe("https://legacy-share.example.com")
-    expect(req.headers).toEqual({})
-  } finally {
-    Account.active = originalActive
-    Config.get = originalConfigGet
-  }
-})
-
-test("ShareNext.request uses org share API with auth headers when account is active", async () => {
-  const originalActive = Account.active
-  const originalToken = Account.token
-
-  Account.active = mock(async () => ({
-    id: AccountID.make("account-1"),
-    email: "user@example.com",
-    url: "https://control.example.com",
-    active_org_id: OrgID.make("org-1"),
-  }))
-  Account.token = mock(async () => AccessToken.make("st_test_token"))
-
-  try {
-    const req = await ShareNext.request()
-
-    expect(req.api.create).toBe("/api/shares")
-    expect(req.api.sync("shr_123")).toBe("/api/shares/shr_123/sync")
-    expect(req.api.remove("shr_123")).toBe("/api/shares/shr_123")
-    expect(req.api.data("shr_123")).toBe("/api/shares/shr_123/data")
-    expect(req.baseUrl).toBe("https://control.example.com")
-    expect(req.headers).toEqual({
-      authorization: "Bearer st_test_token",
-      "x-org-id": "org-1",
-    })
-  } finally {
-    Account.active = originalActive
-    Account.token = originalToken
-  }
-})
-
-test("ShareNext.request fails when org account has no token", async () => {
-  const originalActive = Account.active
-  const originalToken = Account.token
-
-  Account.active = mock(async () => ({
-    id: AccountID.make("account-1"),
-    email: "user@example.com",
-    url: "https://control.example.com",
-    active_org_id: OrgID.make("org-1"),
-  }))
-  Account.token = mock(async () => undefined)
-
-  try {
-    await expect(ShareNext.request()).rejects.toThrow("No active account token available for sharing")
-  } finally {
-    Account.active = originalActive
-    Account.token = originalToken
-  }
-})

package/test/shell/shell.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { Shell } from "../../src/shell/shell"
-import { Filesystem } from "../../src/util/filesystem"
-
-const withShell = async (shell: string | undefined, fn: () => void | Promise<void>) => {
-  const prev = process.env.SHELL
-  if (shell === undefined) delete process.env.SHELL
-  else process.env.SHELL = shell
-  Shell.acceptable.reset()
-  Shell.preferred.reset()
-  try {
-    await fn()
-  } finally {
-    if (prev === undefined) delete process.env.SHELL
-    else process.env.SHELL = prev
-    Shell.acceptable.reset()
-    Shell.preferred.reset()
-  }
-}
-
-describe("shell", () => {
-  test("normalizes shell names", () => {
-    expect(Shell.name("/bin/bash")).toBe("bash")
-    if (process.platform === "win32") {
-      expect(Shell.name("C:/tools/NU.EXE")).toBe("nu")
-      expect(Shell.name("C:/tools/PWSH.EXE")).toBe("pwsh")
-    }
-  })
-
-  test("detects login shells", () => {
-    expect(Shell.login("/bin/bash")).toBe(true)
-    expect(Shell.login("C:/tools/pwsh.exe")).toBe(false)
-  })
-
-  test("detects posix shells", () => {
-    expect(Shell.posix("/bin/bash")).toBe(true)
-    expect(Shell.posix("/bin/fish")).toBe(false)
-    expect(Shell.posix("C:/tools/pwsh.exe")).toBe(false)
-  })
-
-  if (process.platform === "win32") {
-    test("rejects blacklisted shells case-insensitively", async () => {
-      await withShell("NU.EXE", async () => {
-        expect(Shell.name(Shell.acceptable())).not.toBe("nu")
-      })
-    })
-
-    test("normalizes Git Bash shell paths from env", async () => {
-      const shell = "/cygdrive/c/Program Files/Git/bin/bash.exe"
-      await withShell(shell, async () => {
-        expect(Shell.preferred()).toBe(Filesystem.windowsPath(shell))
-      })
-    })
-
-    test("resolves /usr/bin/bash from env to Git Bash", async () => {
-      const bash = Shell.gitbash()
-      if (!bash) return
-      await withShell("/usr/bin/bash", async () => {
-        expect(Shell.acceptable()).toBe(bash)
-        expect(Shell.preferred()).toBe(bash)
-      })
-    })
-
-    test("resolves bare PowerShell shells", async () => {
-      const shell = Bun.which("pwsh") || Bun.which("powershell")
-      if (!shell) return
-      await withShell(path.win32.basename(shell), async () => {
-        expect(Shell.preferred()).toBe(shell)
-      })
-    })
-  }
-})

package/test/skill/discovery.test.ts

@@ -1,116 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test"
-import { Effect } from "effect"
-import { Discovery } from "../../src/skill/discovery"
-import { Global } from "../../src/global"
-import { Filesystem } from "../../src/util/filesystem"
-import { rm } from "fs/promises"
-import path from "path"
-
-let CLOUDFLARE_SKILLS_URL: string
-let server: ReturnType<typeof Bun.serve>
-let downloadCount = 0
-
-const fixturePath = path.join(import.meta.dir, "../fixture/skills")
-const cacheDir = path.join(Global.Path.cache, "skills")
-
-beforeAll(async () => {
-  await rm(cacheDir, { recursive: true, force: true })
-
-  server = Bun.serve({
-    port: 0,
-    async fetch(req) {
-      const url = new URL(req.url)
-
-      // route /.well-known/skills/* to the fixture directory
-      if (url.pathname.startsWith("/.well-known/skills/")) {
-        const filePath = url.pathname.replace("/.well-known/skills/", "")
-        const fullPath = path.join(fixturePath, filePath)
-
-        if (await Filesystem.exists(fullPath)) {
-          if (!fullPath.endsWith("index.json")) {
-            downloadCount++
-          }
-          return new Response(Bun.file(fullPath))
-        }
-      }
-
-      return new Response("Not Found", { status: 404 })
-    },
-  })
-
-  CLOUDFLARE_SKILLS_URL = `http://localhost:${server.port}/.well-known/skills/`
-})
-
-afterAll(async () => {
-  server?.stop()
-  await rm(cacheDir, { recursive: true, force: true })
-})
-
-describe("Discovery.pull", () => {
-  const pull = (url: string) =>
-    Effect.runPromise(Discovery.Service.use((s) => s.pull(url)).pipe(Effect.provide(Discovery.defaultLayer)))
-
-  test("downloads skills from cloudflare url", async () => {
-    const dirs = await pull(CLOUDFLARE_SKILLS_URL)
-    expect(dirs.length).toBeGreaterThan(0)
-    for (const dir of dirs) {
-      expect(dir).toStartWith(cacheDir)
-      const md = path.join(dir, "SKILL.md")
-      expect(await Filesystem.exists(md)).toBe(true)
-    }
-  })
-
-  test("url without trailing slash works", async () => {
-    const dirs = await pull(CLOUDFLARE_SKILLS_URL.replace(/\/$/, ""))
-    expect(dirs.length).toBeGreaterThan(0)
-    for (const dir of dirs) {
-      const md = path.join(dir, "SKILL.md")
-      expect(await Filesystem.exists(md)).toBe(true)
-    }
-  })
-
-  test("returns empty array for invalid url", async () => {
-    const dirs = await pull(`http://localhost:${server.port}/invalid-url/`)
-    expect(dirs).toEqual([])
-  })
-
-  test("returns empty array for non-json response", async () => {
-    // any url not explicitly handled in server returns 404 text "Not Found"
-    const dirs = await pull(`http://localhost:${server.port}/some-other-path/`)
-    expect(dirs).toEqual([])
-  })
-
-  test("downloads reference files alongside SKILL.md", async () => {
-    const dirs = await pull(CLOUDFLARE_SKILLS_URL)
-    // find a skill dir that should have reference files (e.g. agents-sdk)
-    const agentsSdk = dirs.find((d) => d.endsWith(path.sep + "agents-sdk"))
-    expect(agentsSdk).toBeDefined()
-    if (agentsSdk) {
-      const refs = path.join(agentsSdk, "references")
-      expect(await Filesystem.exists(path.join(agentsSdk, "SKILL.md"))).toBe(true)
-      // agents-sdk has reference files per the index
-      const refDir = await Array.fromAsync(new Bun.Glob("**/*.md").scan({ cwd: refs, onlyFiles: true }))
-      expect(refDir.length).toBeGreaterThan(0)
-    }
-  })
-
-  test("caches downloaded files on second pull", async () => {
-    // clear dir and downloadCount
-    await rm(cacheDir, { recursive: true, force: true })
-    downloadCount = 0
-
-    // first pull to populate cache
-    const first = await pull(CLOUDFLARE_SKILLS_URL)
-    expect(first.length).toBeGreaterThan(0)
-    const firstCount = downloadCount
-    expect(firstCount).toBeGreaterThan(0)
-
-    // second pull should return same results from cache
-    const second = await pull(CLOUDFLARE_SKILLS_URL)
-    expect(second.length).toBe(first.length)
-    expect(second.sort()).toEqual(first.sort())
-
-    // second pull should NOT increment download count
-    expect(downloadCount).toBe(firstCount)
-  })
-})

package/test/skill/skill.test.ts

@@ -1,392 +0,0 @@
-import { afterEach, test, expect } from "bun:test"
-import { Skill } from "../../src/skill"
-import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
-import path from "path"
-import fs from "fs/promises"
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-async function createGlobalSkill(homeDir: string) {
-  const skillDir = path.join(homeDir, ".claude", "skills", "global-test-skill")
-  await fs.mkdir(skillDir, { recursive: true })
-  await Bun.write(
-    path.join(skillDir, "SKILL.md"),
-    `---
-name: global-test-skill
-description: A global skill from ~/.claude/skills for testing.
----
-
-# Global Test Skill
-
-This skill is loaded from the global home directory.
-`,
-  )
-}
-
-test("discovers skills from .vikasit/skill/ directory", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".vikasit", "skill", "test-skill")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `---
-name: test-skill
-description: A test skill for verification.
----
-
-# Test Skill
-
-Instructions here.
-`,
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(1)
-      const testSkill = skills.find((s) => s.name === "test-skill")
-      expect(testSkill).toBeDefined()
-      expect(testSkill!.description).toBe("A test skill for verification.")
-      expect(testSkill!.location).toContain(path.join("skill", "test-skill", "SKILL.md"))
-    },
-  })
-})
-
-test("returns skill directories from Skill.dirs", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".vikasit", "skill", "dir-skill")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `---
-name: dir-skill
-description: Skill for dirs test.
----
-
-# Dir Skill
-`,
-      )
-    },
-  })
-
-  const home = process.env.VIKASIT_TEST_HOME
-  process.env.VIKASIT_TEST_HOME = tmp.path
-
-  try {
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const dirs = await Skill.dirs()
-        const skillDir = path.join(tmp.path, ".vikasit", "skill", "dir-skill")
-        expect(dirs).toContain(skillDir)
-        expect(dirs.length).toBe(1)
-      },
-    })
-  } finally {
-    process.env.VIKASIT_TEST_HOME = home
-  }
-})
-
-test("discovers multiple skills from .vikasit/skill/ directory", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir1 = path.join(dir, ".vikasit", "skill", "skill-one")
-      const skillDir2 = path.join(dir, ".vikasit", "skill", "skill-two")
-      await Bun.write(
-        path.join(skillDir1, "SKILL.md"),
-        `---
-name: skill-one
-description: First test skill.
----
-
-# Skill One
-`,
-      )
-      await Bun.write(
-        path.join(skillDir2, "SKILL.md"),
-        `---
-name: skill-two
-description: Second test skill.
----
-
-# Skill Two
-`,
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(2)
-      expect(skills.find((s) => s.name === "skill-one")).toBeDefined()
-      expect(skills.find((s) => s.name === "skill-two")).toBeDefined()
-    },
-  })
-})
-
-test("skips skills with missing frontmatter", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".vikasit", "skill", "no-frontmatter")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `# No Frontmatter
-
-Just some content without YAML frontmatter.
-`,
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills).toEqual([])
-    },
-  })
-})
-
-test("discovers skills from .claude/skills/ directory", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".claude", "skills", "claude-skill")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `---
-name: claude-skill
-description: A skill in the .claude/skills directory.
----
-
-# Claude Skill
-`,
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(1)
-      const claudeSkill = skills.find((s) => s.name === "claude-skill")
-      expect(claudeSkill).toBeDefined()
-      expect(claudeSkill!.location).toContain(path.join(".claude", "skills", "claude-skill", "SKILL.md"))
-    },
-  })
-})
-
-test("discovers global skills from ~/.claude/skills/ directory", async () => {
-  await using tmp = await tmpdir({ git: true })
-
-  const originalHome = process.env.VIKASIT_TEST_HOME
-  process.env.VIKASIT_TEST_HOME = tmp.path
-
-  try {
-    await createGlobalSkill(tmp.path)
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const skills = await Skill.all()
-        expect(skills.length).toBe(1)
-        expect(skills[0].name).toBe("global-test-skill")
-        expect(skills[0].description).toBe("A global skill from ~/.claude/skills for testing.")
-        expect(skills[0].location).toContain(path.join(".claude", "skills", "global-test-skill", "SKILL.md"))
-      },
-    })
-  } finally {
-    process.env.VIKASIT_TEST_HOME = originalHome
-  }
-})
-
-test("returns empty array when no skills exist", async () => {
-  await using tmp = await tmpdir({ git: true })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills).toEqual([])
-    },
-  })
-})
-
-test("discovers skills from .agents/skills/ directory", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".agents", "skills", "agent-skill")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `---
-name: agent-skill
-description: A skill in the .agents/skills directory.
----
-
-# Agent Skill
-`,
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(1)
-      const agentSkill = skills.find((s) => s.name === "agent-skill")
-      expect(agentSkill).toBeDefined()
-      expect(agentSkill!.location).toContain(path.join(".agents", "skills", "agent-skill", "SKILL.md"))
-    },
-  })
-})
-
-test("discovers global skills from ~/.agents/skills/ directory", async () => {
-  await using tmp = await tmpdir({ git: true })
-
-  const originalHome = process.env.VIKASIT_TEST_HOME
-  process.env.VIKASIT_TEST_HOME = tmp.path
-
-  try {
-    const skillDir = path.join(tmp.path, ".agents", "skills", "global-agent-skill")
-    await fs.mkdir(skillDir, { recursive: true })
-    await Bun.write(
-      path.join(skillDir, "SKILL.md"),
-      `---
-name: global-agent-skill
-description: A global skill from ~/.agents/skills for testing.
----
-
-# Global Agent Skill
-
-This skill is loaded from the global home directory.
-`,
-    )
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const skills = await Skill.all()
-        expect(skills.length).toBe(1)
-        expect(skills[0].name).toBe("global-agent-skill")
-        expect(skills[0].description).toBe("A global skill from ~/.agents/skills for testing.")
-        expect(skills[0].location).toContain(path.join(".agents", "skills", "global-agent-skill", "SKILL.md"))
-      },
-    })
-  } finally {
-    process.env.VIKASIT_TEST_HOME = originalHome
-  }
-})
-
-test("discovers skills from both .claude/skills/ and .agents/skills/", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const claudeDir = path.join(dir, ".claude", "skills", "claude-skill")
-      const agentDir = path.join(dir, ".agents", "skills", "agent-skill")
-      await Bun.write(
-        path.join(claudeDir, "SKILL.md"),
-        `---
-name: claude-skill
-description: A skill in the .claude/skills directory.
----
-
-# Claude Skill
-`,
-      )
-      await Bun.write(
-        path.join(agentDir, "SKILL.md"),
-        `---
-name: agent-skill
-description: A skill in the .agents/skills directory.
----
-
-# Agent Skill
-`,
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(2)
-      expect(skills.find((s) => s.name === "claude-skill")).toBeDefined()
-      expect(skills.find((s) => s.name === "agent-skill")).toBeDefined()
-    },
-  })
-})
-
-test("properly resolves directories that skills live in", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const opencodeSkillDir = path.join(dir, ".vikasit", "skill", "agent-skill")
-      const opencodeSkillsDir = path.join(dir, ".vikasit", "skills", "agent-skill")
-      const claudeDir = path.join(dir, ".claude", "skills", "claude-skill")
-      const agentDir = path.join(dir, ".agents", "skills", "agent-skill")
-      await Bun.write(
-        path.join(claudeDir, "SKILL.md"),
-        `---
-name: claude-skill
-description: A skill in the .claude/skills directory.
----
-
-# Claude Skill
-`,
-      )
-      await Bun.write(
-        path.join(agentDir, "SKILL.md"),
-        `---
-name: agent-skill
-description: A skill in the .agents/skills directory.
----
-
-# Agent Skill
-`,
-      )
-      await Bun.write(
-        path.join(opencodeSkillDir, "SKILL.md"),
-        `---
-name: opencode-skill
-description: A skill in the .vikasit/skill directory.
----
-
-# Vikasit Code Skill
-`,
-      )
-      await Bun.write(
-        path.join(opencodeSkillsDir, "SKILL.md"),
-        `---
-name: opencode-skill
-description: A skill in the .vikasit/skills directory.
----
-
-# Vikasit Code Skill
-`,
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const dirs = await Skill.dirs()
-      expect(dirs.length).toBe(4)
-    },
-  })
-})