@cydm/pie 1.0.6 → 1.0.7

package/dist/builtin/extensions/todo/index.js

@@ -1,30 +1,37 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   ManageTodoListParamsSchema,
+  buildExecutionReminder,
+  createExecutionStateFromTodos,
+  createTodoWidgetView,
   executeManageTodoList,
-  restoreTodosFromMessages
-} from "../../../chunks/chunk-TBJ25UWB.js";
-import "../../../chunks/chunk-MWFBYJOI.js";
-import "../../../chunks/chunk-RID3574D.js";
+  executionStateToTodos,
+  restoreExecutionState
+} from "../../../chunks/chunk-BHNULR7U.js";
+import "../../../chunks/chunk-A5JSJAPK.js";
 import "../../../chunks/chunk-TG2EQLX2.js";
 
 // builtin/extensions/todo/index.ts
-var TOOL_DESCRIPTION = `Manage a structured todo list to track progress and plan tasks throughout your coding session.
-
-Use this tool for complex multi-step work, especially when:
-- The task needs planning or progress tracking
-- The user provided multiple requests
-- You need to break a larger change into actionable steps
-- You are about to start or finish a tracked step
-
-Workflow:
-1. Write the full todo list with clear action items
-2. Mark the current item as in-progress before starting it
-3. Complete the work for that item
-4. Mark it completed immediately
-5. Continue until all items are done
-
-Always send the full list on write. Partial updates are not supported.`;
+var EXECUTION_METADATA_KEY = "executionState";
+var TOOL_DESCRIPTION = `Manage a session-local todo list. Use when the user explicitly asks to use the todo tool, create/manage todos, track tasks, follow a todo list, show tasks, or mark a task done.
+NEVER use for: internal planning, tracking your own progress, remembering subtasks, or creating checklists for yourself.
+Use action=create with items to create a list; the tool starts item 1 automatically. Use action=complete_current after finishing the current item; the tool advances to the next item or clears the list after the final item.
+When a todo list exists, keep executing from the current in-progress item until it is cleared. If the work cannot continue, explain the failure and use action=clear with a reason.
+Actions: create, read, complete_current, clear.`;
+function persistExecutionState(ctx, state) {
+  const nextState = state ?? restoreExecutionState(null);
+  ctx.setSessionMetadata(EXECUTION_METADATA_KEY, nextState);
+  ctx.setExecutionState(nextState);
+  ctx.setExecutionReminder(buildExecutionReminder(nextState) ?? void 0);
+  return nextState;
+}
+function notifyWidget(ctx, state) {
+  if (!ctx.hasUI || !ctx.ui) return;
+  const steps = createTodoWidgetView(state);
+  if (steps.length === 0) return;
+  const completed = steps.filter((step) => step.status === "completed").length;
+  ctx.ui.notify(`Todo tracking: ${completed}/${steps.length} completed`, "info");
+}
 function todoExtension(ctx) {
   ctx.registerTool({
     name: "manage_todo_list",
@@ -32,8 +39,30 @@ function todoExtension(ctx) {
     description: TOOL_DESCRIPTION,
     parameters: ManageTodoListParamsSchema,
     async execute(args) {
-      const currentTodos = restoreTodosFromMessages(ctx.getMessages());
-      return executeManageTodoList(args, currentTodos).result;
+      const currentTodos = executionStateToTodos(ctx.getExecutionState());
+      const execution = executeManageTodoList(args, currentTodos);
+      const nextState = createExecutionStateFromTodos(execution.nextTodos, "todo", "user_todo");
+      persistExecutionState(ctx, nextState);
+      notifyWidget(ctx, nextState);
+      return execution.result;
+    }
+  });
+  ctx.on("session:changed", async () => {
+    const state = restoreExecutionState(ctx.getSessionMetadata()?.[EXECUTION_METADATA_KEY]);
+    persistExecutionState(ctx, state);
+  });
+  ctx.on("tool:execution:end", async (event) => {
+    if (event.toolName !== "manage_todo_list") return;
+    const details = event.result?.details;
+    if (!details?.todos) return;
+    const state = createExecutionStateFromTodos(details.todos, "todo", "user_todo");
+    persistExecutionState(ctx, state);
+  });
+  ctx.on("agent:end", async () => {
+    const state = ctx.getExecutionState();
+    if (state.mode !== "todo") return;
+    if (state.lifecycle === "completed") {
+      persistExecutionState(ctx, null);
     }
   });
   ctx.log("Builtin todo extension ready");

package/dist/builtin/skills/browser-tools/CHANGELOG.md

@@ -1,47 +1,5 @@
 # Changelog
 
-All notable changes to this project will be documented in this file.
+## 2.0.0
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [1.1.0] - 2025-03-10
-
-### Fixed
-
-- **browser-eval.js**: Fixed complex JavaScript code execution
-  - Support for "const", "let", "var" keywords
-  - Support for multi-line code and conditionals (if/else, for, while)
-  - Support for function declarations and calls
-  - Automatic expression return value handling
-  - Fixed AsyncFunction wrapping syntax errors
-
-### Improved
-
-- Improved code execution logic using eval() instead of complex AsyncFunction wrapping
-- Support for more complex browser automation scenarios (e.g., MagicShell 10-round dialog testing)
-
-## [1.0.0] - 2025-03-09
-
-### Initial Release
-
-- Basic browser automation toolset
-- Chrome DevTools Protocol support
-- Included tools:
-  - browser-start.js: Start Chrome
-  - browser-nav.js: Page navigation
-  - browser-eval.js: JavaScript execution (basic)
-  - browser-screenshot.js: Screenshots
-  - browser-cookies.js: Cookie management
-  - browser-content.js: Content extraction
-  - browser-hn-scraper.js: HN scraper example
-  - browser-pick.js: Interactive element picker
-
-### Dependencies
-
-- puppeteer: ^24.31.0
-- puppeteer-core: ^23.11.1
-- @mozilla/readability: ^0.6.0
-- cheerio: ^1.1.2
-- jsdom: ^27.0.1
-- turndown: ^7.2.2
+- Replaced Pie's custom Chrome DevTools Protocol scripts with the packaged Microsoft Playwright CLI wrapper.

package/dist/builtin/skills/browser-tools/README.md

@@ -1,106 +1,17 @@
 # Browser Tools
 
-Browser automation tools based on Chrome DevTools Protocol (CDP) for collaborative site exploration and testing.
+Pie's browser-tools skill is backed by Microsoft Playwright CLI through `playwright-cli.js`.
 
-## Tools
-
-| Tool | Function | Usage |
-|------|----------|-------|
-| browser-start.js | Start Chrome with remote debugging | node browser-start.js |
-| browser-nav.js | Navigate to URL | node browser-nav.js https://example.com |
-| browser-eval.js | Execute JavaScript in browser | node browser-eval.js "document.title" |
-| browser-screenshot.js | Take screenshot | node browser-screenshot.js |
-| browser-cookies.js | Manage cookies | node browser-cookies.js |
-| browser-content.js | Extract page content | node browser-content.js |
-| browser-hn-scraper.js | HN scraper example | node browser-hn-scraper.js |
-| browser-pick.js | Interactive element picker | node browser-pick.js |
-
-## Quick Start
-
-### 1. Install dependencies
-
-```bash
-npm install
-```
-
-### 2. Start Chrome
-
-```bash
-node browser-start.js
-```
-
-This starts Chrome with remote debugging port (default: 9222).
-
-### 3. Use tools
+Use:
 
 ```bash
-# Navigate to website
-node browser-nav.js https://www.baidu.com
-
-# Execute JavaScript
-node browser-eval.js "document.title"
-
-# Complex code execution (supports const/let/var/if)
-node browser-eval.js "
-const links = document.querySelectorAll("a");
-const count = links.length;
-count;
-"
-
-# Take screenshot
-node browser-screenshot.js
+node playwright-cli.js --help
+node playwright-cli.js open https://example.com
+node playwright-cli.js snapshot
+node playwright-cli.js screenshot
+node playwright-cli.js console
+node playwright-cli.js network
+node playwright-cli.js close
 ```
 
-## browser-eval.js Advanced Usage
-
-### Simple expressions
-
-```bash
-node browser-eval.js "1 + 1"           # Output: 2
-node browser-eval.js "document.title"  # Output: Page title
-```
-
-### Complex code
-
-Supports multi-line code, const/let/var, conditionals:
-
-```bash
-node browser-eval.js "
-const buttons = document.querySelectorAll("button");
-const count = buttons.length;
-count;
-"
-
-node browser-eval.js "
-let sum = 0;
-for (let i = 1; i <= 5; i++) {
-    sum += i;
-}
-sum;
-"
-```
-
-## Tech Stack
-
-- **Puppeteer Core**: Connect and control Chrome browser
-- **Chrome DevTools Protocol**: Browser remote debugging protocol
-- **ES Modules**: Native ES module system
-
-## Dependencies
-
-- puppeteer: ^24.31.0
-- puppeteer-core: ^23.11.1
-
-## Notes
-
-1. Must run browser-start.js first to start Chrome
-2. Chrome must be started in remote debugging mode (default port 9222)
-3. browser-eval.js uses eval() to execute code, ensure input is trusted
-
-## Author
-
-Mario Zechner
-
-## License
-
-MIT
+Dependencies are provided by `@cydm/pie`; do not run `npm install` inside this skill directory.

package/dist/builtin/skills/browser-tools/SKILL.md

@@ -1,196 +1,43 @@
 ---
 name: browser-tools
-description: Interactive browser automation via Chrome DevTools Protocol. Use when you need to interact with web pages, test frontends, or when user interaction with a visible browser is required.
+description: Interactive browser automation via Microsoft Playwright CLI. Use when you need to open pages, inspect DOM snapshots, click/type, capture screenshots, inspect console/network output, or test frontend flows in a real browser.
 ---
 
 # Browser Tools
 
-Chrome DevTools Protocol tools for agent-assisted web automation. These tools connect to Chrome running on `:9222` with remote debugging enabled.
+Use Pie's packaged Microsoft Playwright CLI wrapper. Scripts live next to this skill; use `read_resource("browser-tools", "playwright-cli.js")` or `resolve_resource("browser-tools", "playwright-cli.js")` to get the executable path.
 
-## Setup
+No manual dependency install is required when this skill is shipped with Pie.
 
-Run once before first use:
+## Common Commands
 
 ```bash
-cd {baseDir}/browser-tools
-npm install
+node <resolvedPath for playwright-cli.js> open https://example.com
+node <resolvedPath for playwright-cli.js> goto https://example.com
+node <resolvedPath for playwright-cli.js> snapshot
+node <resolvedPath for playwright-cli.js> click "Submit"
+node <resolvedPath for playwright-cli.js> type "hello"
+node <resolvedPath for playwright-cli.js> screenshot
+node <resolvedPath for playwright-cli.js> console
+node <resolvedPath for playwright-cli.js> network
+node <resolvedPath for playwright-cli.js> close
 ```
 
-## Start Chrome
+Use `node <resolvedPath for playwright-cli.js> --help` for the full command list.
 
-```bash
-{baseDir}/browser-start.js              # Fresh profile
-{baseDir}/browser-start.js --profile    # Copy user's profile (cookies, logins)
-```
-
-Launch Chrome with remote debugging on `:9222`. Use `--profile` to preserve user's authentication state.
-
-## Navigate
-
-```bash
-{baseDir}/browser-nav.js https://example.com
-{baseDir}/browser-nav.js https://example.com --new
-```
-
-Navigate to URLs. Use `--new` flag to open in a new tab instead of reusing current tab.
-
-## Evaluate JavaScript
-
-```bash
-{baseDir}/browser-eval.js 'document.title'
-{baseDir}/browser-eval.js 'document.querySelectorAll("a").length'
-```
-
-Execute JavaScript in the active tab. Code runs in async context. Use this to extract data, inspect page state, or perform DOM operations programmatically.
-
-## Screenshot
-
-```bash
-{baseDir}/browser-screenshot.js
-```
-
-Capture current viewport and return temporary file path. Use this to visually inspect page state or verify UI changes.
-
-## Pick Elements
-
-```bash
-{baseDir}/browser-pick.js "Click the submit button"
-```
-
-**IMPORTANT**: Use this tool when the user wants to select specific DOM elements on the page. This launches an interactive picker that lets the user click elements to select them. The user can select multiple elements (Cmd/Ctrl+Click) and press Enter when done. The tool returns CSS selectors for the selected elements.
+## Workflow
 
-Common use cases:
-- User says "I want to click that button" → Use this tool to let them select it
-- User says "extract data from these items" → Use this tool to let them select the elements
-- When you need specific selectors but the page structure is complex or ambiguous
+Start with `open` or `goto`, then use `snapshot` before interacting. Prefer snapshot, console, and network output for diagnosis; use screenshots when visual layout matters. Use named sessions with `-s=<session>` when you need to keep multiple browser flows separate.
 
-## Cookies
+If the browser is not installed, run:
 
 ```bash
-{baseDir}/browser-cookies.js
-```
-
-Display all cookies for the current tab including domain, path, httpOnly, and secure flags. Use this to debug authentication issues or inspect session state.
-
-## Extract Page Content
-
-```bash
-{baseDir}/browser-content.js https://example.com
-```
-
-Navigate to a URL and extract readable content as markdown. Uses Mozilla Readability for article extraction and Turndown for HTML-to-markdown conversion. Works on pages with JavaScript content (waits for page to load).
-
-## When to Use
-
-- Testing frontend code in a real browser
-- Interacting with pages that require JavaScript
-- When user needs to visually see or interact with a page
-- Debugging authentication or session issues
-- Scraping dynamic content that requires JS execution
-
----
-
-## Efficiency Guide
-
-### DOM Inspection Over Screenshots
-
-**Don't** take screenshots to see page state. **Do** parse the DOM directly:
-
-```javascript
-// Get page structure
-document.body.innerHTML.slice(0, 5000)
-
-// Find interactive elements
-Array.from(document.querySelectorAll('button, input, [role="button"]')).map(e => ({
-  id: e.id,
-  text: e.textContent.trim(),
-  class: e.className
-}))
-```
-
-### Complex Scripts in Single Calls
-
-Wrap everything in an IIFE to run multi-statement code:
-
-```javascript
-(function() {
-  // Multiple operations
-  const data = document.querySelector('#target').textContent;
-  const buttons = document.querySelectorAll('button');
-  
-  // Interactions
-  buttons[0].click();
-  
-  // Return results
-  return JSON.stringify({ data, buttonCount: buttons.length });
-})()
-```
-
-### Batch Interactions
-
-**Don't** make separate calls for each click. **Do** batch them:
-
-```javascript
-(function() {
-  const actions = ["btn1", "btn2", "btn3"];
-  actions.forEach(id => document.getElementById(id).click());
-  return "Done";
-})()
-```
-
-### Typing/Input Sequences
-
-```javascript
-(function() {
-  const text = "HELLO";
-  for (const char of text) {
-    document.getElementById("key-" + char).click();
-  }
-  document.getElementById("submit").click();
-  return "Submitted: " + text;
-})()
+node <resolvedPath for playwright-cli.js> install-browser chromium
 ```
 
-### Reading App/Game State
-
-Extract structured state in one call:
-
-```javascript
-(function() {
-  const state = {
-    score: document.querySelector('.score')?.textContent,
-    status: document.querySelector('.status')?.className,
-    items: Array.from(document.querySelectorAll('.item')).map(el => ({
-      text: el.textContent,
-      active: el.classList.contains('active')
-    }))
-  };
-  return JSON.stringify(state, null, 2);
-})()
-```
-
-### Waiting for Updates
-
-If DOM updates after actions, add a small delay with bash:
+If a session gets stuck, use:
 
 ```bash
-sleep 0.5 && {baseDir}/browser-eval.js '...'
+node <resolvedPath for playwright-cli.js> close
+node <resolvedPath for playwright-cli.js> kill-all
 ```
-
-### Investigate Before Interacting
-
-Always start by understanding the page structure:
-
-```javascript
-(function() {
-  return {
-    title: document.title,
-    forms: document.forms.length,
-    buttons: document.querySelectorAll('button').length,
-    inputs: document.querySelectorAll('input').length,
-    mainContent: document.body.innerHTML.slice(0, 3000)
-  };
-})()
-```
-
-Then target specific elements based on what you find.

package/dist/builtin/skills/browser-tools/package.json

@@ -1,19 +1,12 @@
 {
 	"name": "browser-tools",
-	"version": "1.1.0",
+	"version": "2.0.0",
 	"type": "module",
-	"description": "Minimal CDP tools for collaborative site exploration",
-	"author": "Mario Zechner",
+	"description": "Microsoft Playwright CLI wrapper for collaborative site exploration",
+	"author": "",
 	"license": "MIT",
-	"dependencies": {
-		"@mozilla/readability": "^0.6.0",
-		"cheerio": "^1.1.2",
-		"jsdom": "^27.0.1",
-		"puppeteer": "^24.31.0",
-		"puppeteer-core": "^23.11.1",
-		"puppeteer-extra": "^3.3.6",
-		"puppeteer-extra-plugin-stealth": "^2.11.2",
-		"turndown": "^7.2.2",
-		"turndown-plugin-gfm": "^1.0.2"
+	"private": true,
+	"pie": {
+		"dependenciesProvidedBy": "@cydm/pie"
 	}
 }

package/dist/builtin/skills/browser-tools/playwright-cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+export function resolvePlaywrightCli() {
+	return require.resolve("@playwright/cli/playwright-cli.js");
+}
+
+export function runPlaywrightCli(args = process.argv.slice(2), options = {}) {
+	const bin = resolvePlaywrightCli();
+	return spawnSync(process.execPath, [bin, ...args], {
+		stdio: "inherit",
+		shell: false,
+		...options,
+	});
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	const result = runPlaywrightCli();
+	process.exitCode = result.status ?? 1;
+}

package/dist/builtin/skills/pie-unity-rpc/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: pie-unity-rpc
+description: Connect to a local pie-unity instance for Unity project discovery, health checks, manifest lookup, and a small set of stable RPC/tool calls. Use when working on a Unity project that imports pie-unity.
+---
+
+# Pie Unity RPC
+
+Use the helper script `pie-unity-rpc.js` to talk to local `pie-unity` instances. Prefer the shell-style host workflow:
+
+1. Discover instances
+2. Select the target project or instance
+3. Check health
+4. Read only the manifest slice you need
+5. Query or inspect Unity state
+6. Edit the scene, read logs, refresh Unity after file changes, or run a frame-scheduled Unity script task
+7. Verify the result
+
+Do not dump the full manifest unless the user explicitly asks for it.
+
+Script resource: `pie-unity-rpc.js`
+
+Command templates below use `<script>` as a placeholder for the resolved script path in the current host.
+
+## Discover
+
+```bash
+node <script> instances
+node <script> instances --project "/abs/path/to/project"
+```
+
+Selection behavior:
+
+- if there is only one active instance, the helper uses it automatically
+- `--project` is treated as a matching hint, not only as an exact path
+- if multiple candidates remain, the helper returns a structured candidate list; show it and ask the user which instance to use
+- prefer `--instance` when the user already knows the target instance ID
+
+## Health
+
+```bash
+node <script> health --project "/abs/path/to/project"
+node <script> health --instance "<instance-id>"
+```
+
+## Manifest
+
+Read only what you need:
+
+```bash
+node <script> manifest --project "/abs/path/to/project"
+node <script> manifest --project "/abs/path/to/project" --namespace chat
+node <script> manifest --project "/abs/path/to/project" --name unity_project_inspect
+```
+
+## Host Workflow
+
+Prefer the host commands over raw `tool` names:
+
+```bash
+node <script> query --project "/abs/path/to/project" --data '{"scope":"scene_object","name":"Main Camera","limit":1}'
+node <script> inspect --project "/abs/path/to/project" --data '{"target":{"path":"Main Camera"}}'
+node <script> edit --project "/abs/path/to/project" --data '{"action":"create_scene_object","name":"CubeA","primitiveType":"Cube","x":0,"y":1,"z":0}'
+node <script> log-read --project "/abs/path/to/project" --data '{"source":"active","tailLines":120,"contains":"error"}'
+```
+
+For Unity project files, use normal Pie file tools rooted at the Unity project. The RPC helper deliberately does not provide separate project file read/write commands.
+
+## Script Run
+
+Use `script-run` only for JavaScript generator tasks that should execute inside Unity. The script must define a generator entrypoint. For multi-frame work, yield `ctx.nextFrame()`, `ctx.waitFrames(n)`, or `ctx.waitSeconds(s)`. The command returns after the task completes, fails, or times out.
+
+```bash
+node <script> script-run --project "/abs/path/to/project" --data '{"script":"export function* run(ctx, args) { return ctx.query({ scope: \"scene_object\", limit: 3 }); }"}'
+node <script> script-run --project "/abs/path/to/project" --data '{"script":"export function* run(ctx, args) { for (let i = 0; i < 60; i++) { ctx.log(\"frame\", i); yield ctx.nextFrame(); } return { ok: true }; }","totalTimeoutMs":10000,"maxFrames":120}'
+```
+
+Do not pass C#, shader source, or raw file contents to `script-run`. Use normal Pie file tools for Unity project files, then call `unity_refresh` through `tool` if Unity must import changed assets. Do not write long synchronous loops. Express long goals as short generator steps that yield between frames.
+
+## Raw Tool / RPC
+
+Use raw `tool` or `rpc` only when the shell-style commands do not cover what you need.
+
+## Retry Behavior
+
+The helper automatically retries when `pie-unity` reports temporary unavailability during compilation or domain reload. Use `--wait-ms` to override the default polling delay.
+
+When using `rpc --method pie_chat.set_config`, the helper waits for the Unity-side `configAppliedVersion` ack when available, then adds a short settle window before returning. Use `--config-settle-ms` to override that delay if needed.
+
+## Guidance
+
+- Start with `instances` if the target Unity project is not yet confirmed.
+- Start with `health` if the project is known.
+- Read this skill contract first. Do not start by scanning the local repo or helper source code unless the task is explicitly about the repo/tooling itself.
+- If a command returns an ambiguous instance error, present the candidate list and ask the user to choose one instance.
+- Read `manifest --namespace unity` or `manifest --namespace unity.script` before using unfamiliar host commands.
+- Once the target `projectPath` is known, keep filesystem exploration scoped to that Unity project. Do not search unrelated repo directories to rediscover the project.
+- For scene setup with named objects such as `Player`, `Goal`, or `Main Camera`, start with `query` for exact names before creating anything.
+- If `query` finds exactly one match, reuse and update it instead of creating a duplicate.
+- If `query` finds multiple matches, do not create another duplicate; inspect/select one explicit result or ask the user.
+- Prefer `query -> inspect -> edit -> inspect` over ad-hoc menu execution. Use `edit` actions `add_component`, `remove_component`, `set_component_enabled`, and `set_component_property` for common scene object component changes instead of writing one-off script-run code.
+- Use normal file tools with the Unity project root for project text files; do not route file access through Unity RPC.
+- Read helper source code only when command behavior is unclear after reading this skill contract or manifest output.
+- After editing C# scripts under `Assets`, call `tool --tool unity_refresh --data {}` if needed, then expect a brief compile/domain-reload window. Re-check `health` or retry the next host command instead of assuming Unity is stuck. If compile/runtime errors appear, use `log-read` instead of guessing.
+- Prefer `script-run` when the task needs filtering, derived values, or multi-frame composition inside Unity.
+
+## Smoke Test
+
+Recommended minimum verification sequence:
+
+```bash
+node <script> health --project "/abs/path/to/project"
+node <script> manifest --project "/abs/path/to/project" --namespace unity
+node <script> tool --project "/abs/path/to/project" --tool chat_send --data '{"text":"respond with exactly pong"}'
+node <script> tool --project "/abs/path/to/project" --tool chat_get_state
+node <script> tool --project "/abs/path/to/project" --tool chat_get_messages
+```
+
+Expected result:
+
+- `chat_get_state` eventually returns `isBusy: false`
+- the final assistant message contains the expected response