glab-agent 0.1.0

package/src/local-agent/skill-import.ts

@@ -0,0 +1,344 @@
+import { execFile } from "node:child_process";
+import { mkdir, writeFile, readFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { parse as parseYaml } from "yaml";
+import { parseSkillMd } from "./skill-parse.js";
+
+const execFileAsync = promisify(execFile);
+
+export interface ImportResult {
+  status: "imported" | "updated" | "unchanged" | "failed";
+  name: string;
+  message: string;
+}
+
+interface ParsedGitHubUrl {
+  owner: string;
+  repo: string;
+  path?: string;
+  ref?: string;
+}
+
+/**
+ * Parse a GitHub URL to extract owner/repo and optional path.
+ * Supports:
+ *   https://github.com/owner/repo
+ *   https://github.com/owner/repo/tree/main/skills/my-skill.yaml
+ *   owner/repo (shorthand)
+ *   owner/repo/skills/my-skill.yaml (shorthand with path)
+ */
+export function parseGitHubUrl(input: string): ParsedGitHubUrl | null {
+  if (!input || typeof input !== "string") return null;
+
+  const trimmed = input.trim();
+
+  // Full HTTPS URL: https://github.com/owner/repo[/tree/ref/path...]
+  const httpsMatch = trimmed.match(
+    /^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/([^/]+)(?:\/(.+))?)?$/
+  );
+  if (httpsMatch) {
+    const [, owner, repo, ref, filePath] = httpsMatch;
+    return {
+      owner,
+      repo,
+      ref: ref || undefined,
+      path: filePath || undefined
+    };
+  }
+
+  // Shorthand: owner/repo[/path...]
+  // Must have exactly "owner/repo" or "owner/repo/path..."
+  const shortMatch = trimmed.match(/^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)(?:\/(.+))?$/);
+  if (shortMatch) {
+    const [, owner, repo, filePath] = shortMatch;
+    return {
+      owner,
+      repo,
+      path: filePath || undefined
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Fetch a single file from GitHub using the raw content URL.
+ * Uses `curl` command (zero npm dependencies, system tool).
+ */
+export async function fetchGitHubFile(
+  owner: string,
+  repo: string,
+  filePath: string,
+  ref?: string,
+  execImpl: typeof execFileAsync = execFileAsync
+): Promise<string> {
+  const branch = ref || "main";
+  const url = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${filePath}`;
+  try {
+    const { stdout } = await execImpl("curl", ["-fsSL", url]);
+    return stdout;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to fetch ${url}: ${msg}`);
+  }
+}
+
+interface GitHubContentsEntry {
+  name: string;
+  path: string;
+  type: "file" | "dir";
+}
+
+/**
+ * Discover skill YAML files in a GitHub repo.
+ * Searches common locations: skills/, .agent_context/skills/, .glab-agent/skills/
+ * Uses GitHub API (via curl) to list directory contents.
+ */
+export async function discoverRemoteSkills(
+  owner: string,
+  repo: string,
+  ref?: string,
+  execImpl: typeof execFileAsync = execFileAsync
+): Promise<string[]> {
+  const searchPaths = ["skills", ".agent_context/skills", ".glab-agent/skills"];
+  const found: string[] = [];
+
+  for (const searchPath of searchPaths) {
+    const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${searchPath}${ref ? `?ref=${ref}` : ""}`;
+    try {
+      const { stdout } = await execImpl("curl", [
+        "-fsSL",
+        "-H", "Accept: application/vnd.github.v3+json",
+        apiUrl
+      ]);
+      const entries = parseYaml(stdout) as GitHubContentsEntry[] | null;
+      if (!Array.isArray(entries)) continue;
+      for (const entry of entries) {
+        if (
+          entry.type === "file" &&
+          (entry.name.endsWith(".yaml") || entry.name.endsWith(".yml") || entry.name === "SKILL.md")
+        ) {
+          found.push(entry.path);
+        }
+        // Anthropic convention: skills/<name>/SKILL.md
+        if (entry.type === "dir") {
+          const subApiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${entry.path}${ref ? `?ref=${ref}` : ""}`;
+          try {
+            const { stdout: subStdout } = await execImpl("curl", [
+              "-fsSL", "-H", "Accept: application/vnd.github.v3+json", subApiUrl
+            ]);
+            const subEntries = parseYaml(subStdout) as GitHubContentsEntry[] | null;
+            if (Array.isArray(subEntries)) {
+              for (const sub of subEntries) {
+                if (sub.type === "file" && sub.name === "SKILL.md") {
+                  found.push(sub.path);
+                }
+              }
+            }
+          } catch { /* subdirectory listing failed — skip */ }
+        }
+      }
+    } catch {
+      // Directory doesn't exist or API error — try next path
+    }
+  }
+
+  return found;
+}
+
+/**
+ * Import a single skill YAML from GitHub to the local skills directory.
+ */
+export async function importSkill(
+  owner: string,
+  repo: string,
+  filePath: string,
+  skillsDir: string,
+  options?: { ref?: string; force?: boolean; execImpl?: typeof execFileAsync }
+): Promise<ImportResult> {
+  const execImpl = options?.execImpl ?? execFileAsync;
+  const force = options?.force ?? false;
+  const ref = options?.ref;
+
+  // 1. Fetch the YAML content
+  let content: string;
+  try {
+    content = await fetchGitHubFile(owner, repo, filePath, ref, execImpl);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      status: "failed",
+      name: path.basename(filePath, path.extname(filePath)),
+      message: `Fetch failed: ${msg}`
+    };
+  }
+
+  // 2. Parse content — branch on format (SKILL.md vs YAML)
+  const isMd = filePath.endsWith(".md") || filePath.endsWith("SKILL.md");
+
+  let skillName: string;
+  if (isMd) {
+    const parsed = parseSkillMd(content);
+    if (!parsed) {
+      return {
+        status: "failed",
+        name: path.basename(filePath, path.extname(filePath)),
+        message: "Invalid SKILL.md: missing frontmatter or name"
+      };
+    }
+    if (!parsed.prompt_inject) {
+      return {
+        status: "failed",
+        name: parsed.name,
+        message: "SKILL.md has empty body (no prompt content)"
+      };
+    }
+    skillName = parsed.name;
+  } else {
+    let parsed: Record<string, unknown>;
+    try {
+      const raw = parseYaml(content);
+      if (typeof raw !== "object" || raw === null) {
+        throw new Error("YAML did not parse to an object");
+      }
+      parsed = raw as Record<string, unknown>;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        status: "failed",
+        name: path.basename(filePath, path.extname(filePath)),
+        message: `Invalid YAML: ${msg}`
+      };
+    }
+
+    if (typeof parsed.name !== "string" || !parsed.name) {
+      return {
+        status: "failed",
+        name: path.basename(filePath, path.extname(filePath)),
+        message: "Skill YAML missing required field: name"
+      };
+    }
+
+    if (typeof parsed.prompt_inject !== "string" || !parsed.prompt_inject) {
+      return {
+        status: "failed",
+        name: parsed.name as string,
+        message: "Skill YAML missing required field: prompt_inject"
+      };
+    }
+    skillName = parsed.name as string;
+  }
+
+  // 3. Determine local filename from skill name (preserve format)
+  const localFileName = isMd ? `${skillName}.md` : `${skillName}.yaml`;
+  const localPath = path.join(skillsDir, localFileName);
+
+  // 4. Check if file already exists
+  let existingContent: string | null = null;
+  try {
+    existingContent = await readFile(localPath, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        status: "failed",
+        name: skillName,
+        message: `Failed to read existing skill file: ${msg}`
+      };
+    }
+    // File does not exist — will be imported
+  }
+
+  if (existingContent !== null) {
+    if (existingContent === content) {
+      return {
+        status: "unchanged",
+        name: skillName,
+        message: `Skill "${skillName}" is already up to date`
+      };
+    }
+    if (!force) {
+      return {
+        status: "unchanged",
+        name: skillName,
+        message: `Skill "${skillName}" already exists (use --force to overwrite)`
+      };
+    }
+    // force=true and content differs → will update
+  }
+
+  // 5. Write to skillsDir/<name>.yaml
+  try {
+    await mkdir(skillsDir, { recursive: true });
+    await writeFile(localPath, content, "utf8");
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      status: "failed",
+      name: skillName,
+      message: `Failed to write skill file: ${msg}`
+    };
+  }
+
+  // 6. Return ImportResult
+  if (existingContent !== null) {
+    return {
+      status: "updated",
+      name: skillName,
+      message: `Skill "${skillName}" updated from ${owner}/${repo}`
+    };
+  }
+  return {
+    status: "imported",
+    name: skillName,
+    message: `Skill "${skillName}" imported from ${owner}/${repo}`
+  };
+}
+
+/**
+ * Import all skills from a GitHub repo.
+ */
+export async function importAllSkills(
+  owner: string,
+  repo: string,
+  skillsDir: string,
+  options?: { ref?: string; force?: boolean; execImpl?: typeof execFileAsync }
+): Promise<ImportResult[]> {
+  const execImpl = options?.execImpl ?? execFileAsync;
+
+  // 1. Discover remote skills
+  let filePaths: string[];
+  try {
+    filePaths = await discoverRemoteSkills(owner, repo, options?.ref, execImpl);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return [
+      {
+        status: "failed",
+        name: "(discovery)",
+        message: `Failed to discover skills in ${owner}/${repo}: ${msg}`
+      }
+    ];
+  }
+
+  if (filePaths.length === 0) {
+    return [
+      {
+        status: "failed",
+        name: "(discovery)",
+        message: `No skill files found in ${owner}/${repo} (looked for .yaml and SKILL.md)`
+      }
+    ];
+  }
+
+  // 2. Import each one
+  const results: ImportResult[] = [];
+  for (const filePath of filePaths) {
+    const result = await importSkill(owner, repo, filePath, skillsDir, options);
+    results.push(result);
+  }
+
+  // 3. Return results array
+  return results;
+}

package/src/local-agent/skill-inject.ts

@@ -0,0 +1,109 @@
+import { mkdir, writeFile, readFile, rm } from "node:fs/promises";
+import path from "node:path";
+import type { AgentSkill } from "./agent-config.js";
+
+/**
+ * Provider-specific skill directory conventions.
+ * Claude Code: .claude/skills/
+ * OpenCode: .config/opencode/skills/
+ * Codex: .agent_context/skills/
+ */
+export function skillDirForProvider(worktreePath: string, provider: "claude" | "codex"): string {
+  if (provider === "claude") return path.join(worktreePath, ".claude", "skills");
+  return path.join(worktreePath, ".agent_context", "skills");
+}
+
+/**
+ * Resolve the source .md file path for a shared skill (if it exists on disk).
+ * Returns undefined if the skill was defined inline (no source file).
+ */
+function sharedSkillMdPath(skillsDir: string | undefined, name: string): string | undefined {
+  if (!skillsDir) return undefined;
+  return path.join(skillsDir, `${slugifySkillName(name)}.md`);
+}
+
+/**
+ * Write skill files into the worktree for native agent CLI recognition.
+ * - For .md shared skills: copies the original SKILL.md file as-is (preserving frontmatter).
+ * - For inline skills (from agent YAML): generates SKILL.md with frontmatter.
+ *
+ * Returns the number of skills written.
+ */
+export async function injectSkillFiles(
+  worktreePath: string,
+  provider: "claude" | "codex",
+  skills: AgentSkill[],
+  skillsDir?: string
+): Promise<number> {
+  if (skills.length === 0) return 0;
+
+  const skillDir = skillDirForProvider(worktreePath, provider);
+  await mkdir(skillDir, { recursive: true });
+
+  let count = 0;
+  for (const skill of skills) {
+    const fileName = slugifySkillName(skill.name) + ".md";
+    const destPath = path.join(skillDir, fileName);
+
+    // Try to copy original .md file if it exists (preserves native SKILL.md format)
+    const srcPath = sharedSkillMdPath(skillsDir, skill.name);
+    let copied = false;
+    if (srcPath) {
+      try {
+        const original = await readFile(srcPath, "utf8");
+        await writeFile(destPath, original, "utf8");
+        copied = true;
+      } catch { /* source .md not found — fall through to generation */ }
+    }
+
+    if (!copied) {
+      const content = formatSkillMarkdown(skill);
+      await writeFile(destPath, content, "utf8");
+    }
+    count++;
+  }
+  return count;
+}
+
+/**
+ * Clean up injected skill files (called after agent run if needed).
+ */
+export async function cleanSkillFiles(
+  worktreePath: string,
+  provider: "claude" | "codex"
+): Promise<void> {
+  const skillDir = skillDirForProvider(worktreePath, provider);
+  try {
+    await rm(skillDir, { recursive: true, force: true });
+  } catch { /* silent */ }
+}
+
+/**
+ * Format an inline skill as standard SKILL.md (YAML frontmatter + markdown body).
+ * Used for inline skills defined in agent YAML that don't have a source .md file.
+ */
+export function formatSkillMarkdown(skill: AgentSkill): string {
+  const lines: string[] = [];
+  lines.push("---");
+  lines.push(`name: ${skill.name}`);
+  if (skill.description) {
+    lines.push(`description: ${skill.description}`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(skill.prompt_inject.trimEnd());
+  lines.push("");
+  return lines.join("\n");
+}
+
+/**
+ * Normalize skill name to a safe filename.
+ */
+export function slugifySkillName(name: string): string {
+  return (
+    name
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "skill"
+  );
+}

package/src/local-agent/skill-parse.ts

@@ -0,0 +1,47 @@
+import { parse as parseYaml } from "yaml";
+import type { AgentSkill } from "./agent-config.js";
+
+/**
+ * Regex to extract YAML frontmatter and markdown body from SKILL.md format.
+ * Group 1: YAML frontmatter content (between --- delimiters)
+ * Group 2: Markdown body (after closing ---)
+ */
+const FRONTMATTER_RE = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?([\s\S]*)$/;
+
+/**
+ * Parse a SKILL.md file (YAML frontmatter + markdown body) into an AgentSkill.
+ * Returns null if the content is not valid SKILL.md format or missing required fields.
+ *
+ * Expected format:
+ * ```
+ * ---
+ * name: skill-name
+ * description: Optional description
+ * ---
+ *
+ * Markdown body becomes prompt_inject
+ * ```
+ */
+export function parseSkillMd(content: string): AgentSkill | null {
+  const match = content.match(FRONTMATTER_RE);
+  if (!match) return null;
+
+  const [, frontmatterStr, body] = match;
+
+  let frontmatter: Record<string, unknown>;
+  try {
+    const raw = parseYaml(frontmatterStr);
+    if (typeof raw !== "object" || raw === null) return null;
+    frontmatter = raw as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+
+  const name = frontmatter.name;
+  if (typeof name !== "string" || !name) return null;
+
+  const description = typeof frontmatter.description === "string" ? frontmatter.description : "";
+  const prompt_inject = body.trim();
+
+  return { name, description, prompt_inject };
+}