@dot-agent/cli 1.0.1 → 1.0.3

package/src/commands/unpack.ts

@@ -1,79 +0,0 @@
-// Copyright 2026 Danilo Borges
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { mkdir, writeFile, stat } from 'fs/promises'
-import { join } from 'path'
-import { createHash } from 'crypto'
-import { UnpackOptions, UnpackResult } from '../types.js'
-import { readZip, validateZipBomb, validateMagicBytes, extractFiles } from '../core/zip.js'
-import { parseAboutme } from '../core/envelope.js'
-
-export async function unpack(options: UnpackOptions): Promise<UnpackResult> {
-  const { file, out, force = false } = options
-
-  // Validate magic bytes
-  await validateMagicBytes(file)
-
-  // Validate ZIP bomb
-  await validateZipBomb(file)
-
-  // Load ZIP
-  const zip = await readZip(file)
-
-  // Read aboutme.json
-  const aboutmeFile = zip.file('.agent/aboutme.json')
-  if (!aboutmeFile) {
-    throw new Error('Missing .agent/aboutme.json in ZIP')
-  }
-
-  const aboutmeText = await aboutmeFile.async('text')
-  const aboutme = parseAboutme(JSON.parse(aboutmeText))
-
-  // Extract output directory
-  const outDir = out || `./${aboutme.name}`
-
-  // Check if directory exists
-  try {
-    await stat(outDir)
-    if (!force) {
-      throw new Error(`Output directory already exists: ${outDir}. Use --force to overwrite.`)
-    }
-  } catch (err: any) {
-    if (err.code !== 'ENOENT') throw err
-  }
-
-  // Extract all files from root
-  const files = await extractFiles(zip)
-  await mkdir(outDir, { recursive: true })
-
-  const extractedFiles: string[] = []
-
-  for (const [path, content] of files) {
-    if (path.startsWith('.agent/')) continue
-
-    const fullPath = join(outDir, path)
-    const dir = fullPath.substring(0, fullPath.lastIndexOf('/'))
-
-    await mkdir(dir, { recursive: true })
-    await writeFile(fullPath, content)
-    extractedFiles.push(path)
-  }
-
-  return {
-    dir: outDir,
-    id: aboutme.id,
-    files: extractedFiles,
-    aboutme,
-  }
-}

package/src/core/envelope.ts

@@ -1,83 +0,0 @@
-// Copyright 2026 Danilo Borges
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-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,55 +0,0 @@
-// Copyright 2026 Danilo Borges
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-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,216 +0,0 @@
-// Copyright 2026 Danilo Borges
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-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,60 +0,0 @@
-// Copyright 2026 Danilo Borges
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-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,90 +0,0 @@
-// Copyright 2026 Danilo Borges
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-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,36 +0,0 @@
-// Copyright 2026 Danilo Borges
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-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,35 +0,0 @@
-// Copyright 2026 Danilo Borges
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-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>
-}