openhermes 4.0.1 → 4.3.0

package/lib/{harness-resolver.mjs → harness-resolver.ts}

@@ -1,6 +1,5 @@
 // Shared harness directory resolver — canonical implementation.
-// Extracted from bootstrap.mjs to eliminate DRY violation with goal-tracker.mjs.
-// Both consumers import from here.
+// Extracted from bootstrap.ts. Both bootstrap.ts and tests import from here.
 
 import path from "node:path"
 import fs from "node:fs"
@@ -9,14 +8,14 @@ import { fileURLToPath } from "node:url"
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const PKG_DIR = path.resolve(__dirname, "..")
 
-const REQUIRED_HARNESS_FILES = [
+const REQUIRED_HARNESS_FILES: ReadonlyArray<readonly string[]> = [
   ["codex", "CONSTITUTION.md"],
   ["instructions", "RUNTIME.md"],
-  ["skills", "oh-plan", "SKILL.md"],
+  ["skills", "oh-planner", "SKILL.md"],
 ]
 
-function ancestorDirs(start, limit = 6) {
-  const dirs = []
+function ancestorDirs(start: string, limit = 6): string[] {
+  const dirs: string[] = []
   let current = path.resolve(start)
   for (let i = 0; i < limit; i++) {
     dirs.push(current)
@@ -27,7 +26,7 @@ function ancestorDirs(start, limit = 6) {
   return dirs
 }
 
-function buildHarnessCandidates(currentDir, execPath, cwd) {
+function buildHarnessCandidates(currentDir: string, execPath: string, cwd: string): string[] {
   const roots = [path.resolve(currentDir, "harness")]
   const seen = new Set(roots)
 
@@ -50,7 +49,7 @@ function buildHarnessCandidates(currentDir, execPath, cwd) {
   return roots
 }
 
-function hasRequiredHarnessFiles(root) {
+function hasRequiredHarnessFiles(root: string): boolean {
   return REQUIRED_HARNESS_FILES.every(parts => fs.existsSync(path.join(root, ...parts)))
 }
 
@@ -59,7 +58,12 @@ export function resolveHarnessRoot({
   execPath = process.execPath,
   cwd = process.cwd(),
   candidateRoots,
-} = {}) {
+}: {
+  currentDir?: string
+  execPath?: string
+  cwd?: string
+  candidateRoots?: string[]
+} = {}): string {
   const roots = candidateRoots ?? buildHarnessCandidates(currentDir, execPath, cwd)
   for (const root of roots) {
     if (hasRequiredHarnessFiles(root)) return root
@@ -67,11 +71,11 @@ export function resolveHarnessRoot({
   return path.resolve(currentDir, "harness")
 }
 
-let _harnessDir
+let _harnessDir: string | undefined
 
-export function setHarnessRootForTest(dir) { _harnessDir = dir }
+export function setHarnessRootForTest(dir: string | undefined): void { _harnessDir = dir }
 
-export function getHarnessDir() {
+export function getHarnessDir(): string {
   if (!_harnessDir) _harnessDir = resolveHarnessRoot()
   return _harnessDir
 }

package/lib/logger.ts

@@ -0,0 +1,75 @@
+import path from "node:path"
+import os from "node:os"
+import fs from "node:fs"
+
+export interface Logger {
+  debug: (...args: unknown[]) => void
+  info: (...args: unknown[]) => void
+  warn: (...args: unknown[]) => void
+  error: (...args: unknown[]) => void
+}
+
+const LEVELS: Record<string, number> = { debug: 0, info: 1, warn: 2, error: 3 }
+
+function resolveLevel(levelName: string | undefined): number | undefined {
+  if (!levelName) return undefined
+  return LEVELS[levelName as keyof typeof LEVELS]
+}
+
+const CURRENT_LEVEL = resolveLevel(process.env.OPENCODE_LOG_LEVEL?.trim().toLowerCase()) ?? (process.env.OPENHERMES_LOG_LEVEL?.trim().toLowerCase() === "debug" ? LEVELS.debug : LEVELS.warn)
+
+const LOG_DIR = path.join(os.homedir(), ".local", "share", "opencode", "log")
+const LOG_FILE = path.join(LOG_DIR, "openhermes.log")
+
+function ts(): string {
+  const d = new Date()
+  return `${d.getFullYear()}-${(d.getMonth()+1).toString().padStart(2,"0")}-${d.getDate().toString().padStart(2,"0")} ${d.getHours().toString().padStart(2,"0")}:${d.getMinutes().toString().padStart(2,"0")}:${d.getSeconds().toString().padStart(2,"0")}.${d.getMilliseconds().toString().padStart(3,"0")}`
+}
+
+function formatArgs(args: unknown[]): string {
+  return args.map(a => {
+    if (a === null) return "null"
+    if (a === undefined) return "undefined"
+    if (typeof a === "object") {
+      try { return (a as Error)?.message || JSON.stringify(a) } catch { return String(a) }
+    }
+    return String(a)
+  }).join(" ")
+}
+
+function shouldLog(levelName: string): boolean {
+  return LEVELS[levelName] >= CURRENT_LEVEL
+}
+
+let _fd: number | null = null
+function getFd(): number {
+  if (_fd) return _fd
+  try {
+    fs.mkdirSync(LOG_DIR, { recursive: true })
+    _fd = fs.openSync(LOG_FILE, "a")
+  } catch {
+    _fd = -1
+  }
+  return _fd
+}
+
+export function createLogger(name: string): Logger {
+  const prefix = `[openhermes:${name}]`
+
+  function emit(levelName: string, ...args: unknown[]): void {
+    if (!shouldLog(levelName)) return
+    const fd = getFd()
+    if (fd < 0) return
+    const line = `${ts()} ${prefix} [${levelName.toUpperCase()}] ${formatArgs(args)}\n`
+    try { fs.writeSync(fd, line) } catch {}
+  }
+
+  return {
+    debug: (...args: unknown[]) => emit("debug", ...args),
+    info: (...args: unknown[]) => emit("info", ...args),
+    warn: (...args: unknown[]) => emit("warn", ...args),
+    error: (...args: unknown[]) => emit("error", ...args),
+  }
+}
+
+export const rootLogger: Logger = createLogger("root")

package/package.json

@@ -1,24 +1,27 @@
 {
   "name": "openhermes",
-  "version": "4.0.1",
-  "description": "OpenCode-native skills, commands, and rules orchestration for OpenHermes.",
+  "version": "4.3.0",
+  "description": "OpenCode-native orchestration for packaged skills, commands, and agents.",
   "type": "module",
   "license": "MIT",
-  "main": "./index.mjs",
+  "engines": {
+    "bun": ">=1.0"
+  },
+  "main": "./index.ts",
   "dependencies": {
     "@opencode-ai/plugin": "1.14.46"
   },
   "exports": {
-    ".": "./index.mjs",
-    "./bootstrap": "./bootstrap.mjs"
+    ".": "./index.ts",
+    "./bootstrap": "./bootstrap.ts"
   },
   "files": [
-    "index.mjs",
-    "bootstrap.mjs",
+    "index.ts",
+    "bootstrap.ts",
+    "tsconfig.json",
     "ETHOS.md",
     "CONTEXT.md",
     "lib/",
-    "test/",
     "harness/codex/",
     "harness/instructions/",
     "harness/skills/",
@@ -26,7 +29,7 @@
     "harness/agents/"
   ],
   "scripts": {
-    "test": "node --test test/*.test.mjs"
+    "test": "bun test test/*.test.ts"
   },
   "keywords": [
     "opencode",
@@ -45,5 +48,8 @@
     "url": "https://github.com/nathwn12/openhermes/issues"
   },
   "homepage": "https://github.com/nathwn12/openhermes#readme",
-  "author": "nathwn12"
+  "author": "nathwn12",
+  "devDependencies": {
+    "@types/node": "^25.8.0"
+  }
 }

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowImportingTsExtensions": true,
+    "types": ["node"]
+  },
+  "include": ["index.ts", "bootstrap.ts", "lib/**/*.ts", "test/**/*.ts"]
+}

package/bootstrap.mjs

@@ -1,174 +0,0 @@
-import path from "node:path"
-import fs from "node:fs"
-import { fileURLToPath } from "node:url"
-import { createLogger } from "./lib/logger.mjs"
-import { getHarnessDir, setHarnessRootForTest, resolveHarnessRoot } from "./lib/harness-resolver.mjs"
-
-const log = createLogger("bootstrap")
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const BOOTSTRAP_MARKER = "OPENHERMES_BOOTSTRAP"
-const OPENHERMES_AGENT = "OpenHermes"
-
-export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir }
-
-function parseFrontmatter(raw) {
-  const frontmatter = {}
-  if (!raw) return frontmatter
-  for (const line of raw.split(/\r?\n/)) {
-    const idx = line.indexOf(":")
-    if (idx < 0) continue
-    const key = line.slice(0, idx).trim()
-    const value = line.slice(idx + 1).trim().replace(/^['"]|['"]$/g, "")
-    if (key) frontmatter[key] = value
-  }
-  return frontmatter
-}
-
-function readMarkdownDocument(filePath) {
-  if (!fs.existsSync(filePath)) return null
-  const source = fs.readFileSync(filePath, "utf8")
-  const match = source.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
-  const frontmatter = parseFrontmatter(match?.[1] ?? "")
-  const body = (match ? match[2] : source).trim()
-  return { frontmatter, body }
-}
-
-function readMarkdownDirectory(dir) {
-  if (!fs.existsSync(dir)) return []
-  return fs.readdirSync(dir)
-    .filter(name => name.endsWith(".md") && name.toLowerCase() !== "readme.md")
-    .sort((a, b) => a.localeCompare(b))
-    .map(name => {
-      const filePath = path.join(dir, name)
-      const document = readMarkdownDocument(filePath)
-      return document ? { name: path.basename(name, ".md"), ...document } : null
-    })
-    .filter(Boolean)
-}
-
-function commandDefinitions(dir) {
-  const commands = {}
-  for (const doc of readMarkdownDirectory(dir)) {
-    const command = {
-      description: doc.frontmatter.description || `OpenHermes command ${doc.name}`,
-      template: doc.body,
-    }
-    if (doc.frontmatter.agent) command.agent = doc.frontmatter.agent
-    if (doc.frontmatter.model) command.model = doc.frontmatter.model
-    if (doc.frontmatter.subtask) command.subtask = doc.frontmatter.subtask === "true"
-    commands[doc.name] = command
-  }
-  return commands
-}
-
-function agentDefinitions(dir) {
-  const agents = {}
-  for (const doc of readMarkdownDirectory(dir)) {
-    const name = doc.name === "openhermes" ? OPENHERMES_AGENT : doc.name
-    agents[name] = {
-      description: doc.frontmatter.description || (name === OPENHERMES_AGENT ? "OpenHermes primary orchestrator" : `OpenHermes agent ${name}`),
-      mode: doc.frontmatter.mode || (name === OPENHERMES_AGENT ? "primary" : "subagent"),
-      prompt: doc.body,
-    }
-  }
-  return agents
-}
-
-function uniqueStrings(existing = [], additions = []) {
-  const seen = new Set(existing.filter(Boolean))
-  const merged = [...existing]
-  for (const item of additions) {
-    if (!item || seen.has(item)) continue
-    seen.add(item)
-    merged.push(item)
-  }
-  return merged
-}
-
-function readText(filePath) {
-  return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : ""
-}
-
-function buildBootstrapContent(hDir) {
-  const parts = [
-    `<${BOOTSTRAP_MARKER}>`,
-    `You are OpenHermes.`,
-    `OpenHermes is OpenCode-native: load skills on demand, prefer subagents for substantive work, and keep the surface small.`,
-    `Durable state is removed for now. Do not invent a persistence layer unless the user explicitly asks for one later.`,
-  ]
-
-  const constitution = readText(path.join(hDir, "codex", "CONSTITUTION.md"))
-  const runtime = readText(path.join(hDir, "instructions", "RUNTIME.md"))
-  const context = readText(path.join(__dirname, "CONTEXT.md"))
-  const ethos = readText(path.join(__dirname, "ETHOS.md"))
-
-  if (constitution) parts.push(`<CONSTITUTION>\n${constitution}\n</CONSTITUTION>`)
-  if (runtime) parts.push(`<RUNTIME>\n${runtime}\n</RUNTIME>`)
-  if (context) parts.push(`<CONTEXT>\n${context}\n</CONTEXT>`)
-  if (ethos) parts.push(`<ETHOS>\n${ethos}\n</ETHOS>`)
-  parts.push(`</${BOOTSTRAP_MARKER}>`)
-
-  return parts.join("\n\n")
-}
-
-export const BootstrapPlugin = async () => {
-  const hDir = getHarnessDir()
-  const skillsDir = path.join(hDir, "skills")
-  const commandsDir = path.join(hDir, "commands")
-  const agentsDir = path.join(hDir, "agents")
-  const bootstrapContent = buildBootstrapContent(hDir)
-
-  return {
-    config: async (config) => {
-      config.skills = config.skills || {}
-      config.skills.paths = uniqueStrings(config.skills.paths || [], [skillsDir])
-
-      config.command = { ...(config.command ?? {}), ...commandDefinitions(commandsDir) }
-
-      const loadedAgents = agentDefinitions(agentsDir)
-      const openHermesAgent = loadedAgents[OPENHERMES_AGENT] ?? {
-        description: "OpenHermes primary orchestrator",
-        mode: "primary",
-        prompt: "You are OpenHermes.",
-      }
-
-      config.agent = {
-        ...(config.agent ?? {}),
-        ...loadedAgents,
-        [OPENHERMES_AGENT]: {
-          ...openHermesAgent,
-          description: openHermesAgent.description || "OpenHermes primary orchestrator",
-          mode: "primary",
-          permission: {
-            bash: { "*": "allow" },
-            edit: "allow",
-            read: "allow",
-            task: { "*": "allow" },
-          },
-        },
-      }
-
-      config.default_agent = OPENHERMES_AGENT
-
-      config.instructions = uniqueStrings(config.instructions || [], [
-        path.join(hDir, "codex", "CONSTITUTION.md"),
-        path.join(hDir, "instructions", "RUNTIME.md"),
-        path.join(__dirname, "CONTEXT.md"),
-        path.join(__dirname, "ETHOS.md"),
-      ])
-    },
-
-    "experimental.chat.messages.transform": async (_input, output) => {
-      try {
-        if (!output.messages?.length) return
-        const firstUser = output.messages.find(m => m?.info?.role === "user")
-        if (!firstUser?.parts?.length) return
-        if (firstUser.parts.some(p => p.text?.includes(BOOTSTRAP_MARKER))) return
-        const ref = firstUser.parts[0]
-        firstUser.parts.unshift({ ...ref, type: "text", text: bootstrapContent })
-      } catch (err) {
-        log.error("transform error:", err?.message)
-      }
-    },
-  }
-}

package/harness/instructions/CONVENTIONS.md

@@ -1,206 +0,0 @@
-# OpenHermes — Coding Conventions & Operational Guidelines
-
-OpenHermes coding conventions and operational guidelines. Shared baseline for all subagents and skills.
-
-## Security Guidelines (CRITICAL)
-
-### Mandatory Pre-Commit Checks
-
-- [ ] No hardcoded secrets (API keys, passwords, tokens)
-- [ ] All user inputs validated
-- [ ] SQL injection prevention (parameterized queries)
-- [ ] XSS prevention (sanitized output)
-- [ ] CSRF protection enabled
-- [ ] Authentication/authorization verified
-- [ ] Rate limiting on all endpoints
-- [ ] Error messages don't leak sensitive data
-
-### Secret Management
-
-```typescript
-// NEVER: Hardcoded secrets
-const apiKey = "sk-proj-xxxxx"
-
-// ALWAYS: Environment variables
-const apiKey = process.env.OPENAI_API_KEY
-if (!apiKey) throw new Error('OPENAI_API_KEY not configured')
-```
-
-### Security Response Protocol
-
-If security issue found:
-1. STOP immediately
-2. Use `security-reviewer` subagent
-3. Fix CRITICAL issues before continuing
-4. Rotate any exposed secrets
-5. Review entire codebase for similar issues
-
----
-
-## Coding Style
-
-### Immutability (CRITICAL)
-
-ALWAYS create new objects, NEVER mutate:
-
-```javascript
-// WRONG: Mutation
-function updateUser(user, name) {
-  user.name = name; return user
-}
-
-// CORRECT: Immutability
-function updateUser(user, name) {
-  return { ...user, name }
-}
-```
-
-### File Organization
-
-MANY SMALL FILES > FEW LARGE FILES:
-- High cohesion, low coupling
-- 200-400 lines typical, 800 max
-- Extract utilities from large components
-- Organize by feature/domain, not by type
-
-### Error Handling
-
-```typescript
-try {
-  const result = await riskyOperation()
-  return result
-} catch (error) {
-  console.error('Operation failed:', error)
-  throw new Error('Detailed user-friendly message')
-}
-```
-
-### Input Validation
-
-```typescript
-import { z } from 'zod'
-const schema = z.object({
-  email: z.string().email(),
-  age: z.number().int().min(0).max(150)
-})
-const validated = schema.parse(input)
-```
-
-### Code Quality Checklist
-
-Before marking work complete:
-- [ ] Code is readable and well-named
-- [ ] Functions are small (<50 lines)
-- [ ] Files are focused (<800 lines)
-- [ ] No deep nesting (>4 levels)
-- [ ] Proper error handling
-- [ ] No console.log statements
-- [ ] No hardcoded values
-- [ ] No mutation (immutable patterns used)
-
----
-
-## Testing Requirements
-
-### Minimum Test Coverage: 80%
-
-Test Types (ALL required):
-1. **Unit Tests** — Individual functions, utilities, components
-2. **Integration Tests** — API endpoints, database operations
-3. **E2E Tests** — Critical user flows (Playwright)
-
-### TDD Workflow
-
-MANDATORY workflow:
-1. Write test first (RED)
-2. Run test — it should FAIL
-3. Write minimal implementation (GREEN)
-4. Run test — it should PASS
-5. Refactor (IMPROVE)
-6. Verify coverage (80%+)
-
----
-
-## Subagent Orchestration
-
-| Subagent | Purpose | When to Use |
-|----------|---------|-------------|
-| planner | Implementation planning | Complex features, refactoring |
-| architect | System design | Architectural decisions |
-| tdd-guide | Test-driven development | New features, bug fixes |
-| code-reviewer | Code review | After writing code |
-| security-reviewer | Security analysis | Before commits |
-| build-error-resolver | Fix build errors | When build fails |
-| e2e-runner | E2E testing | Critical user flows |
-| refactor-cleaner | Dead code cleanup | Code maintenance |
-| doc-updater | Documentation | Updating docs |
-| docs-lookup | Live doc queries | API questions |
-| review-go | Go code review | Go projects |
-| build-go | Go build errors | Go build failures |
-| review-database | Database optimization | SQL, schema design |
-| review-rust | Rust code review | Rust projects |
-| build-rust | Rust build errors | Rust build failures |
-| review-python | Python code review | Python projects |
-| review-java | Java/Spring review | Java projects |
-| build-java | Java build errors | Java build failures |
-| review-kotlin | Kotlin/Android review | Kotlin projects |
-| build-kotlin | Kotlin build errors | Kotlin build failures |
-| review-cpp | C++ review | C++ projects |
-| build-cpp | C++ build errors | C++ build failures |
-| loop-operator | Autonomous loops | Iterative workflows |
-
-### Immediate Subagent Usage
-
-No user prompt needed:
-1. Complex feature requests — Use `planner`
-2. Code just written/modified — Use `code-reviewer`
-3. Bug fix or new feature — Use `tdd-guide`
-4. Architectural decision — Use `architect`
-
----
-
-## Performance
-
-### Model Selection Strategy
-
-**Haiku** (lightweight): deterministic changes, simple code gen, worker agents
-**Sonnet** (default): main development, multi-agent orchestration, complex coding
-**Opus** (deep reasoning): architecture decisions, security review, ambiguous requirements
-
-### Context Window Management
-
-Avoid last 20% of context window for:
-- Large-scale refactoring
-- Feature implementation spanning multiple files
-- Debugging complex interactions
-
----
-
-## Git Workflow
-
-### Commit Message Format
-
-```
-<type>: <description>
-```
-
-Types: feat, fix, refactor, docs, test, chore, perf, ci
-
-### Feature Implementation Workflow
-
-1. **Plan** — Use `planner` to create plan with risks and phases
-2. **TDD** — Use `tdd-guide` for red-green-refactor cycle
-3. **Code Review** — Use `code-reviewer` immediately after writing
-4. **Security** — Use `security-reviewer` before commits
-5. **Commit** — Follow conventional commits format
-
----
-
-## Success Metrics
-
-You are successful when:
-- All tests pass (80%+ coverage)
-- No security vulnerabilities
-- Code is readable and maintainable
-- Performance is acceptable
-- User requirements are met

package/index.mjs

@@ -1,3 +0,0 @@
-import { BootstrapPlugin } from "./bootstrap.mjs"
-
-export default BootstrapPlugin

package/lib/logger.mjs

@@ -1,62 +0,0 @@
-import path from "node:path"
-import os from "node:os"
-import fs from "node:fs"
-
-const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }
-const CURRENT_LEVEL = LEVELS[process.env.OPENCODE_LOG_LEVEL?.trim().toLowerCase()] ?? (process.env.OPENHERMES_LOG_LEVEL?.trim().toLowerCase() === "debug" ? LEVELS.debug : LEVELS.warn)
-
-const LOG_DIR = path.join(os.homedir(), ".local", "share", "opencode", "log")
-const LOG_FILE = path.join(LOG_DIR, "openhermes.log")
-
-function ts() {
-  const d = new Date()
-  return `${d.getFullYear()}-${(d.getMonth()+1).toString().padStart(2,"0")}-${d.getDate().toString().padStart(2,"0")} ${d.getHours().toString().padStart(2,"0")}:${d.getMinutes().toString().padStart(2,"0")}:${d.getSeconds().toString().padStart(2,"0")}.${d.getMilliseconds().toString().padStart(3,"0")}`
-}
-
-function formatArgs(args) {
-  return args.map(a => {
-    if (a === null) return "null"
-    if (a === undefined) return "undefined"
-    if (typeof a === "object") {
-      try { return a?.message || JSON.stringify(a) } catch { return String(a) }
-    }
-    return String(a)
-  }).join(" ")
-}
-
-function shouldLog(levelName) {
-  return LEVELS[levelName] >= CURRENT_LEVEL
-}
-
-let _fd = null
-function getFd() {
-  if (_fd) return _fd
-  try {
-    fs.mkdirSync(LOG_DIR, { recursive: true })
-    _fd = fs.openSync(LOG_FILE, "a")
-  } catch {
-    _fd = -1
-  }
-  return _fd
-}
-
-export function createLogger(name) {
-  const prefix = `[openhermes:${name}]`
-
-  function emit(levelName, ...args) {
-    if (!shouldLog(levelName)) return
-    const fd = getFd()
-    if (fd < 0) return
-    const line = `${ts()} ${prefix} [${levelName.toUpperCase()}] ${formatArgs(args)}\n`
-    try { fs.writeSync(fd, line) } catch {}
-  }
-
-  return {
-    debug: (...args) => emit("debug", ...args),
-    info: (...args) => emit("info", ...args),
-    warn: (...args) => emit("warn", ...args),
-    error: (...args) => emit("error", ...args),
-  }
-}
-
-export const rootLogger = createLogger("root")