nikcli 0.0.6

package/src/skill/skill.ts

@@ -0,0 +1,232 @@
+import z from "zod"
+import path from "path"
+import { createHash } from "crypto"
+import { Config } from "../config/config"
+import { Instance } from "../project/instance"
+import { NamedError } from "@nikcli-ai/util/error"
+import { ConfigMarkdown } from "../config/markdown"
+import { Log } from "../util/log"
+import { Global } from "@/global"
+import { Filesystem } from "@/util/filesystem"
+import { Flag } from "@/flag/flag"
+import { Bus } from "@/bus"
+import { Session } from "@/session"
+
+export namespace Skill {
+  const log = Log.create({ service: "skill" })
+  const COMMAND_PREFIX = "skill:"
+
+  export const Info = z.object({
+    name: z.string(),
+    description: z.string(),
+    location: z.string(),
+    category: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    version: z.string().optional(),
+  })
+  const Metadata = Info.omit({
+    location: true,
+  })
+  export type Info = z.infer<typeof Info>
+  export type Loaded = Info & {
+    dir: string
+    content: string
+  }
+
+  export const InvalidError = NamedError.create(
+    "SkillInvalidError",
+    z.object({
+      path: z.string(),
+      message: z.string().optional(),
+      issues: z.custom<z.core.$ZodIssue[]>().optional(),
+    }),
+  )
+
+  export const NameMismatchError = NamedError.create(
+    "SkillNameMismatchError",
+    z.object({
+      path: z.string(),
+      expected: z.string(),
+      actual: z.string(),
+    }),
+  )
+
+  // External skill directories to search for (project-level and global)
+  // These follow the directory layout used by Claude Code and other agents.
+  const EXTERNAL_DIRS = [".claude", ".agents"]
+  const EXTERNAL_SKILL_GLOB = new Bun.Glob("skills/**/SKILL.md")
+
+  const NIKCLI_SKILL_GLOB = new Bun.Glob("{skill,skills}/**/SKILL.md")
+  const CLAUDE_SKILL_GLOB = new Bun.Glob("skills/**/SKILL.md")
+  const SKILL_GLOB = new Bun.Glob("**/SKILL.md")
+
+  function normalizeName(input: string) {
+    return input.toLowerCase().replace(/[^a-z0-9]+/g, "")
+  }
+
+  function slug(input: string) {
+    return input
+      .toLowerCase()
+      .trim()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+  }
+
+  export function commandName(name: string) {
+    const suffix = slug(name) || "skill"
+    const hash = createHash("sha1").update(name).digest("hex").slice(0, 6)
+    return `${COMMAND_PREFIX}${suffix}-${hash}`
+  }
+
+  export function isCommandName(name: string) {
+    return name.startsWith(COMMAND_PREFIX)
+  }
+
+  export const state = Instance.state(async () => {
+    const skills: Record<string, Info> = {}
+
+    const addSkill = async (match: string) => {
+      const md = await ConfigMarkdown.parse(match).catch((err) => {
+        const message = ConfigMarkdown.FrontmatterError.isInstance(err)
+          ? err.data.message
+          : `Failed to parse skill ${match}`
+        Bus.publish(Session.Event.Error, { error: new NamedError.Unknown({ message }).toObject() })
+        log.error("failed to load skill", { skill: match, err })
+        return undefined
+      })
+
+      if (!md) return
+
+      const parsed = Metadata.safeParse(md.data)
+      if (!parsed.success) return
+
+      if (skills[parsed.data.name]) {
+        log.warn("duplicate skill name", {
+          name: parsed.data.name,
+          existing: skills[parsed.data.name].location,
+          duplicate: match,
+        })
+      }
+
+      skills[parsed.data.name] = {
+        name: parsed.data.name,
+        description: parsed.data.description,
+        location: match,
+        category: parsed.data.category,
+        tags: parsed.data.tags,
+        version: parsed.data.version,
+      }
+    }
+
+    const scanExternal = async (root: string, scope: "global" | "project") => {
+      return Array.fromAsync(
+        EXTERNAL_SKILL_GLOB.scan({
+          cwd: root,
+          absolute: true,
+          onlyFiles: true,
+          followSymlinks: true,
+          dot: true,
+        }),
+      )
+        .then((matches) => Promise.all(matches.map(addSkill)))
+        .catch((error) => {
+          log.error(`failed to scan ${scope} skills`, { dir: root, error })
+        })
+    }
+
+    // Scan external skill directories (.claude/skills/, .agents/skills/, etc.)
+    // Load global (home) first, then project-level (so project-level overwrites)
+    if (!Flag.NIKCLI_DISABLE_EXTERNAL_SKILLS) {
+      for (const dir of EXTERNAL_DIRS) {
+        const root = path.join(Global.Path.home, dir)
+        if (!(await Filesystem.isDir(root))) continue
+        await scanExternal(root, "global")
+      }
+
+      for await (const root of Filesystem.up({
+        targets: EXTERNAL_DIRS,
+        start: Instance.directory,
+        stop: Instance.worktree,
+      })) {
+        await scanExternal(root, "project")
+      }
+    }
+
+    for (const dir of await Config.directories()) {
+      for await (const match of NIKCLI_SKILL_GLOB.scan({
+        cwd: dir,
+        absolute: true,
+        onlyFiles: true,
+        followSymlinks: true,
+      })) {
+        await addSkill(match)
+      }
+    }
+
+    return skills
+  })
+
+  export async function get(name: string) {
+    return state().then((x) => x[name])
+  }
+
+  export async function all() {
+    return state().then((x) => Object.values(x))
+  }
+
+  export async function resolve(name: string, candidates?: Info[]) {
+    const query = name.trim()
+    if (!query) return { skill: undefined, suggestions: [] as string[] }
+
+    const list = candidates ?? (await all())
+    const lower = query.toLowerCase()
+    const normalized = normalizeName(query)
+
+    const exact =
+      list.find((skill) => skill.name === query) ??
+      list.find((skill) => skill.name.toLowerCase() === lower) ??
+      (() => {
+        const matches = list.filter((skill) => normalizeName(skill.name) === normalized)
+        return matches.length === 1 ? matches[0] : undefined
+      })()
+
+    if (exact) {
+      return { skill: exact, suggestions: [exact.name] }
+    }
+
+    const partial = list.filter((skill) => {
+      const skillName = skill.name.toLowerCase()
+      const normalizedName = normalizeName(skill.name)
+      return skillName.includes(lower) || normalizedName.includes(normalized)
+    })
+
+    if (partial.length === 1) {
+      return { skill: partial[0], suggestions: partial.map((skill) => skill.name) }
+    }
+
+    const related = partial.length
+      ? partial
+      : list.filter((skill) =>
+          [skill.description, skill.category ?? "", ...(skill.tags ?? [])].some((value) =>
+            value.toLowerCase().includes(lower),
+          ),
+        )
+
+    return {
+      skill: undefined,
+      suggestions: related.slice(0, 5).map((skill) => skill.name),
+    }
+  }
+
+  export async function load(name: string): Promise<Loaded | undefined> {
+    const skill = await get(name)
+    if (!skill) return
+
+    const parsed = await ConfigMarkdown.parse(skill.location)
+    return {
+      ...skill,
+      dir: path.dirname(skill.location),
+      content: parsed.content.trim(),
+    }
+  }
+}

package/src/snapshot/index.ts

@@ -0,0 +1,297 @@
+import { $ } from "bun"
+import path from "path"
+import fs from "fs/promises"
+import { Log } from "../util/log"
+import { Global } from "../global"
+import z from "zod"
+import { Config } from "../config/config"
+import { Instance } from "../project/instance"
+import { Scheduler } from "../scheduler"
+
+export namespace Snapshot {
+  const log = Log.create({ service: "snapshot" })
+  const hour = 60 * 60 * 1000
+  const prune = "7.days"
+
+  export function init() {
+    Scheduler.register({
+      id: "snapshot.cleanup",
+      interval: hour,
+      run: cleanup,
+      scope: "instance",
+    })
+  }
+
+  export async function cleanup() {
+    if (Instance.project.vcs !== "git") return
+    const cfg = await Config.get()
+    if (cfg.snapshot === false) return
+    const git = gitdir()
+    const exists = await fs
+      .stat(git)
+      .then(() => true)
+      .catch(() => false)
+    if (!exists) return
+    const result = await $`git --git-dir ${git} --work-tree ${Instance.worktree} gc --prune=${prune}`
+      .quiet()
+      .cwd(Instance.directory)
+      .nothrow()
+    if (result.exitCode !== 0) {
+      log.warn("cleanup failed", {
+        exitCode: result.exitCode,
+        stderr: result.stderr.toString(),
+        stdout: result.stdout.toString(),
+      })
+      return
+    }
+    log.info("cleanup", { prune })
+  }
+
+  export async function track() {
+    if (Instance.project.vcs !== "git") return
+    const cfg = await Config.get()
+    if (cfg.snapshot === false) return
+    const git = gitdir()
+    if (await fs.mkdir(git, { recursive: true })) {
+      await $`git init`
+        .env({
+          ...process.env,
+          GIT_DIR: git,
+          GIT_WORK_TREE: Instance.worktree,
+        })
+        .quiet()
+        .nothrow()
+      await $`git --git-dir ${git} config core.autocrlf false`.quiet().nothrow()
+      log.info("initialized")
+    }
+    await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`.quiet().cwd(Instance.directory).nothrow()
+    const hash = await $`git --git-dir ${git} --work-tree ${Instance.worktree} write-tree`
+      .quiet()
+      .cwd(Instance.directory)
+      .nothrow()
+      .text()
+    log.info("tracking", { hash, cwd: Instance.directory, git })
+    return hash.trim()
+  }
+
+  export const Patch = z.object({
+    hash: z.string(),
+    files: z.string().array(),
+  })
+  export type Patch = z.infer<typeof Patch>
+
+  export async function patch(hash: string): Promise<Patch> {
+    const git = gitdir()
+    await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`.quiet().cwd(Instance.directory).nothrow()
+    const result =
+      await $`git -c core.autocrlf=false --git-dir ${git} --work-tree ${Instance.worktree} diff --no-ext-diff --name-only ${hash} -- .`
+        .quiet()
+        .cwd(Instance.directory)
+        .nothrow()
+
+    if (result.exitCode !== 0) {
+      log.warn("failed to get diff", { hash, exitCode: result.exitCode })
+      return { hash, files: [] }
+    }
+
+    const files = result.text()
+    return {
+      hash,
+      files: files
+        .trim()
+        .split("\n")
+        .map((x) => x.trim())
+        .filter(Boolean)
+        .map((x) => unquote(x))
+        .map((x) => path.join(Instance.worktree, x)),
+    }
+  }
+
+  export async function restore(snapshot: string) {
+    log.info("restore", { commit: snapshot })
+    const git = gitdir()
+    const result =
+      await $`git --git-dir ${git} --work-tree ${Instance.worktree} read-tree ${snapshot} && git --git-dir ${git} --work-tree ${Instance.worktree} checkout-index -a -f`
+        .quiet()
+        .cwd(Instance.worktree)
+        .nothrow()
+
+    if (result.exitCode !== 0) {
+      log.error("failed to restore snapshot", {
+        snapshot,
+        exitCode: result.exitCode,
+        stderr: result.stderr.toString(),
+        stdout: result.stdout.toString(),
+      })
+    }
+  }
+
+  export async function revert(patches: Patch[]) {
+    const files = new Set<string>()
+    const git = gitdir()
+    for (const item of patches) {
+      for (const file of item.files) {
+        if (files.has(file)) continue
+        log.info("reverting", { file, hash: item.hash })
+        const result = await $`git --git-dir ${git} --work-tree ${Instance.worktree} checkout ${item.hash} -- ${file}`
+          .quiet()
+          .cwd(Instance.worktree)
+          .nothrow()
+        if (result.exitCode !== 0) {
+          const relativePath = path.relative(Instance.worktree, file)
+          const checkTree =
+            await $`git --git-dir ${git} --work-tree ${Instance.worktree} ls-tree ${item.hash} -- ${relativePath}`
+              .quiet()
+              .cwd(Instance.worktree)
+              .nothrow()
+          if (checkTree.exitCode === 0 && checkTree.text().trim()) {
+            log.info("file existed in snapshot but checkout failed, keeping", {
+              file,
+            })
+          } else {
+            log.info("file did not exist in snapshot, deleting", { file })
+            await fs.unlink(file).catch(() => {})
+          }
+        }
+        files.add(file)
+      }
+    }
+  }
+
+  export async function diff(hash: string) {
+    const git = gitdir()
+    await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`.quiet().cwd(Instance.directory).nothrow()
+    const result =
+      await $`git -c core.autocrlf=false --git-dir ${git} --work-tree ${Instance.worktree} diff --no-ext-diff ${hash} -- .`
+        .quiet()
+        .cwd(Instance.worktree)
+        .nothrow()
+
+    if (result.exitCode !== 0) {
+      log.warn("failed to get diff", {
+        hash,
+        exitCode: result.exitCode,
+        stderr: result.stderr.toString(),
+        stdout: result.stdout.toString(),
+      })
+      return ""
+    }
+
+    return result.text().trim()
+  }
+
+  export const FileDiff = z
+    .object({
+      file: z.string(),
+      before: z.string(),
+      after: z.string(),
+      additions: z.number(),
+      deletions: z.number(),
+    })
+    .meta({
+      ref: "FileDiff",
+    })
+  export type FileDiff = z.infer<typeof FileDiff>
+  export async function diffFull(from: string, to: string): Promise<FileDiff[]> {
+    const git = gitdir()
+    const result: FileDiff[] = []
+
+    const show = async (hash: string, file: string) => {
+      const response =
+        await $`git -c core.autocrlf=false --git-dir ${git} --work-tree ${Instance.worktree} show ${hash}:${file}`
+          .quiet()
+          .nothrow()
+      if (response.exitCode === 0) return response.text()
+      const stderr = response.stderr.toString()
+      if (stderr.toLowerCase().includes("does not exist in")) return ""
+      return `[DEBUG ERROR] git show ${hash}:${file} failed: ${stderr}`
+    }
+
+    for await (const line of $`git -c core.autocrlf=false --git-dir ${git} --work-tree ${Instance.worktree} diff --no-ext-diff --no-renames --numstat ${from} ${to} -- .`
+      .quiet()
+      .cwd(Instance.directory)
+      .nothrow()
+      .lines()) {
+      if (!line) continue
+      const [additions, deletions, rawFile] = line.split("\t")
+      const file = unquote(rawFile)
+      const isBinaryFile = additions === "-" && deletions === "-"
+
+      const before = isBinaryFile ? "" : await show(from, file)
+      const after = isBinaryFile ? "" : await show(to, file)
+      const added = isBinaryFile ? 0 : parseInt(additions)
+      const deleted = isBinaryFile ? 0 : parseInt(deletions)
+      result.push({
+        file,
+        before,
+        after,
+        additions: Number.isFinite(added) ? added : 0,
+        deletions: Number.isFinite(deleted) ? deleted : 0,
+      })
+    }
+    return result
+  }
+
+  export function unquote(path: string): string {
+    if (path.startsWith('"') && path.endsWith('"')) {
+      const quoted = path.slice(1, -1)
+      const buffer: number[] = []
+      for (let i = 0; i < quoted.length; i++) {
+        if (quoted[i] === "\\") {
+          i++
+          if (i + 2 < quoted.length && /^[0-7]{3}$/.test(quoted.slice(i, i + 3))) {
+            const octal = quoted.slice(i, i + 3)
+            buffer.push(parseInt(octal, 8))
+            i += 2
+          } else {
+            switch (quoted[i]) {
+              case "b":
+                buffer.push(8)
+                break
+              case "t":
+                buffer.push(9)
+                break
+              case "n":
+                buffer.push(10)
+                break
+              case "v":
+                buffer.push(11)
+                break
+              case "f":
+                buffer.push(12)
+                break
+              case "r":
+                buffer.push(13)
+                break
+              case '"':
+                buffer.push(34)
+                break
+              case "\\":
+                buffer.push(92)
+                break
+              default:
+                buffer.push(quoted.charCodeAt(i))
+            }
+          }
+        } else {
+          const charCode = quoted.charCodeAt(i)
+          if (charCode < 128) {
+            buffer.push(charCode)
+          } else {
+            const charBuffer = Buffer.from(quoted[i])
+            for (const byte of charBuffer) {
+              buffer.push(byte)
+            }
+          }
+        }
+      }
+      return Buffer.from(buffer).toString("utf8")
+    }
+    return path
+  }
+
+  function gitdir() {
+    const project = Instance.project
+    return path.join(Global.Path.data, "snapshot", project.id)
+  }
+}