agent-facets 0.3.0 → 0.3.5

package/src/commands/create/index.ts

@@ -1,76 +0,0 @@
-import { join } from 'node:path'
-import { createInterface } from 'node:readline'
-import { FACET_MANIFEST_FILE } from '@agent-facets/core'
-import { type } from 'arktype'
-import type { Command } from '../../commands.ts'
-import { writeScaffold } from '../create-scaffold.ts'
-import { resolveTargetDir } from '../resolve-dir.ts'
-import { runCreateWizardInk } from './wizard.tsx'
-
-export type { CreateOptions } from '../create-scaffold.ts'
-export { writeScaffold } from '../create-scaffold.ts'
-
-const CreateFlags = type({ 'force?': 'boolean' })
-
-async function confirmOverwrite(display: string): Promise<boolean> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout })
-
-  return new Promise((resolve) => {
-    rl.question(`A facet already exists in ${display}. Overwrite? (y/N) `, (answer) => {
-      rl.close()
-      resolve(answer.toLowerCase() === 'y')
-    })
-  })
-}
-
-export const createCommand: Command = {
-  name: 'create',
-  description: 'Create a new facet project interactively',
-  usage: '[directory]',
-  flags: {
-    force: { type: 'boolean', description: 'Overwrite existing facet.json' },
-  },
-  run: async (args: string[], flags: Record<string, unknown>): Promise<number> => {
-    const resolved = await resolveTargetDir(args[0], { mustExist: false })
-    if (!resolved.ok) {
-      console.error(resolved.message)
-      return 1
-    }
-
-    const targetDir = resolved.dir
-    const displayDir = resolved.display
-
-    // Validate flags via Arktype
-    const validatedFlags = CreateFlags(flags)
-    if (validatedFlags instanceof type.errors) {
-      console.error(`Invalid flags: ${validatedFlags.summary}`)
-      return 1
-    }
-
-    // Overwrite protection
-    const manifestExists = await Bun.file(join(targetDir, FACET_MANIFEST_FILE)).exists()
-    if (manifestExists && !validatedFlags.force) {
-      const confirmed = await confirmOverwrite(displayDir)
-      if (!confirmed) {
-        console.log('Cancelled.')
-        return 1
-      }
-    }
-
-    const opts = await runCreateWizardInk()
-    if (!opts) {
-      console.log('\nCancelled.')
-      return 1
-    }
-
-    const files = await writeScaffold(opts, targetDir)
-
-    console.log(`\nFacet created: ${opts.name} → ${displayDir}`)
-    for (const file of files) {
-      console.log(`  ${displayDir}/${file}`)
-    }
-    console.log(`\nRun "facet build${args[0] ? ` ${displayDir}` : ''}" to validate your facet.`)
-
-    return 0
-  },
-}

package/src/commands/create/types.ts

@@ -1,9 +0,0 @@
-export type AssetType = 'skill' | 'agent' | 'command'
-
-export const ASSET_TYPES: AssetType[] = ['skill', 'command', 'agent']
-
-export const ASSET_LABELS: Record<AssetType, string> = {
-  skill: 'Skills',
-  agent: 'Agents',
-  command: 'Commands',
-}

package/src/commands/create/wizard.tsx

@@ -1,75 +0,0 @@
-import { render } from 'ink'
-import type { AssetSectionKey } from '../../tui/context/form-state-context.ts'
-import { openInEditorSync } from '../../tui/editor.ts'
-import type { WizardSnapshot } from '../../tui/views/create/wizard.tsx'
-import { CreateWizard } from '../../tui/views/create/wizard.tsx'
-import type { CreateOptions } from '../create-scaffold.ts'
-
-interface EditorRequest {
-  section: AssetSectionKey
-  name: string
-  description: string
-}
-
-export async function runCreateWizardInk(): Promise<CreateOptions | null> {
-  let result: CreateOptions | null = null
-  let snapshot: WizardSnapshot | undefined
-  let pendingEditor: EditorRequest | null = null
-  let done = false
-
-  while (!done) {
-    pendingEditor = null
-
-    await new Promise<void>((resolve) => {
-      const instance = render(
-        <CreateWizard
-          snapshot={snapshot}
-          onComplete={(opts) => {
-            result = opts
-          }}
-          onCancel={() => {
-            result = null
-          }}
-          onSnapshot={(s) => {
-            snapshot = s
-          }}
-          onRequestEditor={(section, name, description) => {
-            pendingEditor = { section, name, description }
-            instance.unmount()
-          }}
-        />,
-      )
-
-      instance.waitUntilExit().then(() => resolve())
-    })
-
-    if (pendingEditor) {
-      const req = pendingEditor as EditorRequest
-      const edited = openInEditorSync(req.description, `${req.name}.md`)
-      if (snapshot) {
-        const section = snapshot.form.assets[req.section]
-        snapshot = {
-          ...snapshot,
-          selectedItem: undefined,
-          form: {
-            ...snapshot.form,
-            assets: {
-              ...snapshot.form.assets,
-              [req.section]: {
-                ...section,
-                descriptions: {
-                  ...section.descriptions,
-                  ...(edited !== null ? { [req.name]: edited.trim() } : {}),
-                },
-              },
-            },
-          },
-        }
-      }
-    } else {
-      done = true
-    }
-  }
-
-  return result
-}

package/src/commands/create-scaffold.ts

@@ -1,184 +0,0 @@
-import { mkdir } from 'node:fs/promises'
-import { join } from 'node:path'
-import { FACET_MANIFEST_FILE, KEBAB_CASE } from '@agent-facets/core'
-
-// --- Types ---
-
-export interface CreateOptions {
-  name: string
-  version: string
-  description: string
-  skills: string[]
-  agents: string[]
-  commands: string[]
-}
-
-// --- Defaults ---
-
-export const DEFAULT_VERSION = '0.0.0'
-
-// --- Validation ---
-
-export { KEBAB_CASE }
-export const SEMVER = /^\d+\.\d+\.\d+$/
-
-export function isValidKebabCase(value: string): boolean {
-  return KEBAB_CASE.test(value)
-}
-
-export function isValidSemVer(value: string): boolean {
-  return SEMVER.test(value)
-}
-
-// --- Template generation ---
-
-function toTitleCase(kebab: string): string {
-  return kebab
-    .split('-')
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-    .join(' ')
-}
-
-export function skillTemplate(name: string): string {
-  return `# ${toTitleCase(name)}
-
-<!-- This is a starter skill template. Replace this content with your skill's instructions. -->
-<!-- Skills provide reusable knowledge and guidelines that agents and commands can reference. -->
-<!-- A skill needs a description (required) — the description helps consumers decide -->
-<!-- whether to use this skill. The prompt content is this file. -->
-
-## Purpose
-
-Describe what this skill teaches or what guidelines it provides.
-
-## Guidelines
-
-- Add your skill's guidelines here
-- Each guideline should be clear and actionable
-`
-}
-
-export function agentTemplate(name: string): string {
-  return `# ${toTitleCase(name)}
-
-<!-- This is a starter agent template. Replace this content with your agent's prompt. -->
-<!-- Agents are AI assistant personas with specific roles, behaviors, and tool access. -->
-
-## Role
-
-Describe this agent's role and responsibilities.
-
-## Behavior
-
-- Define how this agent should behave
-- Specify what tools it should use
-- Describe its communication style
-`
-}
-
-export function commandTemplate(name: string): string {
-  return `# ${toTitleCase(name)}
-
-<!-- This is a starter command template. Replace this content with your command's prompt. -->
-<!-- Commands are user-invokable actions that perform specific tasks. -->
-
-## Task
-
-Describe what this command does when invoked.
-
-## Steps
-
-1. First step
-2. Second step
-3. Final step
-`
-}
-
-// --- Manifest generation ---
-
-export function generateManifest(opts: CreateOptions): string {
-  const manifest: Record<string, unknown> = {
-    name: opts.name,
-    version: opts.version,
-  }
-
-  if (opts.description) {
-    manifest.description = opts.description
-  }
-
-  if (opts.skills.length > 0) {
-    const skills: Record<string, { description: string }> = {}
-    for (const skill of opts.skills) {
-      skills[skill] = { description: `A ${toTitleCase(skill)} skill` }
-    }
-    manifest.skills = skills
-  }
-
-  if (opts.agents.length > 0) {
-    const agents: Record<string, { description: string }> = {}
-    for (const agent of opts.agents) {
-      agents[agent] = { description: `A ${toTitleCase(agent)} agent` }
-    }
-    manifest.agents = agents
-  }
-
-  if (opts.commands.length > 0) {
-    const commands: Record<string, { description: string }> = {}
-    for (const command of opts.commands) {
-      commands[command] = { description: `A ${toTitleCase(command)} command` }
-    }
-    manifest.commands = commands
-  }
-
-  return JSON.stringify(manifest, null, 2)
-}
-
-// --- File listing preview ---
-
-export function previewFiles(opts: CreateOptions): string[] {
-  const files: string[] = [FACET_MANIFEST_FILE]
-  for (const skill of opts.skills) {
-    files.push(`skills/${skill}/SKILL.md`)
-  }
-  for (const agent of opts.agents) {
-    files.push(`agents/${agent}.md`)
-  }
-  for (const command of opts.commands) {
-    files.push(`commands/${command}.md`)
-  }
-  return files
-}
-
-// --- Scaffold writing ---
-
-export async function writeScaffold(opts: CreateOptions, targetDir: string): Promise<string[]> {
-  const files: string[] = []
-
-  // Write manifest
-  const manifestPath = join(targetDir, FACET_MANIFEST_FILE)
-  await Bun.write(manifestPath, generateManifest(opts))
-  files.push(FACET_MANIFEST_FILE)
-
-  // Write skill files (Agent Skills directory convention: skills/<name>/SKILL.md)
-  for (const skill of opts.skills) {
-    await mkdir(join(targetDir, 'skills', skill), { recursive: true })
-    await Bun.write(join(targetDir, `skills/${skill}/SKILL.md`), skillTemplate(skill))
-    files.push(`skills/${skill}/SKILL.md`)
-  }
-
-  // Write agent files
-  for (const agent of opts.agents) {
-    await mkdir(join(targetDir, 'agents'), { recursive: true })
-    await Bun.write(join(targetDir, `agents/${agent}.md`), agentTemplate(agent))
-    files.push(`agents/${agent}.md`)
-  }
-
-  // Write command files
-  for (const command of opts.commands) {
-    await mkdir(join(targetDir, 'commands'), { recursive: true })
-    await Bun.write(join(targetDir, `commands/${command}.md`), commandTemplate(command))
-    files.push(`commands/${command}.md`)
-  }
-
-  return files
-}

package/src/commands/edit/index.ts

@@ -1,144 +0,0 @@
-import { mkdir } from 'node:fs/promises'
-import { join } from 'node:path'
-import {
-  type FacetManifest,
-  hasFrontMatter,
-  loadManifest,
-  reconcile,
-  scanAssets,
-  writeManifest,
-} from '@agent-facets/core'
-import type { Command } from '../../commands.ts'
-import type { EditContext, EditOperation, EditResult, ReconciliationItem } from '../../tui/views/edit/edit-types.ts'
-import { agentTemplate, commandTemplate, skillTemplate } from '../create-scaffold.ts'
-import { resolveTargetDir } from '../resolve-dir.ts'
-import { runEditWizardInk } from './wizard.tsx'
-
-export async function buildEditContext(
-  rootDir: string,
-): Promise<{ ok: true; context: EditContext } | { ok: false; exitCode: number }> {
-  // Load manifest
-  const loadResult = await loadManifest(rootDir)
-  if (!loadResult.ok) {
-    // Hard error — show errors and exit
-    console.error('Manifest is invalid:')
-    for (const err of loadResult.errors) {
-      console.error(`  ${err.message}`)
-    }
-    console.error('\nFix facet.json and try again.')
-    return { ok: false, exitCode: 1 }
-  }
-
-  const manifest = loadResult.data
-
-  // Scan disk for assets
-  const discovered = await scanAssets(rootDir)
-
-  // Run reconciliation
-  const recon = reconcile(manifest, discovered)
-
-  // Build reconciliation items
-  const items: ReconciliationItem[] = []
-
-  for (const addition of recon.additions) {
-    items.push({ kind: 'addition', type: addition.type, name: addition.name, path: addition.path })
-  }
-
-  for (const missing of recon.missing) {
-    items.push({ kind: 'missing', type: missing.type, name: missing.name, expectedPath: missing.expectedPath })
-  }
-
-  // Check matched assets for front matter
-  for (const matched of recon.matched) {
-    const filePath = join(rootDir, matched.path)
-    const content = await Bun.file(filePath).text()
-    if (hasFrontMatter(content)) {
-      items.push({ kind: 'front-matter', type: matched.type, name: matched.name, path: matched.path })
-    }
-  }
-
-  return { ok: true, context: { rootDir, manifest, reconciliationItems: items } }
-}
-
-export async function applyOperations(
-  manifest: FacetManifest,
-  operations: EditOperation[],
-  rootDir: string,
-): Promise<void> {
-  for (const op of operations) {
-    switch (op.op) {
-      case 'write-manifest':
-        await writeManifest(manifest, rootDir)
-        break
-
-      case 'scaffold': {
-        if (op.type === 'skills') {
-          const dir = join(rootDir, 'skills', op.name)
-          await mkdir(dir, { recursive: true })
-          await Bun.write(join(dir, 'SKILL.md'), skillTemplate(op.name))
-        } else if (op.type === 'agents') {
-          await mkdir(join(rootDir, 'agents'), { recursive: true })
-          await Bun.write(join(rootDir, `agents/${op.name}.md`), agentTemplate(op.name))
-        } else if (op.type === 'commands') {
-          await mkdir(join(rootDir, 'commands'), { recursive: true })
-          await Bun.write(join(rootDir, `commands/${op.name}.md`), commandTemplate(op.name))
-        }
-        break
-      }
-
-      case 'delete-file': {
-        const path =
-          op.type === 'skills' ? join(rootDir, 'skills', op.name, 'SKILL.md') : join(rootDir, op.type, `${op.name}.md`)
-        try {
-          const { unlink } = await import('node:fs/promises')
-          await unlink(path)
-        } catch {
-          // File already gone — that's fine
-        }
-        break
-      }
-
-      case 'strip-front-matter': {
-        const { extractFrontMatter } = await import('@agent-facets/core')
-        const filePath = join(rootDir, op.path)
-        const raw = await Bun.file(filePath).text()
-        const { content } = extractFrontMatter(raw)
-        await Bun.write(filePath, content)
-        break
-      }
-    }
-  }
-}
-
-export const editCommand: Command = {
-  name: 'edit',
-  description: 'Edit a facet project interactively',
-  usage: '[directory]',
-  run: async (args: string[], _flags: Record<string, unknown>): Promise<number> => {
-    const resolved = await resolveTargetDir(args[0], { mustExist: true, facetMustExist: true })
-    if (!resolved.ok) {
-      console.error(resolved.message)
-      return 1
-    }
-
-    const rootDir = resolved.dir
-    const displayDir = resolved.display
-
-    const loaded = await buildEditContext(rootDir)
-    if (!loaded.ok) return loaded.exitCode
-
-    const result: EditResult = await runEditWizardInk(loaded.context)
-
-    if (result.outcome === 'cancelled') {
-      console.log('\nCancelled — no changes applied.')
-      return 1
-    }
-
-    await applyOperations(result.manifest, result.operations, rootDir)
-
-    console.log(`\nChanges applied to ${displayDir}`)
-    console.log(`Run "facet build${args[0] ? ` ${displayDir}` : ''}" to validate your facet.`)
-
-    return 0
-  },
-}

package/src/commands/edit/wizard.tsx

@@ -1,74 +0,0 @@
-import { render } from 'ink'
-import type { AssetSectionKey } from '../../tui/context/form-state-context.ts'
-import { openInEditorSync } from '../../tui/editor.ts'
-import type { EditContext, EditResult } from '../../tui/views/edit/edit-types.ts'
-import type { EditWizardSnapshot } from '../../tui/views/edit/wizard.tsx'
-import { EditWizard } from '../../tui/views/edit/wizard.tsx'
-
-interface EditorRequest {
-  section: AssetSectionKey
-  name: string
-  description: string
-}
-
-export async function runEditWizardInk(context: EditContext): Promise<EditResult> {
-  let result: EditResult = { outcome: 'cancelled' }
-  let snapshot: EditWizardSnapshot | undefined
-  let pendingEditor: EditorRequest | null = null
-  let done = false
-
-  while (!done) {
-    pendingEditor = null
-
-    await new Promise<void>((resolve) => {
-      const instance = render(
-        <EditWizard
-          context={context}
-          snapshot={snapshot}
-          onComplete={(r) => {
-            result = r
-          }}
-          onSnapshot={(s) => {
-            snapshot = s
-          }}
-          onRequestEditor={(section, name, description) => {
-            pendingEditor = { section, name, description }
-            instance.unmount()
-          }}
-        />,
-      )
-
-      instance.waitUntilExit().then(() => resolve())
-    })
-
-    if (pendingEditor) {
-      const req = pendingEditor as EditorRequest
-      const edited = openInEditorSync(req.description, `${req.name}.md`)
-      if (snapshot) {
-        snapshot = {
-          ...snapshot,
-          selectedItem: undefined,
-          formState: snapshot.formState
-            ? {
-                ...snapshot.formState,
-                assets: {
-                  ...snapshot.formState.assets,
-                  [req.section]: {
-                    ...snapshot.formState.assets[req.section],
-                    descriptions: {
-                      ...snapshot.formState.assets[req.section].descriptions,
-                      ...(edited !== null ? { [req.name]: edited.trim() } : {}),
-                    },
-                  },
-                },
-              }
-            : undefined,
-        }
-      }
-    } else {
-      done = true
-    }
-  }
-
-  return result
-}

package/src/commands/resolve-dir.ts

@@ -1,98 +0,0 @@
-import { mkdir, stat } from 'node:fs/promises'
-import { dirname, join, resolve } from 'node:path'
-import { FACET_MANIFEST_FILE } from '@agent-facets/core'
-
-export interface ResolvedDir {
-  ok: true
-  dir: string
-  display: string
-}
-
-export interface ResolvedDirError {
-  ok: false
-  message: string
-}
-
-export type ResolveResult = ResolvedDir | ResolvedDirError
-
-export interface ResolveOptions {
-  mustExist: boolean
-  facetMustExist?: boolean
-}
-
-/**
- * Validates and resolves a directory argument for CLI commands.
- *
- * Handles:
- * - No argument → uses process.cwd(), display as '.'
- * - Argument ending with facet.json → silently uses parent directory
- * - Argument is a non-directory file → error
- * - Directory doesn't exist + mustExist false → auto-creates it
- * - Directory doesn't exist + mustExist true → error
- * - facetMustExist true but no facet.json → error
- */
-export async function resolveTargetDir(arg: string | undefined, opts: ResolveOptions): Promise<ResolveResult> {
-  const display = arg || '.'
-
-  // No argument → current directory
-  if (!arg) {
-    const dir = process.cwd()
-
-    if (opts.facetMustExist) {
-      const manifestExists = await Bun.file(join(dir, FACET_MANIFEST_FILE)).exists()
-      if (!manifestExists) {
-        return { ok: false, message: `No ${FACET_MANIFEST_FILE} found in ${display}` }
-      }
-    }
-
-    return { ok: true, dir, display }
-  }
-
-  // Pointing to facet.json directly → use parent directory
-  if (arg === FACET_MANIFEST_FILE || arg.endsWith(`/${FACET_MANIFEST_FILE}`)) {
-    const dir = resolve(dirname(arg))
-
-    const dirStat = await stat(dir).catch(() => null)
-    if (!dirStat?.isDirectory()) {
-      return { ok: false, message: `Directory does not exist: ${dirname(arg)}` }
-    }
-
-    if (opts.facetMustExist) {
-      const manifestExists = await Bun.file(join(dir, FACET_MANIFEST_FILE)).exists()
-      if (!manifestExists) {
-        return { ok: false, message: `No ${FACET_MANIFEST_FILE} found in ${display}` }
-      }
-    }
-
-    return { ok: true, dir, display: dirname(arg) || '.' }
-  }
-
-  // Check if the path exists
-  const pathStat = await stat(arg).catch(() => null)
-
-  // Path exists but is a file, not a directory
-  if (pathStat && !pathStat.isDirectory()) {
-    return { ok: false, message: `Expected a directory, not a file: ${arg}` }
-  }
-
-  // Path doesn't exist
-  if (!pathStat) {
-    if (opts.mustExist) {
-      return { ok: false, message: `Directory does not exist: ${arg}` }
-    }
-
-    // Auto-create for commands that allow it (e.g., create)
-    await mkdir(arg, { recursive: true })
-  }
-
-  const dir = resolve(arg)
-
-  if (opts.facetMustExist) {
-    const manifestExists = await Bun.file(join(dir, FACET_MANIFEST_FILE)).exists()
-    if (!manifestExists) {
-      return { ok: false, message: `No ${FACET_MANIFEST_FILE} found in ${display}` }
-    }
-  }
-
-  return { ok: true, dir, display }
-}

package/src/commands.ts

@@ -1,40 +0,0 @@
-import { buildCommand } from './commands/build.ts'
-import { createCommand } from './commands/create/index.ts'
-import { editCommand } from './commands/edit/index.ts'
-
-export type FlagDef = {
-  type: 'boolean' | 'string'
-  description: string
-}
-
-export type Command = {
-  name: string
-  description: string
-  usage?: string
-  flags?: Record<string, FlagDef>
-  run: (args: string[], flags: Record<string, unknown>) => Promise<number>
-}
-
-function stubCommand(name: string, description: string): Command {
-  return {
-    name,
-    description,
-    run: async (_args, _flags) => {
-      console.log(`"${name}" is not yet implemented.`)
-      return 0
-    },
-  }
-}
-
-export const commands: Record<string, Command> = {
-  add: stubCommand('add', 'Add a facet to the project'),
-  build: buildCommand,
-  create: createCommand,
-  edit: editCommand,
-  info: stubCommand('info', 'Show information about a facet'),
-  install: stubCommand('install', 'Install all facets from the lockfile'),
-  list: stubCommand('list', 'List installed facets'),
-  publish: stubCommand('publish', 'Publish a facet to the registry'),
-  remove: stubCommand('remove', 'Remove a facet from the project'),
-  upgrade: stubCommand('upgrade', 'Upgrade installed facets'),
-}