@zhijiewang/openharness 2.4.0 → 2.8.0

package/dist/tools/SkillTool/index.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { z } from "zod";
 import { discoverSkills, findSkill } from "../../harness/plugins.js";
@@ -24,7 +24,7 @@ export const SkillTool = {
             return { output: "Error: Invalid skill name.", isError: true };
         }
         // Early path traversal check for Level 2
-        if (input.path && input.path.includes("..")) {
+        if (input.path?.includes("..")) {
             return { output: "Error: Path traversal not allowed.", isError: true };
         }
         // List skills if "list" or "ls"
@@ -62,6 +62,30 @@ export const SkillTool = {
                 return { output: `File not found: ${input.path} (looked in ${skillDir}/)`, isError: true };
             }
         }
+        // Track usage (fire-and-forget, don't block skill invocation)
+        try {
+            let raw = readFileSync(skill.filePath, "utf-8");
+            const now = Date.now();
+            const usedMatch = raw.match(/^timesUsed:\s*(\d+)$/m);
+            const count = usedMatch ? parseInt(usedMatch[1], 10) + 1 : 1;
+            if (usedMatch) {
+                raw = raw.replace(/^timesUsed:\s*\d+$/m, `timesUsed: ${count}`);
+            }
+            else {
+                const first = raw.indexOf("---");
+                const closing = raw.indexOf("---", first + 3);
+                if (closing > 0) {
+                    raw = `${raw.slice(0, closing)}timesUsed: ${count}\nlastUsed: ${now}\n${raw.slice(closing)}`;
+                }
+            }
+            if (raw.match(/^lastUsed:/m)) {
+                raw = raw.replace(/^lastUsed:\s*\d+$/m, `lastUsed: ${now}`);
+            }
+            writeFileSync(skill.filePath, raw);
+        }
+        catch {
+            /* don't block on tracking failure */
+        }
         return { output: skill.content, isError: false };
     },
     prompt() {

package/dist/tools/TodoWriteTool/index.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    todos: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<["pending", "in_progress", "completed"]>>;
+        priority: z.ZodOptional<z.ZodEnum<["high", "medium", "low"]>>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        status: "completed" | "pending" | "in_progress";
+        id: string;
+        priority?: "low" | "medium" | "high" | undefined;
+    }, {
+        content: string;
+        id: string;
+        status?: "completed" | "pending" | "in_progress" | undefined;
+        priority?: "low" | "medium" | "high" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    todos: {
+        content: string;
+        status: "completed" | "pending" | "in_progress";
+        id: string;
+        priority?: "low" | "medium" | "high" | undefined;
+    }[];
+}, {
+    todos: {
+        content: string;
+        id: string;
+        status?: "completed" | "pending" | "in_progress" | undefined;
+        priority?: "low" | "medium" | "high" | undefined;
+    }[];
+}>;
+export declare const TodoWriteTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/TodoWriteTool/index.js

@@ -0,0 +1,78 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { z } from "zod";
+const todoSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    status: z.enum(["pending", "in_progress", "completed"]).default("pending"),
+    priority: z.enum(["high", "medium", "low"]).optional(),
+});
+const inputSchema = z.object({
+    todos: z.array(todoSchema).describe("List of todo items to write. Existing items with matching IDs are updated."),
+});
+export const TodoWriteTool = {
+    name: "TodoWrite",
+    description: "Write or update todo items. Creates new items or updates existing ones by ID.",
+    inputSchema,
+    riskLevel: "low",
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return false;
+    },
+    async call(input, context) {
+        const dir = path.join(context.workingDir, ".oh");
+        const filePath = path.join(dir, "todos.json");
+        try {
+            await fs.mkdir(dir, { recursive: true });
+            let existing = [];
+            try {
+                const content = await fs.readFile(filePath, "utf-8");
+                existing = JSON.parse(content);
+            }
+            catch {
+                // File doesn't exist yet
+            }
+            const existingMap = new Map(existing.map((t) => [t.id, t]));
+            const now = Date.now();
+            let created = 0;
+            let updated = 0;
+            for (const item of input.todos) {
+                const prev = existingMap.get(item.id);
+                if (prev) {
+                    existingMap.set(item.id, { ...prev, ...item, updatedAt: now });
+                    updated++;
+                }
+                else {
+                    existingMap.set(item.id, { ...item, createdAt: now, updatedAt: now });
+                    created++;
+                }
+            }
+            const todos = [...existingMap.values()];
+            await fs.writeFile(filePath, JSON.stringify(todos, null, 2), "utf-8");
+            const parts = [];
+            if (created > 0)
+                parts.push(`${created} created`);
+            if (updated > 0)
+                parts.push(`${updated} updated`);
+            const total = todos.filter((t) => t.status !== "completed").length;
+            return {
+                output: `Todos: ${parts.join(", ")}. ${total} remaining (${todos.length} total).`,
+                isError: false,
+            };
+        }
+        catch (err) {
+            return { output: `Error writing todos: ${err.message}`, isError: true };
+        }
+    },
+    prompt() {
+        return `Write or update todo items in .oh/todos.json. Each item has:
+- id (string, required): Unique identifier for the todo.
+- content (string, required): Description of what needs to be done.
+- status ("pending" | "in_progress" | "completed"): Current status. Default: "pending".
+- priority ("high" | "medium" | "low", optional): Priority level.
+Items with matching IDs are updated; new IDs create new items.`;
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/tools.js

@@ -43,6 +43,7 @@ import { TaskListTool } from "./tools/TaskListTool/index.js";
 import { TaskOutputTool } from "./tools/TaskOutputTool/index.js";
 import { TaskStopTool } from "./tools/TaskStopTool/index.js";
 import { TaskUpdateTool } from "./tools/TaskUpdateTool/index.js";
+import { TodoWriteTool } from "./tools/TodoWriteTool/index.js";
 import { ToolSearchTool } from "./tools/ToolSearchTool/index.js";
 import { WebFetchTool } from "./tools/WebFetchTool/index.js";
 import { WebSearchTool } from "./tools/WebSearchTool/index.js";
@@ -104,6 +105,7 @@ export function getAllTools() {
         MonitorTool,
         ScheduleWakeupTool,
         SessionSearchTool,
+        TodoWriteTool,
     ];
     return [...core, ...extended.map((t) => new DeferredTool(t))];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.4.0",
+  "version": "2.8.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {