@dot-agent/cli 1.0.0 → 1.0.2

package/src/core/envelope.ts

@@ -1,69 +0,0 @@
-import { AboutMe, Integrity, Skill } from '../types.js'
-
-export function parseAboutme(json: any): AboutMe {
-  if (!json.schemaVersion) throw new Error('Missing schemaVersion in aboutme.json')
-  if (!json.id) throw new Error('Missing id in aboutme.json')
-  if (!json.name) throw new Error('Missing name in aboutme.json')
-  if (!json.description) throw new Error('Missing description in aboutme.json')
-  if (!json.version) throw new Error('Missing version in aboutme.json')
-  if (!json.domain) throw new Error('Missing domain in aboutme.json')
-  if (!json.license) throw new Error('Missing license in aboutme.json')
-  if (!json.persona) throw new Error('Missing persona in aboutme.json')
-  if (!json.compiler) throw new Error('Missing compiler in aboutme.json')
-  if (!Array.isArray(json.skills)) throw new Error('Missing skills array in aboutme.json')
-  if (!Array.isArray(json.requires)) throw new Error('Missing requires array in aboutme.json')
-  if (!json.integrity) throw new Error('Missing integrity in aboutme.json')
-
-  return {
-    schemaVersion: json.schemaVersion,
-    id: json.id,
-    name: json.name,
-    description: json.description,
-    version: json.version,
-    domain: json.domain,
-    license: json.license,
-    persona: json.persona,
-    compiler: json.compiler,
-    commit: json.commit,
-    skills: json.skills,
-    requires: json.requires,
-    integrity: json.integrity,
-  }
-}
-
-export interface BuildAboutmeOptions {
-  id: string
-  name: string
-  description: string
-  version: string
-  domain: string
-  license?: string
-  persona: string
-  compiler: string
-  commit?: string
-  skills?: Skill[]
-  requires?: string[]
-  integrity: Integrity
-}
-
-export function buildAboutme(opts: BuildAboutmeOptions): AboutMe {
-  return {
-    schemaVersion: 'dot-agent/1.0',
-    id: opts.id,
-    name: opts.name,
-    description: opts.description,
-    version: opts.version,
-    domain: opts.domain,
-    license: opts.license || 'Apache-2.0',
-    persona: opts.persona,
-    compiler: opts.compiler,
-    commit: opts.commit,
-    skills: opts.skills || [],
-    requires: opts.requires || [],
-    integrity: opts.integrity,
-  }
-}
-
-export function aboutmeToJson(aboutme: AboutMe): string {
-  return JSON.stringify(aboutme, null, 2)
-}

package/src/core/id.ts

@@ -1,41 +0,0 @@
-export interface IdParts {
-  namespace: string
-  name: string
-  version: string
-  digest: string
-}
-
-export function parseId(id: string): IdParts {
-  const match = id.match(/^(.+)\/(.+):(.+)~(.+)$/)
-  if (!match) {
-    throw new Error(`Invalid agent ID format: ${id}. Expected: namespace/name:version~digest`)
-  }
-  const [, namespace, name, version, digest] = match
-  return { namespace, name, version, digest }
-}
-
-export function buildId(parts: IdParts): string {
-  const { namespace, name, version, digest } = parts
-  if (!namespace || !name || !version || !digest) {
-    throw new Error('Missing required ID parts: namespace, name, version, digest')
-  }
-  return `${namespace}/${name}:${version}~${digest}`
-}
-
-export function extractDigest(id: string): string {
-  try {
-    const parts = parseId(id)
-    return parts.digest
-  } catch {
-    return ''
-  }
-}
-
-export function extractName(id: string): string {
-  try {
-    const parts = parseId(id)
-    return parts.name
-  } catch {
-    return ''
-  }
-}

package/src/core/lint.ts

@@ -1,202 +0,0 @@
-import { createRequire } from 'module'
-import { Parser, Language } from 'web-tree-sitter'
-import { AgentDSLKernel, init as initKernel } from '@dot-agent/kernel-dsl'
-import { LintMessage } from '../types.js'
-
-const require = createRequire(import.meta.url)
-const { agentWasmPath, behaviorWasmPath } = require('@dot-agent/tree-sitter')
-
-declare module '@dot-agent/tree-sitter' {
-  export const agentWasmPath: string
-  export const behaviorWasmPath: string
-}
-
-let _initialized = false
-let _agentParser: Parser
-let _behaviorParser: Parser
-let _agentLang: any
-let _behaviorLang: any
-
-async function ensureWasmInit() {
-  if (_initialized) return
-
-  try {
-    await Parser.init()
-  } catch (err) {
-    throw err
-  }
-
-  _agentParser = new Parser()
-  _behaviorParser = new Parser()
-
-  try {
-    _agentLang = await Language.load(agentWasmPath)
-    _behaviorLang = await Language.load(behaviorWasmPath)
-  } catch (err) {
-    throw err
-  }
-
-  try {
-    await initKernel()
-  } catch (err) {
-    // Silently fail - kernel might not be available in all environments
-    // We can continue with tree-sitter only for syntax checking
-  }
-
-  _initialized = true
-}
-
-function collectSyntaxErrors(node: Parser.SyntaxNode): Parser.SyntaxNode[] {
-  const errors: Parser.SyntaxNode[] = []
-  if (node.isError || node.isMissing) errors.push(node)
-  for (const child of node.children) {
-    errors.push(...collectSyntaxErrors(child))
-  }
-  return errors
-}
-
-function getLineCol(node: Parser.SyntaxNode): { line: number; col: number } {
-  return { line: node.startPosition.row + 1, col: node.startPosition.column + 1 }
-}
-
-export async function lintDescription(text: string): Promise<LintMessage[]> {
-  await ensureWasmInit()
-
-  _agentParser.setLanguage(_agentLang)
-  const tree = _agentParser.parse(text)
-  const messages: LintMessage[] = []
-
-  const syntaxErrors = collectSyntaxErrors(tree.rootNode)
-  if (syntaxErrors.length > 0) {
-    for (const error of syntaxErrors) {
-      const { line, col } = getLineCol(error)
-      messages.push({
-        file: 'agent.description',
-        line,
-        col,
-        severity: 'error',
-        code: 'E004',
-        message: 'Syntax error in description',
-      })
-    }
-  }
-
-  const walk = (node: Parser.SyntaxNode) => {
-    if (node.type === 'domain_declaration' && node.childCount > 0) {
-      const valueNode = node.child(node.childCount - 1)
-      if (valueNode && valueNode.text === 'example.com') {
-        const { line, col } = getLineCol(valueNode)
-        messages.push({
-          file: 'agent.description',
-          line,
-          col,
-          severity: 'warning',
-          code: 'W003',
-          message: 'domain still has default value "example.com"',
-        })
-      }
-    }
-    for (const child of node.children) walk(child)
-  }
-  walk(tree.rootNode)
-
-  return messages
-}
-
-export async function lintBehavior(text: string): Promise<LintMessage[]> {
-  await ensureWasmInit()
-
-  _behaviorParser.setLanguage(_behaviorLang)
-  const tree = _behaviorParser.parse(text)
-  const messages: LintMessage[] = []
-
-  const syntaxErrors = collectSyntaxErrors(tree.rootNode)
-  if (syntaxErrors.length > 0) {
-    for (const error of syntaxErrors) {
-      const { line, col } = getLineCol(error)
-      messages.push({
-        file: 'agent.behavior',
-        line,
-        col,
-        severity: 'error',
-        code: 'E004',
-        message: 'Syntax error in behavior DSL',
-      })
-    }
-  }
-
-  const walk = (node: Parser.SyntaxNode) => {
-    if (node.type === 'text_block') {
-      if (node.text.length > 280) {
-        const { line, col } = getLineCol(node)
-        messages.push({
-          file: 'agent.behavior',
-          line,
-          col,
-          severity: 'warning',
-          code: 'W002',
-          message: `Text block exceeds 280 characters (${node.text.length})`,
-        })
-      }
-    }
-    for (const child of node.children) walk(child)
-  }
-  walk(tree.rootNode)
-
-  try {
-    const kernel = new AgentDSLKernel()
-    try {
-      const effects = kernel.load_behavior(text)
-
-      if (Array.isArray(effects)) {
-        for (const effect of effects) {
-          if (effect.type === 'parse_error') {
-            messages.push({
-              file: 'agent.behavior',
-              line: 1,
-              col: 1,
-              severity: 'error',
-              code: 'E006',
-              message: `Parse error: ${effect.message}`,
-            })
-          }
-        }
-      }
-
-      const graph = kernel.get_graph()
-      if (graph?.states) {
-        for (const stateName of Object.keys(graph.states)) {
-          const state = graph.states[stateName]
-          const hasIncoming = graph.transitions?.some((t: any) => t.to === stateName)
-          const hasOutgoing = graph.transitions?.some((t: any) => t.from === stateName)
-
-          if (!hasIncoming && !hasOutgoing && stateName !== graph.current) {
-            messages.push({
-              file: 'agent.behavior',
-              line: 1,
-              col: 1,
-              severity: 'warning',
-              code: 'W001',
-              message: `state "${stateName}" has no transitions`,
-            })
-          }
-        }
-      }
-    } catch (kernelErr: any) {
-      // Kernel load failed - skip semantic checks, syntax errors already caught by tree-sitter
-    }
-  } catch (err: any) {
-    // Could not initialize kernel - skip semantic checks
-  }
-
-  return messages
-}
-
-export async function createLinter() {
-  await ensureWasmInit()
-
-  return {
-    lintDescription,
-    lintBehavior,
-  }
-}

package/src/core/types.ts

@@ -1,46 +0,0 @@
-import { ParsedDescription } from '../types.js'
-
-export function buildTypesJson(description: ParsedDescription): object | null {
-  const capabilities = description.capabilities || []
-
-  const publicCapabilities = capabilities.filter((cap: any) => cap.public !== false)
-  if (publicCapabilities.length === 0) return null
-
-  const types: any = {
-    input: [],
-    output: [],
-    $defs: {},
-  }
-
-  for (const cap of publicCapabilities) {
-    if (cap.inputType) {
-      if (typeof cap.inputType === 'string' && cap.inputType.startsWith('std.')) {
-        types.input.push({
-          $ref: `https://dot-agent.dev/schema/std/v1/${cap.inputType.replace('std.', '')}.json`,
-        })
-      } else if (typeof cap.inputType === 'object') {
-        const typeName = cap.name ? `${cap.name}Input` : 'Input'
-        types.input.push({ $ref: `#/$defs/${typeName}` })
-        types.$defs[typeName] = cap.inputType
-      }
-    }
-
-    if (cap.outputType) {
-      if (typeof cap.outputType === 'string' && cap.outputType.startsWith('std.')) {
-        types.output.push({
-          $ref: `https://dot-agent.dev/schema/std/v1/${cap.outputType.replace('std.', '')}.json`,
-        })
-      } else if (typeof cap.outputType === 'object') {
-        const typeName = cap.name ? `${cap.name}Output` : 'Output'
-        types.output.push({ $ref: `#/$defs/${typeName}` })
-        types.$defs[typeName] = cap.outputType
-      }
-    }
-  }
-
-  if (Object.keys(types.$defs).length === 0) delete types.$defs
-
-  if (types.input.length === 0 && types.output.length === 0) return null
-
-  return types
-}

package/src/core/zip.ts

@@ -1,76 +0,0 @@
-import JSZip from 'jszip'
-import { readFile, writeFile } from 'fs/promises'
-
-const MAX_ZIP_SIZE = 500 * 1024 * 1024
-const MAX_COMPRESSION_RATIO = 100
-
-export async function readZip(filePath: string): Promise<JSZip> {
-  const data = await readFile(filePath)
-  return JSZip.loadAsync(data)
-}
-
-export async function validateZipBomb(filePath: string): Promise<boolean> {
-  const data = await readFile(filePath)
-  const zip = await JSZip.loadAsync(data)
-
-  let totalUncompressed = 0
-  zip.forEach((relativePath, file) => {
-    if (!file.dir) {
-      totalUncompressed += file._data?.uncompressedSize || 0
-    }
-  })
-
-  const compressedSize = data.length
-  const ratio = totalUncompressed / compressedSize
-
-  if (totalUncompressed > MAX_ZIP_SIZE) {
-    throw new Error(`ZIP uncompressed size exceeds 500MB limit: ${totalUncompressed}`)
-  }
-
-  if (ratio > MAX_COMPRESSION_RATIO) {
-    throw new Error(`ZIP compression ratio exceeds 100x limit: ${ratio.toFixed(1)}x`)
-  }
-
-  return true
-}
-
-export async function extractFiles(
-  zip: JSZip,
-  filter?: string[]
-): Promise<Map<string, string>> {
-  const files = new Map<string, string>()
-
-  const promises: Promise<void>[] = []
-  zip.forEach((relativePath, file) => {
-    if (file.dir) return
-    if (filter && !filter.some(f => relativePath.startsWith(f))) return
-
-    promises.push(
-      file.async('text').then(content => {
-        files.set(relativePath, content)
-      })
-    )
-  })
-
-  await Promise.all(promises)
-  return files
-}
-
-export function createZip(): JSZip {
-  return new JSZip()
-}
-
-export async function writeZip(zip: JSZip, outPath: string): Promise<void> {
-  const data = await zip.generateAsync({ type: 'arraybuffer' })
-  await writeFile(outPath, Buffer.from(data))
-}
-
-export async function validateMagicBytes(filePath: string): Promise<boolean> {
-  const data = await readFile(filePath)
-  const magicBytes = data.subarray(0, 4)
-  const isZip = magicBytes[0] === 0x50 && magicBytes[1] === 0x4b && magicBytes[2] === 0x03 && magicBytes[3] === 0x04
-  if (!isZip) {
-    throw new Error('File is not a valid ZIP (invalid magic bytes)')
-  }
-  return true
-}

package/src/index.ts

@@ -1,22 +0,0 @@
-export { init } from './commands/init.js'
-export { pack } from './commands/pack.js'
-export { unpack } from './commands/unpack.js'
-export { run } from './commands/run.js'
-
-export type {
-  InitOptions,
-  InitResult,
-  PackOptions,
-  PackResult,
-  UnpackOptions,
-  UnpackResult,
-  RunOptions,
-  AgentContext,
-  FileEntry,
-  LintMessage,
-  AboutMe,
-  Skill,
-  Integrity,
-  ParsedDescription,
-  ParsedBehavior,
-} from './types.js'

package/src/types.kernel-dsl.d.ts

@@ -1,21 +0,0 @@
-declare module '@dot-agent/kernel-dsl' {
-  export class AgentDSLKernel {
-    constructor()
-    get_current_state(): string
-    get_graph(): any
-    get_memory(): any
-    get_valid_intents(): string[]
-    load_behavior(text: string): any
-    observe(callback: Function): void
-    send_complete(): any
-    send_event(event: string): any
-    send_failed(): any
-    send_fallback(): any
-    send_intent(intent: string): any
-    send_offtopic(): any
-    tick_prompt(): any
-    free(): void
-  }
-
-  export function init(): Promise<void>
-}

package/src/types.ts

@@ -1,114 +0,0 @@
-export interface LintMessage {
-  file: string
-  line: number
-  col: number
-  severity: 'error' | 'warning'
-  code: string
-  message: string
-}
-
-export interface InitOptions {
-  name?: string
-  domain?: string
-  dir?: string
-}
-
-export interface InitResult {
-  dir: string
-  files: string[]
-}
-
-export interface PackOptions {
-  dir?: string
-  out?: string
-  commit?: string
-  version?: string
-}
-
-export interface PackResult {
-  path: string
-  id: string
-  warnings: LintMessage[]
-}
-
-export interface UnpackOptions {
-  file: string
-  out?: string
-  force?: boolean
-}
-
-export interface UnpackResult {
-  dir: string
-  id: string
-  files: string[]
-  aboutme: AboutMe
-}
-
-export interface RunOptions {
-  source: string
-}
-
-export interface FileEntry {
-  path: string
-  content: string
-}
-
-export interface AgentContext {
-  id: string
-  description: any
-  behavior: any
-  kernel: any
-  files: {
-    soul?: string
-    guides: FileEntry[]
-    knowledge: FileEntry[]
-    behaviors: FileEntry[]
-  }
-  aboutme: AboutMe
-  on(event: string, listener: (...args: any[]) => void): this
-  emit(event: string, ...args: any[]): boolean
-}
-
-export interface Skill {
-  id: string
-  description: string
-}
-
-export interface Integrity {
-  sha256: string
-  types?: string
-  files?: string
-}
-
-export interface AboutMe {
-  schemaVersion: string
-  id: string
-  name: string
-  description: string
-  version: string
-  domain: string
-  license: string
-  persona: string
-  compiler: string
-  commit?: string
-  skills: Skill[]
-  requires: string[]
-  integrity: Integrity
-}
-
-export interface ParsedDescription {
-  domain: string
-  name: string
-  version: string
-  description: string
-  capabilities: Array<{
-    name: string
-    type?: string
-    description: string
-  }>
-  [key: string]: any
-}
-
-export interface ParsedBehavior {
-  [key: string]: any
-}

package/src/types.wts.d.ts

@@ -1,10 +0,0 @@
-declare module 'web-tree-sitter' {
-  export class Parser {
-    static init(): Promise<void>
-    static Language: {
-      load(path: string): Promise<any>
-    }
-    setLanguage(lang: any): void
-    parse(text: string): any
-  }
-}

package/tests/envelope.test.ts

@@ -1,62 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { buildAboutme, parseAboutme, aboutmeToJson } from '../src/core/envelope.js'
-
-describe('envelope', () => {
-  it('builds aboutme.json', () => {
-    const aboutme = buildAboutme({
-      id: 'example.com/test:v1.0~abc123',
-      name: 'Test Agent',
-      description: 'A test agent',
-      version: 'v1.0',
-      domain: 'example.com',
-      persona: 'SOUL.md',
-      compiler: 'dot-agent/1.0.0',
-      integrity: {
-        sha256: 'e3b0c44298fc1c149afbaf8b2b',
-        files: '.agent/files.json',
-      },
-    })
-
-    expect(aboutme.schemaVersion).toBe('dot-agent/1.0')
-    expect(aboutme.id).toBe('example.com/test:v1.0~abc123')
-    expect(aboutme.name).toBe('Test Agent')
-  })
-
-  it('parses aboutme.json', () => {
-    const json = {
-      schemaVersion: 'dot-agent/1.0',
-      id: 'example.com/test:v1.0~abc123',
-      name: 'Test Agent',
-      description: 'A test agent',
-      version: 'v1.0',
-      domain: 'example.com',
-      license: 'Apache-2.0',
-      persona: 'SOUL.md',
-      compiler: 'dot-agent/1.0.0',
-      skills: [],
-      requires: [],
-      integrity: { sha256: 'abc123', files: '.agent/files.json' },
-    }
-
-    const parsed = parseAboutme(json)
-    expect(parsed.name).toBe('Test Agent')
-    expect(parsed.schemaVersion).toBe('dot-agent/1.0')
-  })
-
-  it('converts aboutme to JSON string', () => {
-    const aboutme = buildAboutme({
-      id: 'example.com/test:v1.0~abc123',
-      name: 'Test Agent',
-      description: 'A test agent',
-      version: 'v1.0',
-      domain: 'example.com',
-      persona: 'SOUL.md',
-      compiler: 'dot-agent/1.0.0',
-      integrity: { sha256: 'abc123', files: '.agent/files.json' },
-    })
-
-    const json = aboutmeToJson(aboutme)
-    expect(json).toContain('dot-agent/1.0')
-    expect(json).toContain('Test Agent')
-  })
-})

package/tests/id.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { parseId, buildId } from '../src/core/id.js'
-
-describe('id', () => {
-  it('parses a valid agent ID', () => {
-    const parts = parseId('entelekheia.ai/doctor:v1.0~a1b2c3d')
-    expect(parts.namespace).toBe('entelekheia.ai')
-    expect(parts.name).toBe('doctor')
-    expect(parts.version).toBe('v1.0')
-    expect(parts.digest).toBe('a1b2c3d')
-  })
-
-  it('builds an ID from parts', () => {
-    const id = buildId({
-      namespace: 'entelekheia.ai',
-      name: 'doctor',
-      version: 'v1.0',
-      digest: 'a1b2c3d',
-    })
-    expect(id).toBe('entelekheia.ai/doctor:v1.0~a1b2c3d')
-  })
-
-  it('throws on invalid ID format', () => {
-    expect(() => parseId('invalid')).toThrow()
-  })
-})