@cogineai/dearharness 0.1.0

package/dist/tools/find.js

@@ -0,0 +1,67 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { FIND_MAX_DEPTH, FIND_MAX_RESULTS } from '../config.js';
+import { resolveWorkspaceEntry, resolveWorkspacePath } from './path.js';
+async function collectMatches(root, query, workspaceRealPath, out, depth, seenRealPaths, maxDepth) {
+    if (out.length >= FIND_MAX_RESULTS || depth > maxDepth) {
+        return;
+    }
+    const rootRealPath = await fs.realpath(root);
+    if (seenRealPaths.has(rootRealPath)) {
+        return;
+    }
+    seenRealPaths.add(rootRealPath);
+    const entries = await fs.readdir(rootRealPath, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (out.length >= FIND_MAX_RESULTS) {
+            break;
+        }
+        const target = path.join(rootRealPath, entry.name);
+        const resolved = await resolveWorkspaceEntry(workspaceRealPath, target).catch(() => null);
+        if (!resolved) {
+            continue;
+        }
+        if (entry.name.includes(query)) {
+            if (out.length >= FIND_MAX_RESULTS) {
+                break;
+            }
+            out.push(resolved.relativePath);
+        }
+        if (out.length >= FIND_MAX_RESULTS || depth >= maxDepth || !resolved.stat.isDirectory()) {
+            continue;
+        }
+        if (seenRealPaths.has(resolved.targetRealPath)) {
+            continue;
+        }
+        await collectMatches(resolved.targetRealPath, query, workspaceRealPath, out, depth + 1, seenRealPaths, maxDepth);
+    }
+}
+export const findTool = {
+    name: 'find',
+    access: 'read',
+    supports(action) {
+        return typeof action.find === 'object' && !!action.find;
+    },
+    async execute(action, context) {
+        try {
+            const { relativePath, targetRealPath, workspaceRealPath } = await resolveWorkspacePath(context.cwd, action.find.path ?? '.');
+            const matches = [];
+            await collectMatches(targetRealPath, action.find.name, workspaceRealPath, matches, 0, new Set(), FIND_MAX_DEPTH);
+            return {
+                tool: 'find',
+                status: 'ok',
+                meta: { path: relativePath, matches: matches.length },
+                content: `TOOL_RESULT find OK\npath=${relativePath}\n${matches.join('\n')}`.trim()
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                tool: 'find',
+                status: 'error',
+                meta: { path: action.find.path ?? '.', error: message },
+                content: `TOOL_RESULT find ERROR\npath=${action.find.path ?? '.'}\n${message}`
+            };
+        }
+    }
+};

package/dist/tools/grep.js

@@ -0,0 +1,88 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { GREP_MAX_FILE_BYTES, GREP_MAX_MATCHES } from '../config.js';
+import { resolveWorkspaceEntry, resolveWorkspacePath } from './path.js';
+async function collectFileMatches(entry, pattern, out) {
+    if (out.length >= GREP_MAX_MATCHES) {
+        return;
+    }
+    if (!entry.stat.isFile()) {
+        return;
+    }
+    if (entry.stat.size > GREP_MAX_FILE_BYTES) {
+        return;
+    }
+    const raw = await fs.readFile(entry.targetRealPath, 'utf8').catch(() => null);
+    if (raw === null) {
+        return;
+    }
+    for (const [index, line] of raw.split('\n').entries()) {
+        if (out.length >= GREP_MAX_MATCHES) {
+            break;
+        }
+        if (line.includes(pattern)) {
+            out.push(`${entry.relativePath}:${index + 1}: ${line}`);
+        }
+    }
+}
+async function collectGrepMatches(root, pattern, workspaceRealPath, out, seenRealPaths) {
+    if (out.length >= GREP_MAX_MATCHES) {
+        return;
+    }
+    const rootRealPath = await fs.realpath(root);
+    if (seenRealPaths.has(rootRealPath)) {
+        return;
+    }
+    seenRealPaths.add(rootRealPath);
+    const entries = await fs.readdir(rootRealPath, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (out.length >= GREP_MAX_MATCHES) {
+            break;
+        }
+        const target = path.join(rootRealPath, entry.name);
+        const resolved = await resolveWorkspaceEntry(workspaceRealPath, target).catch(() => null);
+        if (!resolved) {
+            continue;
+        }
+        if (resolved.stat.isDirectory()) {
+            await collectGrepMatches(resolved.targetRealPath, pattern, workspaceRealPath, out, seenRealPaths);
+            continue;
+        }
+        await collectFileMatches(resolved, pattern, out);
+    }
+}
+export const grepTool = {
+    name: 'grep',
+    access: 'read',
+    supports(action) {
+        return typeof action.grep === 'object' && !!action.grep;
+    },
+    async execute(action, context) {
+        try {
+            const { relativePath, targetRealPath, workspaceRealPath } = await resolveWorkspacePath(context.cwd, action.grep.path ?? '.');
+            const matches = [];
+            const targetStats = await fs.stat(targetRealPath);
+            if (targetStats.isDirectory()) {
+                await collectGrepMatches(targetRealPath, action.grep.pattern, workspaceRealPath, matches, new Set());
+            }
+            else if (targetStats.isFile()) {
+                await collectFileMatches({ stat: targetStats, targetRealPath, relativePath }, action.grep.pattern, matches);
+            }
+            return {
+                tool: 'grep',
+                status: 'ok',
+                meta: { path: relativePath, matches: matches.length },
+                content: `TOOL_RESULT grep OK\npath=${relativePath}\n${matches.join('\n')}`.trim()
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                tool: 'grep',
+                status: 'error',
+                meta: { path: action.grep.path ?? '.', error: message },
+                content: `TOOL_RESULT grep ERROR\npath=${action.grep.path ?? '.'}\n${message}`
+            };
+        }
+    }
+};

package/dist/tools/ls.js

@@ -0,0 +1,37 @@
+import { promises as fs } from 'node:fs';
+import { LIST_MAX_ENTRIES } from '../config.js';
+import { resolveWorkspacePath } from './path.js';
+export const lsTool = {
+    name: 'ls',
+    access: 'read',
+    supports(action) {
+        return typeof action.ls === 'object' && !!action.ls;
+    },
+    async execute(action, context) {
+        try {
+            const { relativePath, targetRealPath } = await resolveWorkspacePath(context.cwd, action.ls.path ?? '.');
+            const allEntries = (await fs.readdir(targetRealPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+            const truncated = allEntries.length > LIST_MAX_ENTRIES;
+            const entries = allEntries
+                .slice(0, LIST_MAX_ENTRIES)
+                .map((entry) => `${entry.isDirectory() ? 'dir' : 'file'} ${entry.name}${entry.isDirectory() ? '/' : ''}`)
+                .join('\n');
+            const truncationNotice = truncated ? `\n... (truncated, showing ${Math.min(allEntries.length, LIST_MAX_ENTRIES)} of ${allEntries.length} entries)` : '';
+            return {
+                tool: 'ls',
+                status: 'ok',
+                meta: { path: relativePath },
+                content: `TOOL_RESULT ls OK\npath=${relativePath}\n${entries}${truncationNotice}`.trim()
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                tool: 'ls',
+                status: 'error',
+                meta: { path: action.ls.path ?? '.', error: message },
+                content: `TOOL_RESULT ls ERROR\npath=${action.ls.path ?? '.'}\n${message}`
+            };
+        }
+    }
+};

package/dist/tools/path.js

@@ -0,0 +1,35 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+export const WORKSPACE_PATH_ERROR = 'path must stay inside the workspace and be workspace-relative';
+export function isPathInsideWorkspace(workspaceRealPath, targetRealPath) {
+    const relativePath = path.relative(workspaceRealPath, targetRealPath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+export async function resolveWorkspacePath(cwd, inputPath) {
+    const target = path.resolve(cwd, inputPath);
+    const relativePath = path.relative(cwd, target) || '.';
+    if (path.isAbsolute(inputPath) || relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        throw new Error(WORKSPACE_PATH_ERROR);
+    }
+    const workspaceRealPath = await fs.realpath(cwd);
+    const targetRealPath = await fs.realpath(target);
+    if (!isPathInsideWorkspace(workspaceRealPath, targetRealPath)) {
+        throw new Error(WORKSPACE_PATH_ERROR);
+    }
+    return { target, relativePath, workspaceRealPath, targetRealPath };
+}
+export async function resolveWorkspaceEntry(workspaceRealPath, target) {
+    const stat = await fs.lstat(target);
+    if (stat.isSymbolicLink()) {
+        return null;
+    }
+    const targetRealPath = await fs.realpath(target);
+    if (!isPathInsideWorkspace(workspaceRealPath, targetRealPath)) {
+        return null;
+    }
+    return {
+        stat,
+        targetRealPath,
+        relativePath: path.relative(workspaceRealPath, targetRealPath) || '.'
+    };
+}

package/dist/tools/read.js

@@ -0,0 +1,40 @@
+import { promises as fs } from 'node:fs';
+import { READ_MAX_BYTES } from '../config.js';
+import { resolveWorkspacePath } from './path.js';
+export const readTool = {
+    name: 'read',
+    access: 'read',
+    supports(action) {
+        return typeof action.read === 'object' && !!action.read;
+    },
+    async execute(action, context) {
+        try {
+            const { relativePath, targetRealPath } = await resolveWorkspacePath(context.cwd, action.read.path);
+            const raw = await fs.readFile(targetRealPath, 'utf8');
+            const lines = raw.split('\n');
+            const start = Math.min(Math.max(1, action.read.start_line ?? 1), lines.length);
+            const requestedEnd = action.read.end_line ?? Math.min(lines.length, start + 199);
+            const end = Math.max(start, Math.min(lines.length, requestedEnd));
+            const snippet = lines
+                .slice(start - 1, end)
+                .map((line, index) => `${start + index}| ${line}`)
+                .join('\n')
+                .slice(0, READ_MAX_BYTES);
+            return {
+                tool: 'read',
+                status: 'ok',
+                meta: { path: relativePath, start_line: start, end_line: end },
+                content: `TOOL_RESULT read OK\npath=${relativePath}\n${snippet}`.trim()
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                tool: 'read',
+                status: 'error',
+                meta: { path: action.read.path, error: message },
+                content: `TOOL_RESULT read ERROR\npath=${action.read.path}\n${message}`
+            };
+        }
+    }
+};

package/dist/tools/registry.js

@@ -0,0 +1,18 @@
+import { bashTool } from './bash.js';
+import { editTool } from './edit.js';
+import { findTool } from './find.js';
+import { grepTool } from './grep.js';
+import { lsTool } from './ls.js';
+import { readTool } from './read.js';
+export function createToolRegistry(definitions = [bashTool, editTool, readTool, lsTool, findTool, grepTool]) {
+    return {
+        definitions,
+        resolve(action) {
+            const definition = definitions.find((candidate) => candidate.supports(action));
+            if (!definition) {
+                throw new Error(`No tool registered for action: ${JSON.stringify(action)}`);
+            }
+            return { definition };
+        }
+    };
+}

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/workspace/config.js

@@ -0,0 +1,72 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { APP_DIR } from '../config.js';
+const EMPTY_WORKSPACE_CONFIG = {
+    instructionFiles: [],
+    extensions: [],
+    defaultSkills: []
+};
+function cloneEmptyWorkspaceConfig() {
+    return {
+        instructionFiles: [...EMPTY_WORKSPACE_CONFIG.instructionFiles],
+        extensions: [...EMPTY_WORKSPACE_CONFIG.extensions],
+        defaultSkills: [...EMPTY_WORKSPACE_CONFIG.defaultSkills]
+    };
+}
+function readStringArray(record, key) {
+    const value = record[key];
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+        throw new Error(`${key} must be an array of strings`);
+    }
+    return value;
+}
+function readModelConfig(record) {
+    const value = record.model;
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('model must be an object');
+    }
+    const model = value;
+    for (const key of ['provider', 'model', 'baseUrl', 'streaming']) {
+        if (model[key] !== undefined && typeof model[key] !== 'string') {
+            throw new Error(`model.${key} must be a string`);
+        }
+    }
+    if (typeof model.streaming === 'string' && !['auto', 'on', 'off'].includes(model.streaming)) {
+        throw new Error('model.streaming must be one of: auto, on, off');
+    }
+    return {
+        ...(typeof model.provider === 'string' ? { provider: model.provider } : {}),
+        ...(typeof model.model === 'string' ? { model: model.model } : {}),
+        ...(typeof model.baseUrl === 'string' ? { baseUrl: model.baseUrl } : {}),
+        ...(typeof model.streaming === 'string' ? { streaming: model.streaming } : {})
+    };
+}
+export async function loadWorkspaceConfig(cwd) {
+    const target = path.join(cwd, APP_DIR, 'config.json');
+    try {
+        const parsed = JSON.parse(await fs.readFile(target, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('workspace config must be a JSON object');
+        }
+        const record = parsed;
+        const model = readModelConfig(record);
+        return {
+            instructionFiles: readStringArray(record, 'instructionFiles'),
+            extensions: readStringArray(record, 'extensions'),
+            defaultSkills: readStringArray(record, 'defaultSkills'),
+            ...(model ? { model } : {})
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return cloneEmptyWorkspaceConfig();
+        }
+        throw error;
+    }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@cogineai/dearharness",
+  "version": "0.1.0",
+  "description": "OpenClaw Harness operator CLI and instance-side daemon prototype.",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://github.com/cogine-ai/dearharness-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cogine-ai/dearharness-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cogine-ai/dearharness-cli/issues"
+  },
+  "keywords": [
+    "dearharness",
+    "dearclaw",
+    "openclaw",
+    "harness",
+    "cli",
+    "daemon"
+  ],
+  "bin": {
+    "dearharness": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "!dist/**/*.test.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "node --test --import tsx \"src/**/*.test.ts\""
+  },
+  "dependencies": {
+    "fflate": "^0.8.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
+  }
+}