@naraya/cli 0.1.0 → 0.4.0

package/src/pentest/skills/loader/skill-loader.ts

@@ -0,0 +1,206 @@
+import type { PentestSkill, PentestSkillManifest, SkillLoadResult } from "../types.js"
+import type { PentestPhase, ToolCategory } from "../../types.js"
+import { existsSync, readFileSync, readdirSync, statSync } from "fs"
+import { join } from "path"
+
+const SKILL_DIRS = [
+  ".agents/skills",
+  ".opencode/skills",
+  ".claude/skills",
+  "packages/pentest-skills/skills",
+]
+
+const SKILL_FILENAME = "SKILL.md"
+
+export function resolveSkillPath(skillName: string, baseDir: string = process.cwd()): string | null {
+  for (const dir of SKILL_DIRS) {
+    const skillPath = join(baseDir, dir, skillName, SKILL_FILENAME)
+    if (existsSync(skillPath)) {
+      return skillPath
+    }
+  }
+  return null
+}
+
+export function discoverSkills(baseDir: string = process.cwd()): PentestSkillManifest[] {
+  const manifests: PentestSkillManifest[] = []
+
+  for (const dir of SKILL_DIRS) {
+    const skillsDir = join(baseDir, dir)
+    if (!existsSync(skillsDir)) continue
+
+    const entries = readdirSync(skillsDir)
+    for (const entry of entries) {
+      const skillDir = join(skillsDir, entry)
+      if (!statSync(skillDir).isDirectory()) continue
+
+      const skillFile = join(skillDir, SKILL_FILENAME)
+      if (!existsSync(skillFile)) continue
+
+      const manifest = parseSkillManifest(skillFile, entry, skillDir)
+      if (manifest) {
+        manifests.push(manifest)
+      }
+    }
+  }
+
+  return manifests
+}
+
+export function loadSkill(skillName: string, baseDir: string = process.cwd()): SkillLoadResult {
+  const skillPath = resolveSkillPath(skillName, baseDir)
+  
+  if (!skillPath) {
+    return {
+      name: skillName,
+      loaded: false,
+      error: `Skill not found: ${skillName}`,
+    }
+  }
+
+  try {
+    const content = readFileSync(skillPath, "utf-8")
+    const skill = parseSkillContent(content, skillName, skillPath)
+    
+    return {
+      name: skillName,
+      loaded: true,
+      skill,
+    }
+  } catch (error) {
+    return {
+      name: skillName,
+      loaded: false,
+      error: error instanceof Error ? error.message : "Failed to load skill",
+    }
+  }
+}
+
+export function loadAllSkills(baseDir: string = process.cwd()): SkillLoadResult[] {
+  const manifests = discoverSkills(baseDir)
+  return manifests.map(m => loadSkill(m.name, baseDir))
+}
+
+export function loadSkillsByPhase(
+  phase: string,
+  baseDir: string = process.cwd(),
+): SkillLoadResult[] {
+  const manifests = discoverSkills(baseDir)
+  const filtered = manifests.filter(m => m.phase.includes(phase as never))
+  return filtered.map(m => loadSkill(m.name, baseDir))
+}
+
+export function loadSkillsByTools(
+  toolNames: readonly string[],
+  baseDir: string = process.cwd(),
+): SkillLoadResult[] {
+  const manifests = discoverSkills(baseDir)
+  const toolSet = new Set(toolNames)
+  const filtered = manifests.filter(m => m.tools.some((t: string) => toolSet.has(t)))
+  return filtered.map(m => loadSkill(m.name, baseDir))
+}
+
+export function getSkillsForTool(
+  toolName: string,
+  baseDir: string = process.cwd(),
+): SkillLoadResult[] {
+  return loadSkillsByTools([toolName], baseDir)
+}
+
+function parseSkillManifest(
+  skillFile: string,
+  skillName: string,
+  _skillDir: string,
+): PentestSkillManifest | null {
+  try {
+    const content = readFileSync(skillFile, "utf-8")
+    const frontmatter = extractFrontmatter(content)
+    
+    if (!frontmatter) {
+      return {
+        name: skillName,
+        description: "",
+        version: "0.0.0",
+        phase: [] as PentestPhase[],
+        category: [] as ToolCategory[],
+        tools: [],
+        tags: [],
+        skill_path: skillFile,
+        loaded: false,
+      }
+    }
+
+    return {
+      name: (frontmatter.name as string) ?? skillName,
+      description: (frontmatter.description as string) ?? "",
+      version: (frontmatter.version as string) ?? "0.0.0",
+      phase: parseStringArray(frontmatter.phase) as PentestPhase[],
+      category: parseStringArray(frontmatter.category) as ToolCategory[],
+      tools: parseStringArray(frontmatter.tools),
+      tags: parseStringArray(frontmatter.tags),
+      skill_path: skillFile,
+      loaded: true,
+    }
+  } catch {
+    return null
+  }
+}
+
+function parseSkillContent(
+  content: string,
+  skillName: string,
+  _skillPath: string,
+): PentestSkill {
+  const frontmatter = extractFrontmatter(content) ?? {}
+  
+  return {
+    name: (frontmatter.name as string) ?? skillName,
+    description: (frontmatter.description as string) ?? "",
+    version: (frontmatter.version as string) ?? "0.0.0",
+    phase: parseStringArray(frontmatter.phase) as PentestPhase[],
+    category: parseStringArray(frontmatter.category) as ToolCategory[],
+    tools: parseStringArray(frontmatter.tools),
+    author: frontmatter.author as string | undefined,
+    homepage: frontmatter.homepage as string | undefined,
+    tags: parseStringArray(frontmatter.tags),
+    template: content,
+  }
+}
+
+function extractFrontmatter(content: string): Record<string, unknown> | null {
+  const match = /^---\s*\n([\s\S]*?)\n---/.exec(content)
+  if (!match) return null
+
+  const yaml = match[1]
+  const result: Record<string, unknown> = {}
+
+  for (const line of yaml.split("\n")) {
+    const colonIndex = line.indexOf(":")
+    if (colonIndex === -1) continue
+
+    const key = line.slice(0, colonIndex).trim()
+    const value = line.slice(colonIndex + 1).trim()
+
+    if (value.startsWith("[") && value.endsWith("]")) {
+      result[key] = value
+        .slice(1, -1)
+        .split(",")
+        .map(s => s.trim().replace(/^["']|["']$/g, ""))
+    } else {
+      result[key] = value.replace(/^["']|["']$/g, "")
+    }
+  }
+
+  return result
+}
+
+function parseStringArray(value: unknown): string[] {
+  if (Array.isArray(value)) return value.map(String)
+  if (typeof value === "string") {
+    if (value.startsWith("[") && value.endsWith("]")) {
+      return value.slice(1, -1).split(",").map(s => s.trim().replace(/^["']|["']$/g, ""))
+    }
+    return [value]
+  }
+  return []
+}

package/src/pentest/skills/register/index.ts

@@ -0,0 +1 @@
+export * from "./skill-register.js"

package/src/pentest/skills/register/skill-register.ts

@@ -0,0 +1,196 @@
+import type { PentestSkill, SkillRegisterEntry, SkillRegisterConfig } from "../types.js"
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs"
+import { join, dirname } from "path"
+import { loadSkill } from "../loader/skill-loader.js"
+
+const DEFAULT_CONFIG: SkillRegisterConfig = {
+  skills_dir: ".agents/skills",
+  auto_discover: true,
+  search_paths: [".agents/skills", ".opencode/skills", ".claude/skills"],
+}
+
+export class SkillRegister {
+  private entries: Map<string, SkillRegisterEntry> = new Map()
+  private config: SkillRegisterConfig
+
+  constructor(config: Partial<SkillRegisterConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config }
+    
+    if (this.config.auto_discover) {
+      this.discoverAndRegister()
+    }
+  }
+
+  register(skill: PentestSkill): SkillRegisterEntry {
+    const entry: SkillRegisterEntry = {
+      name: skill.name,
+      skill,
+      registered_at: new Date().toISOString(),
+      enabled: true,
+    }
+    
+    this.entries.set(skill.name, entry)
+    return entry
+  }
+
+  registerFromFile(skillName: string, baseDir?: string): SkillRegisterEntry | null {
+    const result = loadSkill(skillName, baseDir)
+    
+    if (!result.loaded || !result.skill) {
+      return null
+    }
+
+    return this.register(result.skill)
+  }
+
+  registerMany(skills: readonly PentestSkill[]): SkillRegisterEntry[] {
+    return skills.map(skill => this.register(skill))
+  }
+
+  registerFromFiles(skillNames: readonly string[], baseDir?: string): SkillRegisterEntry[] {
+    const entries: SkillRegisterEntry[] = []
+    
+    for (const name of skillNames) {
+      const entry = this.registerFromFile(name, baseDir)
+      if (entry) entries.push(entry)
+    }
+
+    return entries
+  }
+
+  unregister(skillName: string): boolean {
+    return this.entries.delete(skillName)
+  }
+
+  enable(skillName: string): boolean {
+    const entry = this.entries.get(skillName)
+    if (!entry) return false
+    ;(entry as { enabled: boolean }).enabled = true
+    return true
+  }
+
+  disable(skillName: string): boolean {
+    const entry = this.entries.get(skillName)
+    if (!entry) return false
+    ;(entry as { enabled: boolean }).enabled = false
+    return true
+  }
+
+  get(skillName: string): SkillRegisterEntry | undefined {
+    return this.entries.get(skillName)
+  }
+
+  getEnabled(): SkillRegisterEntry[] {
+    return [...this.entries.values()].filter(e => e.enabled)
+  }
+
+  getAll(): SkillRegisterEntry[] {
+    return [...this.entries.values()]
+  }
+
+  getByPhase(phase: string): SkillRegisterEntry[] {
+    return this.getEnabled().filter(e => e.skill.phase.includes(phase as never))
+  }
+
+  getByCategory(category: string): SkillRegisterEntry[] {
+    return this.getEnabled().filter(e => e.skill.category.includes(category as never))
+  }
+
+  getByTool(toolName: string): SkillRegisterEntry[] {
+    return this.getEnabled().filter(e => e.skill.tools.includes(toolName))
+  }
+
+  getByTag(tag: string): SkillRegisterEntry[] {
+    return this.getEnabled().filter(e => e.skill.tags.includes(tag))
+  }
+
+  has(skillName: string): boolean {
+    return this.entries.has(skillName)
+  }
+
+  count(): number {
+    return this.entries.size
+  }
+
+  enabledCount(): number {
+    return this.getEnabled().length
+  }
+
+  clear(): void {
+    this.entries.clear()
+  }
+
+  saveToFile(outputPath?: string): string {
+    const path = outputPath ?? join(this.config.skills_dir, ".skill-register.json")
+    const dir = dirname(path)
+    
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+
+    const data = {
+      version: "1.0.0",
+      saved_at: new Date().toISOString(),
+      entries: this.getAll().map(e => ({
+        name: e.name,
+        description: e.skill.description,
+        version: e.skill.version,
+        phase: e.skill.phase,
+        category: e.skill.category,
+        tools: e.skill.tools,
+        tags: e.skill.tags,
+        enabled: e.enabled,
+        registered_at: e.registered_at,
+      })),
+    }
+
+    writeFileSync(path, JSON.stringify(data, null, 2))
+    return path
+  }
+
+  loadFromFile(inputPath?: string): number {
+    const path = inputPath ?? join(this.config.skills_dir, ".skill-register.json")
+    
+    if (!existsSync(path)) return 0
+
+    try {
+      const content = readFileSync(path, "utf-8")
+      const data = JSON.parse(content) as { entries: Array<{ name: string; enabled: boolean }> }
+      
+      let loaded = 0
+      for (const entry of data.entries ?? []) {
+        const result = loadSkill(entry.name)
+        if (result.loaded && result.skill) {
+          const registered = this.register(result.skill)
+          ;(registered as { enabled: boolean }).enabled = entry.enabled
+          loaded++
+        }
+      }
+      
+      return loaded
+    } catch {
+      return 0
+    }
+  }
+
+  private discoverAndRegister(): void {
+    for (const searchPath of this.config.search_paths) {
+      if (!existsSync(searchPath)) continue
+
+      const entries = readdirSync(searchPath)
+      for (const entry of entries) {
+        const skillPath = join(searchPath, entry, "SKILL.md")
+        if (existsSync(skillPath)) {
+          const result = loadSkill(entry, searchPath)
+          if (result.loaded && result.skill) {
+            this.register(result.skill)
+          }
+        }
+      }
+    }
+  }
+}
+
+export function createSkillRegister(config?: Partial<SkillRegisterConfig>): SkillRegister {
+  return new SkillRegister(config)
+}

package/src/pentest/skills/types.ts

@@ -0,0 +1,66 @@
+import type { PentestPhase, ToolCategory } from "../types.js"
+
+export interface PentestSkill {
+  readonly name: string
+  readonly description: string
+  readonly version: string
+  readonly phase: readonly PentestPhase[]
+  readonly category: readonly ToolCategory[]
+  readonly tools: readonly string[]
+  readonly author?: string
+  readonly homepage?: string
+  readonly tags: readonly string[]
+  readonly template: string
+}
+
+export interface PentestSkillManifest {
+  readonly name: string
+  readonly description: string
+  readonly version: string
+  readonly phase: readonly PentestPhase[]
+  readonly category: readonly ToolCategory[]
+  readonly tools: readonly string[]
+  readonly tags: readonly string[]
+  readonly skill_path: string
+  readonly loaded: boolean
+}
+
+export interface SkillRegisterEntry {
+  readonly name: string
+  readonly skill: PentestSkill
+  readonly registered_at: string
+  readonly enabled: boolean
+}
+
+export interface SkillRegisterConfig {
+  readonly skills_dir: string
+  readonly auto_discover: boolean
+  readonly search_paths: readonly string[]
+}
+
+export interface GeneratedSkill {
+  readonly name: string
+  readonly content: string
+  readonly path: string
+  readonly tools_referenced: readonly string[]
+  readonly phase: readonly PentestPhase[]
+}
+
+export interface SkillGenerationOptions {
+  readonly name: string
+  readonly description: string
+  readonly phase: readonly PentestPhase[]
+  readonly category: readonly ToolCategory[]
+  readonly tools: readonly string[]
+  readonly author?: string
+  readonly tags?: readonly string[]
+  readonly output_dir?: string
+  readonly template?: "basic" | "recon" | "exploitation" | "reporting" | "custom"
+}
+
+export interface SkillLoadResult {
+  readonly name: string
+  readonly loaded: boolean
+  readonly skill?: PentestSkill
+  readonly error?: string
+}