@zhijiewang/openharness 2.5.0 → 2.9.0

package/dist/harness/plugins.js

@@ -12,10 +12,31 @@
  */
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, relative } from "node:path";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
 const PROJECT_SKILLS_DIR = join(".oh", "skills");
 const GLOBAL_SKILLS_DIR = join(homedir(), ".oh", "skills");
-/** Parse YAML frontmatter from a skill markdown file */
+// Claude Code ecosystem mirror paths (Anthropic convention)
+const CC_PROJECT_SKILLS_DIR = join(".claude", "skills");
+const CC_GLOBAL_SKILLS_DIR = join(homedir(), ".claude", "skills");
+// Bundled skills shipped with the openharness package itself.
+// At runtime this resolves to <package-root>/data/skills/ both in dev (src/) and prod (dist/).
+const BUNDLED_SKILLS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "data", "skills");
+/** Parse a frontmatter list value. Accepts `[a, b]` (YAML inline) or `a b c` (space-separated, Anthropic spec). */
+function parseListValue(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        return trimmed
+            .slice(1, -1)
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean);
+    }
+    // Strip surrounding quotes if present
+    const unquoted = trimmed.replace(/^["']|["']$/g, "");
+    return unquoted.split(/\s+/).filter(Boolean);
+}
+/** Parse YAML frontmatter from a skill markdown file. Accepts both OH camelCase and Anthropic kebab-case. */
 function parseSkillFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match)
@@ -28,33 +49,74 @@ function parseSkillFrontmatter(content) {
     const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
     if (descMatch)
         result.description = descMatch[1].trim();
+    // trigger: OH-native field; when-to-use / whenToUse: Anthropic-style hint (also used as trigger fallback)
     const triggerMatch = frontmatter.match(/^trigger:\s*(.+)$/m);
     if (triggerMatch)
         result.trigger = triggerMatch[1].trim();
-    const toolsMatch = frontmatter.match(/^tools:\s*\[(.+)\]$/m);
-    if (toolsMatch)
-        result.tools = toolsMatch[1].split(",").map((t) => t.trim());
-    // Also parse allowedTools (used by built-in skills) and merge with tools
-    const allowedToolsMatch = frontmatter.match(/^allowedTools:\s*\[(.+)\]$/m);
-    if (allowedToolsMatch) {
-        const allowed = allowedToolsMatch[1].split(",").map((t) => t.trim());
-        result.tools = result.tools ? [...new Set([...result.tools, ...allowed])] : allowed;
+    const whenToUseMatch = frontmatter.match(/^(?:when-to-use|whenToUse):\s*(.+)$/m);
+    if (whenToUseMatch)
+        result.whenToUse = whenToUseMatch[1].trim();
+    // tools / allowedTools / allowed-tools — array OR space-separated. Merge all forms found.
+    const toolsCollected = new Set();
+    for (const re of [/^tools:\s*(.+)$/m, /^allowedTools:\s*(.+)$/m, /^allowed-tools:\s*(.+)$/m]) {
+        const m = frontmatter.match(re);
+        if (m)
+            for (const t of parseListValue(m[1]))
+                toolsCollected.add(t);
     }
-    const argsMatch = frontmatter.match(/^args:\s*\[(.+)\]$/m);
+    if (toolsCollected.size > 0)
+        result.tools = [...toolsCollected];
+    // args / argument-hint
+    const argsMatch = frontmatter.match(/^(?:args|argument-hint):\s*(.+)$/m);
     if (argsMatch)
-        result.args = argsMatch[1].split(",").map((a) => a.trim());
+        result.args = parseListValue(argsMatch[1]);
     // invokeModel: false OR disable-model-invocation: true → hidden from system prompt
     if (frontmatter.match(/^invokeModel:\s*false$/m) || frontmatter.match(/^disable-model-invocation:\s*true$/m)) {
         result.invokeModel = false;
     }
+    // license: SPDX identifier (e.g. MIT, Apache-2.0)
+    const licenseMatch = frontmatter.match(/^license:\s*(.+)$/m);
+    if (licenseMatch)
+        result.license = licenseMatch[1].trim().replace(/^["']|["']$/g, "");
+    // paths: glob list — scopes auto-surfacing to matching files
+    const pathsMatch = frontmatter.match(/^paths:\s*(.+)$/m);
+    if (pathsMatch)
+        result.paths = parseListValue(pathsMatch[1]);
+    // context: "default" | "fork" — when "fork", skill runs in a new sub-agent context
+    const contextMatch = frontmatter.match(/^context:\s*(.+)$/m);
+    if (contextMatch) {
+        const v = contextMatch[1].trim().replace(/^["']|["']$/g, "");
+        if (v === "fork" || v === "default")
+            result.context = v;
+    }
+    // agent: sub-agent type name (only meaningful when context: fork)
+    const agentMatch = frontmatter.match(/^agent:\s*(.+)$/m);
+    if (agentMatch)
+        result.agent = agentMatch[1].trim().replace(/^["']|["']$/g, "");
     return result;
 }
-/** Recursively collect all .md files from a directory tree */
+/** Recursively collect skill .md files from a directory tree.
+ * Anthropic / Claude Code convention: a directory containing `SKILL.md` is a single
+ * directory-packaged skill — only the SKILL.md surfaces; sibling .md files are
+ * companion documentation (referenced via Read at runtime). Directories without
+ * SKILL.md fall through to the legacy flat-file behavior (every .md is a skill).
+ */
 function walkMdFiles(dir) {
     if (!existsSync(dir))
         return [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    // Directory-packaged skill: only SKILL.md counts; siblings are companions.
+    if (entries.includes("SKILL.md")) {
+        return [join(dir, "SKILL.md")];
+    }
     const results = [];
-    for (const entry of readdirSync(dir)) {
+    for (const entry of entries) {
         const full = join(dir, entry);
         try {
             if (statSync(full).isDirectory()) {
@@ -86,6 +148,11 @@ function loadSkillsFromDir(dir, source) {
                 trigger: meta.trigger,
                 tools: meta.tools,
                 args: meta.args,
+                whenToUse: meta.whenToUse,
+                license: meta.license,
+                paths: meta.paths,
+                context: meta.context,
+                agent: meta.agent,
                 content,
                 filePath,
                 source,
@@ -98,11 +165,17 @@ function loadSkillsFromDir(dir, source) {
     })
         .filter((s) => s !== null);
 }
-/** Discover all available skills from project + global dirs + installed plugins */
+/** Discover all available skills from bundled + project + global dirs + installed plugins */
 export function discoverSkills() {
     const skills = [];
+    // Bundled (shipped with the openharness package)
+    skills.push(...loadSkillsFromDir(BUNDLED_SKILLS_DIR, "bundled"));
+    // OH-native paths
     skills.push(...loadSkillsFromDir(PROJECT_SKILLS_DIR, "project"));
     skills.push(...loadSkillsFromDir(GLOBAL_SKILLS_DIR, "global"));
+    // Claude Code ecosystem mirror paths — same source labels (project/global)
+    skills.push(...loadSkillsFromDir(CC_PROJECT_SKILLS_DIR, "project"));
+    skills.push(...loadSkillsFromDir(CC_GLOBAL_SKILLS_DIR, "global"));
     // Load skills from installed marketplace plugins (namespaced as plugin-name:skill-name)
     try {
         const { getInstalledPlugins } = require("./marketplace.js");
@@ -119,14 +192,22 @@ export function discoverSkills() {
     catch {
         /* marketplace module may not be loaded yet */
     }
-    return skills;
+    // De-duplicate by name+filePath: if same skill appears in multiple paths (e.g. CC mirror), keep first.
+    const seen = new Set();
+    return skills.filter((s) => {
+        const key = `${s.name}::${s.filePath}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
 }
 /** Find a skill by name (case-insensitive) */
 export function findSkill(name) {
     const skills = discoverSkills();
     return skills.find((s) => s.name.toLowerCase() === name.toLowerCase()) ?? null;
 }
-/** Find skills that match a trigger condition */
+/** Find skills that match a trigger condition (substring match against `trigger` field). */
 export function findTriggeredSkills(userMessage) {
     const skills = discoverSkills();
     return skills.filter((s) => {

package/dist/harness/session-db.d.ts

@@ -48,7 +48,14 @@ export declare function sessionToIndexEntry(session: Session): SessionIndexEntry
  * Rebuilds the FTS5 index from session JSON files on disk.
  */
 export declare function rebuildIndex(db: Database.Database, sessionsDir?: string): number;
-/** Get a shared DB connection (opens once, reuses thereafter) */
+/**
+ * Get a shared DB connection (opens once, reuses thereafter).
+ *
+ * Honors the `OH_SESSION_DB_PATH` environment variable for test isolation.
+ * When the env var changes between calls, the old singleton is closed and a
+ * new one is opened at the new path — this lets tests point at a tmp dir
+ * without leaking into the user's real `~/.oh/sessions.db`.
+ */
 export declare function getSessionDb(): Database.Database;
 /** Close the singleton connection (call on process exit) */
 export declare function closeGlobalSessionDb(): void;

package/dist/harness/session-db.js

@@ -145,11 +145,32 @@ export function rebuildIndex(db, sessionsDir) {
 }
 // ── Singleton Connection ──
 let _singletonDb = null;
-/** Get a shared DB connection (opens once, reuses thereafter) */
+let _singletonDbPath = null;
+/**
+ * Get a shared DB connection (opens once, reuses thereafter).
+ *
+ * Honors the `OH_SESSION_DB_PATH` environment variable for test isolation.
+ * When the env var changes between calls, the old singleton is closed and a
+ * new one is opened at the new path — this lets tests point at a tmp dir
+ * without leaking into the user's real `~/.oh/sessions.db`.
+ */
 export function getSessionDb() {
-    if (!_singletonDb) {
-        _singletonDb = openSessionDb();
+    const envPath = process.env.OH_SESSION_DB_PATH;
+    const targetPath = envPath || DEFAULT_DB_PATH;
+    if (_singletonDb && _singletonDbPath === targetPath) {
+        return _singletonDb;
+    }
+    if (_singletonDb) {
+        try {
+            _singletonDb.close();
+        }
+        catch {
+            /* ignore */
+        }
+        _singletonDb = null;
     }
+    _singletonDb = openSessionDb(targetPath);
+    _singletonDbPath = targetPath;
     return _singletonDb;
 }
 /** Close the singleton connection (call on process exit) */

package/dist/harness/skill-registry.d.ts

@@ -1,6 +1,8 @@
 /**
  * Skills Registry — search and install community skills from a remote registry.
  */
+/** SPDX identifiers for licenses we install without explicit user acceptance. */
+export declare const PERMISSIVE_LICENSES: Set<string>;
 export type RegistrySkill = {
     name: string;
     description: string;
@@ -8,6 +10,14 @@ export type RegistrySkill = {
     version: string;
     source: string;
     tags: string[];
+    /** SPDX license identifier (e.g. "MIT"). Required for new entries; absent for legacy. */
+    license?: string;
+    /** Attribution string to preserve when installing (e.g. "© 2025 Jesse Vincent"). */
+    attribution?: string;
+    /** Upstream homepage / repo URL. */
+    upstream?: string;
+    /** When false, skill cannot be installed via this command — only linked to upstream. Used for viral licenses (CC-BY-SA, GPL). */
+    installable?: boolean;
 };
 export type Registry = {
     skills: RegistrySkill[];
@@ -16,6 +26,20 @@ export type Registry = {
 export declare function fetchRegistry(url?: string): Promise<Registry>;
 /** Search registry by query (matches name, description, tags) */
 export declare function searchRegistry(registry: Registry, query: string): RegistrySkill[];
-/** Install a skill from the registry to ~/.oh/skills/ */
-export declare function installSkill(skill: RegistrySkill): Promise<string>;
+/** Result returned by installSkill — either success with path, or refusal with reason. */
+export type InstallResult = {
+    ok: true;
+    filePath: string;
+} | {
+    ok: false;
+    reason: "not-installable" | "license-not-accepted";
+    message: string;
+};
+/** Install a skill from the registry to ~/.oh/skills/.
+ * Refuses non-permissive licenses unless `acceptLicense` matches the entry's license.
+ * Refuses entries with `installable: false` (e.g. viral-license skills that must be installed upstream).
+ */
+export declare function installSkill(skill: RegistrySkill, opts?: {
+    acceptLicense?: string;
+}): Promise<InstallResult>;
 //# sourceMappingURL=skill-registry.d.ts.map

package/dist/harness/skill-registry.js

@@ -6,6 +6,16 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 const DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/zhijiewong/openharness/main/data/registry.json";
 const GLOBAL_SKILLS_DIR = join(homedir(), ".oh", "skills");
+/** SPDX identifiers for licenses we install without explicit user acceptance. */
+export const PERMISSIVE_LICENSES = new Set([
+    "MIT",
+    "Apache-2.0",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "ISC",
+    "CC0-1.0",
+    "Unlicense",
+]);
 /** Fetch the registry from remote URL */
 export async function fetchRegistry(url = DEFAULT_REGISTRY_URL) {
     const response = await fetch(url);
@@ -20,16 +30,44 @@ export function searchRegistry(registry, query) {
         s.description.toLowerCase().includes(q) ||
         s.tags.some((t) => t.toLowerCase().includes(q)));
 }
-/** Install a skill from the registry to ~/.oh/skills/ */
-export async function installSkill(skill) {
+/** Install a skill from the registry to ~/.oh/skills/.
+ * Refuses non-permissive licenses unless `acceptLicense` matches the entry's license.
+ * Refuses entries with `installable: false` (e.g. viral-license skills that must be installed upstream).
+ */
+export async function installSkill(skill, opts = {}) {
+    // Gate 1: link-only entries
+    if (skill.installable === false) {
+        const upstream = skill.upstream ? ` Visit ${skill.upstream} to install under its license terms.` : "";
+        return {
+            ok: false,
+            reason: "not-installable",
+            message: `Skill "${skill.name}" is link-only (license: ${skill.license ?? "unknown"}).${upstream}`,
+        };
+    }
+    // Gate 2: license check
+    if (skill.license && !PERMISSIVE_LICENSES.has(skill.license)) {
+        if (opts.acceptLicense !== skill.license) {
+            return {
+                ok: false,
+                reason: "license-not-accepted",
+                message: `Skill "${skill.name}" is licensed under ${skill.license}, which is not in the auto-install allowlist.\n` +
+                    `To install, re-run with --accept-license=${skill.license} to acknowledge its terms.`,
+            };
+        }
+    }
     const response = await fetch(skill.source);
     if (!response.ok)
         throw new Error(`Failed to download skill: ${response.status}`);
-    const content = await response.text();
+    let content = await response.text();
+    // Preserve attribution by prepending an HTML comment if present and not already in the file
+    if (skill.attribution && !content.includes(skill.attribution)) {
+        const header = `<!-- Source: ${skill.upstream ?? skill.source}\n     License: ${skill.license ?? "unknown"}\n     ${skill.attribution} -->\n`;
+        content = header + content;
+    }
     mkdirSync(GLOBAL_SKILLS_DIR, { recursive: true });
     const slug = skill.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
     const filePath = join(GLOBAL_SKILLS_DIR, `${slug}.md`);
     writeFileSync(filePath, content);
-    return filePath;
+    return { ok: true, filePath };
 }
 //# sourceMappingURL=skill-registry.js.map

package/dist/providers/anthropic.js

@@ -87,15 +87,18 @@ export class AnthropicProvider {
         // Prompt caching: send system prompt as content blocks with cache_control.
         // Anthropic caches matching prefixes — 90% cost reduction on repeat turns.
         const systemBlocks = [{ type: "text", text: systemPrompt, cache_control: { type: "ephemeral" } }];
+        // Scale max_tokens and thinking budget based on model
+        const isOpus = m.includes("opus");
+        const maxTokens = isOpus ? 16384 : 8192;
+        const thinkingBudget = isOpus ? 32000 : 10000;
         const body = {
             model: m,
-            max_tokens: 8192,
+            max_tokens: maxTokens,
             system: systemBlocks,
             messages: this.convertMessages(messages),
             stream: true,
+            thinking: { type: "enabled", budget_tokens: thinkingBudget },
         };
-        // Enable extended thinking for Claude models
-        body.thinking = { type: "enabled", budget_tokens: 10000 };
         const anthropicTools = this.convertTools(tools);
         if (anthropicTools) {
             // Mark last tool definition as cacheable (cache covers all tools before it)
@@ -131,7 +134,6 @@ export class AnthropicProvider {
         let currentToolId = "";
         let currentToolName = "";
         let currentToolArgs = "";
-        let _inThinkingBlock = false;
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -169,9 +171,7 @@ export class AnthropicProvider {
                                 callId: block.id,
                             };
                         }
-                        if (block?.type === "thinking") {
-                            _inThinkingBlock = true;
-                        }
+                        // thinking blocks are handled via thinking_delta in content_block_delta
                         break;
                     }
                     case "content_block_delta": {
@@ -188,7 +188,6 @@ export class AnthropicProvider {
                         break;
                     }
                     case "content_block_stop": {
-                        _inThinkingBlock = false;
                         if (currentToolId) {
                             let parsedArgs = {};
                             if (currentToolArgs) {

package/dist/providers/openai.js

@@ -75,8 +75,9 @@ export class OpenAIProvider {
         if (tools?.length)
             body.tools = tools;
         // Enable reasoning for o-series models
-        if (m.startsWith("o1") || m.startsWith("o3")) {
-            body.reasoning_effort = "medium";
+        const isReasoning = m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4");
+        if (isReasoning) {
+            body.reasoning_effort = m.includes("mini") ? "medium" : "high";
         }
         let res;
         try {

package/dist/renderer/layout-sections.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Layout section renderers — individual UI widgets rasterized into a CellGrid.
+ * Each function takes (state, grid, row, limit, ...options) and returns next row.
+ */
+import type { CellGrid, Style } from "./cells.js";
+import type { LayoutState } from "./layout.js";
+export declare const S_TEXT: Style;
+export declare const S_DIM: Style;
+export declare const S_BORDER: Style;
+export declare const S_BANNER: Style;
+export declare const S_BANNER_DIM: Style;
+export declare let S_USER: Style;
+export declare let S_ASSISTANT: Style;
+export declare let S_ERROR: Style;
+export declare let S_YELLOW: Style;
+export declare let S_GREEN: Style;
+/** Reset style cache — call after theme change */
+export declare function resetStyleCache(): void;
+export declare function ensureStyles(): void;
+export declare const SPINNER_CHARS: string[];
+export declare function renderBannerSection(state: LayoutState, grid: CellGrid, r: number, limit: number, opts: {
+    compact: boolean;
+}): number;
+export declare function renderThinkingSection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderThinkingSummarySection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderSpinnerSection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderErrorSection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderToolCallsSection(state: LayoutState, grid: CellGrid, r: number, limit: number, opts: {
+    maxLiveLines: number;
+    showOverflow: boolean;
+}): number;
+export declare function renderContextWarningSection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderPermissionBoxSection(state: LayoutState, grid: CellGrid, nextRow: number, h: number, opts: {
+    boxed: boolean;
+    maxDiffHeight: number;
+}): number;
+export declare function renderQuestionPromptSection(state: LayoutState, grid: CellGrid, nextRow: number, h: number, opts: {
+    boxed: boolean;
+}): {
+    nextRow: number;
+    questionInputRow: number;
+};
+export declare function renderStatusLineSection(state: LayoutState, grid: CellGrid, nextRow: number, limit: number): number;
+export declare function renderAutocompleteSection(state: LayoutState, grid: CellGrid, nextRow: number, limit: number, promptWidth: number): number;
+export declare function renderNotificationsSection(state: LayoutState, grid: CellGrid, nextRow: number, limit: number): number;
+export declare function renderInputSection(state: LayoutState, grid: CellGrid, inputRow: number, limit: number, promptText: string, promptWidth: number): number;
+export declare function renderCompanionSection(state: LayoutState, grid: CellGrid, anchorRow: number, limit: number, promptWidth: number): void;
+export declare function computeCursorPosition(state: LayoutState, inputRow: number, inputStart: number, questionInputRow: number): {
+    cursorRow: number;
+    cursorCol: number;
+};
+export declare function getPromptText(state: LayoutState): {
+    promptText: string;
+    promptWidth: number;
+};
+//# sourceMappingURL=layout-sections.d.ts.map